xref: /packages/apps/TV/src/com/android/tv/dvr/DvrManager.java

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.tv.dvr;

import android.annotation.TargetApi;
import android.content.ContentProviderOperation;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.content.OperationApplicationException;
import android.media.tv.TvContract;
import android.media.tv.TvInputInfo;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Handler;
import android.os.RemoteException;
import android.support.annotation.MainThread;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.VisibleForTesting;
import android.support.annotation.WorkerThread;
import android.util.Log;
import android.util.Range;
import com.android.tv.TvSingletons;
import com.android.tv.common.SoftPreconditions;
import com.android.tv.common.feature.CommonFeatures;
import com.android.tv.common.util.CommonUtils;
import com.android.tv.data.Program;
import com.android.tv.data.api.Channel;
import com.android.tv.dvr.DvrDataManager.OnRecordedProgramLoadFinishedListener;
import com.android.tv.dvr.DvrDataManager.RecordedProgramListener;
import com.android.tv.dvr.DvrScheduleManager.OnInitializeListener;
import com.android.tv.dvr.data.RecordedProgram;
import com.android.tv.dvr.data.ScheduledRecording;
import com.android.tv.dvr.data.SeriesRecording;
import com.android.tv.util.AsyncDbTask;
import com.android.tv.util.Utils;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.Executor;

/**
 * DVR manager class to add and remove recordings. UI can modify recording list through this class,
 * instead of modifying them directly through {@link DvrDataManager}.
 */
@MainThread
@TargetApi(Build.VERSION_CODES.N)
public class DvrManager {
    private static final String TAG = "DvrManager";
    private static final boolean DEBUG = false;

    private final WritableDvrDataManager mDataManager;
    private final DvrScheduleManager mScheduleManager;
    // @GuardedBy("mListener")
    private final Map<Listener, Handler> mListener = new HashMap<>();
    private final Context mAppContext;
    private final Executor mDbExecutor;

    public DvrManager(Context context) {
        SoftPreconditions.checkFeatureEnabled(context, CommonFeatures.DVR, TAG);
        mAppContext = context.getApplicationContext();
        TvSingletons tvSingletons = TvSingletons.getSingletons(context);
        mDbExecutor = tvSingletons.getDbExecutor();
        mDataManager = (WritableDvrDataManager) tvSingletons.getDvrDataManager();
        mScheduleManager = tvSingletons.getDvrScheduleManager();
        if (mDataManager.isInitialized() && mScheduleManager.isInitialized()) {
            createSeriesRecordingsForRecordedProgramsIfNeeded(mDataManager.getRecordedPrograms());
        } else {
            // No need to handle DVR schedule load finished because schedule manager is initialized
            // after the all the schedules are loaded.
            if (!mDataManager.isRecordedProgramLoadFinished()) {
                mDataManager.addRecordedProgramLoadFinishedListener(
                        new OnRecordedProgramLoadFinishedListener() {
                            @Override
                            public void onRecordedProgramLoadFinished() {
                                mDataManager.removeRecordedProgramLoadFinishedListener(this);
                                if (mDataManager.isInitialized()
                                        && mScheduleManager.isInitialized()) {
                                    createSeriesRecordingsForRecordedProgramsIfNeeded(
                                            mDataManager.getRecordedPrograms());
                                }
                            }
                        });
            }
            if (!mScheduleManager.isInitialized()) {
                mScheduleManager.addOnInitializeListener(
                        new OnInitializeListener() {
                            @Override
                            public void onInitialize() {
                                mScheduleManager.removeOnInitializeListener(this);
                                if (mDataManager.isInitialized()
                                        && mScheduleManager.isInitialized()) {
                                    createSeriesRecordingsForRecordedProgramsIfNeeded(
                                            mDataManager.getRecordedPrograms());
                                }
                            }
                        });
            }
        }
        mDataManager.addRecordedProgramListener(
                new RecordedProgramListener() {
                    @Override
                    public void onRecordedProgramsAdded(RecordedProgram... recordedPrograms) {
                        if (!mDataManager.isInitialized() || !mScheduleManager.isInitialized()) {
                            return;
                        }
                        for (RecordedProgram recordedProgram : recordedPrograms) {
                            createSeriesRecordingForRecordedProgramIfNeeded(recordedProgram);
                        }
                    }

                    @Override
                    public void onRecordedProgramsChanged(RecordedProgram... recordedPrograms) {}

                    @Override
                    public void onRecordedProgramsRemoved(RecordedProgram... recordedPrograms) {
                        // Removing series recording is handled in the
                        // SeriesRecordingDetailsFragment.
                    }
                });
    }

    private void createSeriesRecordingsForRecordedProgramsIfNeeded(
            List<RecordedProgram> recordedPrograms) {
        for (RecordedProgram recordedProgram : recordedPrograms) {
            createSeriesRecordingForRecordedProgramIfNeeded(recordedProgram);
        }
    }

    private void createSeriesRecordingForRecordedProgramIfNeeded(RecordedProgram recordedProgram) {
        if (recordedProgram.isEpisodic()) {
            SeriesRecording seriesRecording =
                    mDataManager.getSeriesRecording(recordedProgram.getSeriesId());
            if (seriesRecording == null) {
                addSeriesRecording(recordedProgram);
            }
        }
    }

    /** Schedules a recording for {@code program}. */
    public ScheduledRecording addSchedule(Program program) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return null;
        }
        SeriesRecording seriesRecording = getSeriesRecording(program);
        return addSchedule(
                program,
                seriesRecording == null
                        ? mScheduleManager.suggestNewPriority()
                        : seriesRecording.getPriority());
    }

    /**
     * Schedules a recording for {@code program} with the highest priority so that the schedule can
     * be recorded.
     */
    public ScheduledRecording addScheduleWithHighestPriority(Program program) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return null;
        }
        SeriesRecording seriesRecording = getSeriesRecording(program);
        return addSchedule(
                program,
                seriesRecording == null
                        ? mScheduleManager.suggestNewPriority()
                        : mScheduleManager.suggestHighestPriority(
                                seriesRecording.getInputId(),
                                new Range(
                                        program.getStartTimeUtcMillis(),
                                        program.getEndTimeUtcMillis()),
                                seriesRecording.getPriority()));
    }

    private ScheduledRecording addSchedule(Program program, long priority) {
        TvInputInfo input = Utils.getTvInputInfoForProgram(mAppContext, program);
        if (input == null) {
            Log.e(TAG, "Can't find input for program: " + program);
            return null;
        }
        ScheduledRecording schedule;
        SeriesRecording seriesRecording = getSeriesRecording(program);
        schedule =
                createScheduledRecordingBuilder(input.getId(), program)
                        .setPriority(priority)
                        .setSeriesRecordingId(
                                seriesRecording == null
                                        ? SeriesRecording.ID_NOT_SET
                                        : seriesRecording.getId())
                        .build();
        mDataManager.addScheduledRecording(schedule);
        return schedule;
    }

    /** Adds a recording schedule with a time range. */
    public void addSchedule(Channel channel, long startTime, long endTime) {
        Log.i(
                TAG,
                "Adding scheduled recording of channel "
                        + channel
                        + " starting at "
                        + Utils.toTimeString(startTime)
                        + " and ending at "
                        + Utils.toTimeString(endTime));
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return;
        }
        TvInputInfo input = Utils.getTvInputInfoForChannelId(mAppContext, channel.getId());
        if (input == null) {
            Log.e(TAG, "Can't find input for channel: " + channel);
            return;
        }
        addScheduleInternal(input.getId(), channel.getId(), startTime, endTime);
    }

    /** Adds the schedule. */
    public void addSchedule(ScheduledRecording schedule) {
        if (mDataManager.isDvrScheduleLoadFinished()) {
            mDataManager.addScheduledRecording(schedule);
        }
    }

    private void addScheduleInternal(String inputId, long channelId, long startTime, long endTime) {
        mDataManager.addScheduledRecording(
                ScheduledRecording.builder(inputId, channelId, startTime, endTime)
                        .setPriority(mScheduleManager.suggestNewPriority())
                        .build());
    }

    /** Adds a new series recording and schedules for the programs with the initial state. */
    public SeriesRecording addSeriesRecording(
            Program selectedProgram,
            List<Program> programsToSchedule,
            @SeriesRecording.SeriesState int initialState) {
        Log.i(
                TAG,
                "Adding series recording for program "
                        + selectedProgram
                        + ", and schedules: "
                        + programsToSchedule);
        if (!SoftPreconditions.checkState(mDataManager.isInitialized())) {
            return null;
        }
        TvInputInfo input = Utils.getTvInputInfoForProgram(mAppContext, selectedProgram);
        if (input == null) {
            Log.e(TAG, "Can't find input for program: " + selectedProgram);
            return null;
        }
        SeriesRecording seriesRecording =
                SeriesRecording.builder(input.getId(), selectedProgram)
                        .setPriority(mScheduleManager.suggestNewSeriesPriority())
                        .setState(initialState)
                        .build();
        mDataManager.addSeriesRecording(seriesRecording);
        // The schedules for the recorded programs should be added not to create the schedule the
        // duplicate episodes.
        addRecordedProgramToSeriesRecording(seriesRecording);
        addScheduleToSeriesRecording(seriesRecording, programsToSchedule);
        return seriesRecording;
    }

    private void addSeriesRecording(RecordedProgram recordedProgram) {
        SeriesRecording seriesRecording =
                SeriesRecording.builder(recordedProgram.getInputId(), recordedProgram)
                        .setPriority(mScheduleManager.suggestNewSeriesPriority())
                        .setState(SeriesRecording.STATE_SERIES_STOPPED)
                        .build();
        mDataManager.addSeriesRecording(seriesRecording);
        // The schedules for the recorded programs should be added not to create the schedule the
        // duplicate episodes.
        addRecordedProgramToSeriesRecording(seriesRecording);
    }

    private void addRecordedProgramToSeriesRecording(SeriesRecording series) {
        List<ScheduledRecording> toAdd = new ArrayList<>();
        for (RecordedProgram recordedProgram : mDataManager.getRecordedPrograms()) {
            if (series.getSeriesId().equals(recordedProgram.getSeriesId())
                    && !recordedProgram.isClipped()) {
                // Duplicate schedules can exist, but they will be deleted in a few days. And it's
                // also guaranteed that the schedules don't belong to any series recordings because
                // there are no more than one series recordings which have the same program title.
                toAdd.add(
                        ScheduledRecording.builder(recordedProgram)
                                .setPriority(series.getPriority())
                                .setSeriesRecordingId(series.getId())
                                .build());
            }
        }
        if (!toAdd.isEmpty()) {
            mDataManager.addScheduledRecording(ScheduledRecording.toArray(toAdd));
        }
    }

    /**
     * Adds {@link ScheduledRecording}s for the series recording.
     *
     * <p>This method doesn't add the series recording.
     */
    public void addScheduleToSeriesRecording(
            SeriesRecording series, List<Program> programsToSchedule) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return;
        }
        TvInputInfo input = Utils.getTvInputInfoForInputId(mAppContext, series.getInputId());
        if (input == null) {
            Log.e(TAG, "Can't find input with ID: " + series.getInputId());
            return;
        }
        List<ScheduledRecording> toAdd = new ArrayList<>();
        List<ScheduledRecording> toUpdate = new ArrayList<>();
        for (Program program : programsToSchedule) {
            ScheduledRecording scheduleWithSameProgram =
                    mDataManager.getScheduledRecordingForProgramId(program.getId());
            if (scheduleWithSameProgram != null) {
                if (scheduleWithSameProgram.isNotStarted()) {
                    ScheduledRecording r =
                            ScheduledRecording.buildFrom(scheduleWithSameProgram)
                                    .setSeriesRecordingId(series.getId())
                                    .build();
                    if (!r.equals(scheduleWithSameProgram)) {
                        toUpdate.add(r);
                    }
                }
            } else {
                toAdd.add(
                        createScheduledRecordingBuilder(input.getId(), program)
                                .setPriority(series.getPriority())
                                .setSeriesRecordingId(series.getId())
                                .build());
            }
        }
        if (!toAdd.isEmpty()) {
            mDataManager.addScheduledRecording(ScheduledRecording.toArray(toAdd));
        }
        if (!toUpdate.isEmpty()) {
            mDataManager.updateScheduledRecording(ScheduledRecording.toArray(toUpdate));
        }
    }

    /** Updates the series recording. */
    public void updateSeriesRecording(SeriesRecording series) {
        if (SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            SeriesRecording previousSeries = mDataManager.getSeriesRecording(series.getId());
            if (previousSeries != null) {
                // If the channel option of series changed, remove the existing schedules. The new
                // schedules will be added by SeriesRecordingScheduler or by SeriesSettingsFragment.
                if (previousSeries.getChannelOption() != series.getChannelOption()
                        || (previousSeries.getChannelOption() == SeriesRecording.OPTION_CHANNEL_ONE
                                && previousSeries.getChannelId() != series.getChannelId())) {
                    List<ScheduledRecording> schedules =
                            mDataManager.getScheduledRecordings(series.getId());
                    List<ScheduledRecording> schedulesToRemove = new ArrayList<>();
                    for (ScheduledRecording schedule : schedules) {
                        if (schedule.isNotStarted()) {
                            schedulesToRemove.add(schedule);
                        } else if (schedule.isInProgress()
                                && series.getChannelOption() == SeriesRecording.OPTION_CHANNEL_ONE
                                && schedule.getChannelId() != series.getChannelId()) {
                            stopRecording(schedule);
                        }
                    }
                    List<ScheduledRecording> deletedSchedules =
                            new ArrayList<>(mDataManager.getDeletedSchedules());
                    for (ScheduledRecording deletedSchedule : deletedSchedules) {
                        if (deletedSchedule.getSeriesRecordingId() == series.getId()
                                && deletedSchedule.getEndTimeMs() > System.currentTimeMillis()) {
                            schedulesToRemove.add(deletedSchedule);
                        }
                    }
                    mDataManager.removeScheduledRecording(
                            true, ScheduledRecording.toArray(schedulesToRemove));
                }
            }
            mDataManager.updateSeriesRecording(series);
            if (previousSeries == null || previousSeries.getPriority() != series.getPriority()) {
                long priority = series.getPriority();
                List<ScheduledRecording> schedulesToUpdate = new ArrayList<>();
                for (ScheduledRecording schedule :
                        mDataManager.getScheduledRecordings(series.getId())) {
                    if (schedule.isNotStarted() || schedule.isInProgress()) {
                        schedulesToUpdate.add(
                                ScheduledRecording.buildFrom(schedule)
                                        .setPriority(priority)
                                        .build());
                    }
                }
                if (!schedulesToUpdate.isEmpty()) {
                    mDataManager.updateScheduledRecording(
                            ScheduledRecording.toArray(schedulesToUpdate));
                }
            }
        }
    }

    /**
     * Removes the series recording and all the corresponding schedules which are not started yet.
     */
    public void removeSeriesRecording(long seriesRecordingId) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return;
        }
        SeriesRecording series = mDataManager.getSeriesRecording(seriesRecordingId);
        if (series == null) {
            return;
        }
        for (ScheduledRecording schedule : mDataManager.getAllScheduledRecordings()) {
            if (schedule.getSeriesRecordingId() == seriesRecordingId) {
                if (schedule.getState() == ScheduledRecording.STATE_RECORDING_IN_PROGRESS) {
                    stopRecording(schedule);
                    break;
                }
            }
        }
        mDataManager.removeSeriesRecording(series);
    }

    /** Stops the currently recorded program */
    public void stopRecording(final ScheduledRecording recording) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return;
        }
        synchronized (mListener) {
            for (final Entry<Listener, Handler> entry : mListener.entrySet()) {
                entry.getValue()
                        .post(
                                new Runnable() {
                                    @Override
                                    public void run() {
                                        entry.getKey().onStopRecordingRequested(recording);
                                    }
                                });
            }
        }
    }

    /** Removes scheduled recordings or an existing recordings. */
    public void removeScheduledRecording(ScheduledRecording... schedules) {
        Log.i(TAG, "Removing " + Arrays.asList(schedules));
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return;
        }
        for (ScheduledRecording r : schedules) {
            if (r.getState() == ScheduledRecording.STATE_RECORDING_IN_PROGRESS) {
                stopRecording(r);
            } else {
                mDataManager.removeScheduledRecording(r);
            }
        }
    }

    /** Removes scheduled recordings without changing to the DELETED state. */
    public void forceRemoveScheduledRecording(ScheduledRecording... schedules) {
        Log.i(TAG, "Force removing " + Arrays.asList(schedules));
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return;
        }
        for (ScheduledRecording r : schedules) {
            if (r.getState() == ScheduledRecording.STATE_RECORDING_IN_PROGRESS) {
                stopRecording(r);
            } else {
                mDataManager.removeScheduledRecording(true, r);
            }
        }
    }

    /** Removes the recorded program. It deletes the file if possible. */
    public void removeRecordedProgram(Uri recordedProgramUri) {
        if (!SoftPreconditions.checkState(mDataManager.isInitialized())) {
            return;
        }
        removeRecordedProgram(ContentUris.parseId(recordedProgramUri));
    }

    /** Removes the recorded program. It deletes the file if possible. */
    public void removeRecordedProgram(long recordedProgramId) {
        if (!SoftPreconditions.checkState(mDataManager.isInitialized())) {
            return;
        }
        RecordedProgram recordedProgram = mDataManager.getRecordedProgram(recordedProgramId);
        if (recordedProgram != null) {
            removeRecordedProgram(recordedProgram);
        }
    }

    /** Removes the recorded program. It deletes the file if possible. */
    public void removeRecordedProgram(final RecordedProgram recordedProgram) {
        if (!SoftPreconditions.checkState(mDataManager.isInitialized())) {
            return;
        }
        new AsyncDbTask<Void, Void, Integer>(mDbExecutor) {
            @Override
            protected Integer doInBackground(Void... params) {
                ContentResolver resolver = mAppContext.getContentResolver();
                return resolver.delete(recordedProgram.getUri(), null, null);
            }

            @Override
            protected void onPostExecute(Integer deletedCounts) {
                if (deletedCounts > 0) {
                    new AsyncTask<Void, Void, Void>() {
                        @Override
                        protected Void doInBackground(Void... params) {
                            removeRecordedData(recordedProgram.getDataUri());
                            return null;
                        }
                    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
                }
            }
        }.executeOnDbThread();
    }

    public void removeRecordedPrograms(List<Long> recordedProgramIds) {
        final ArrayList<ContentProviderOperation> dbOperations = new ArrayList<>();
        final List<Uri> dataUris = new ArrayList<>();
        for (Long rId : recordedProgramIds) {
            RecordedProgram r = mDataManager.getRecordedProgram(rId);
            if (r != null) {
                dataUris.add(r.getDataUri());
                dbOperations.add(ContentProviderOperation.newDelete(r.getUri()).build());
            }
        }
        new AsyncDbTask<Void, Void, Boolean>(mDbExecutor) {
            @Override
            protected Boolean doInBackground(Void... params) {
                ContentResolver resolver = mAppContext.getContentResolver();
                try {
                    resolver.applyBatch(TvContract.AUTHORITY, dbOperations);
                } catch (RemoteException | OperationApplicationException e) {
                    Log.w(TAG, "Remove recorded programs from DB failed.", e);
                    return false;
                }
                return true;
            }

            @Override
            protected void onPostExecute(Boolean success) {
                if (success) {
                    new AsyncTask<Void, Void, Void>() {
                        @Override
                        protected Void doInBackground(Void... params) {
                            for (Uri dataUri : dataUris) {
                                removeRecordedData(dataUri);
                            }
                            return null;
                        }
                    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
                }
            }
        }.executeOnDbThread();
    }

    /** Updates the scheduled recording. */
    public void updateScheduledRecording(ScheduledRecording recording) {
        if (SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            mDataManager.updateScheduledRecording(recording);
        }
    }

    /**
     * Returns priority ordered list of all scheduled recordings that will not be recorded if this
     * program is.
     *
     * @see DvrScheduleManager#getConflictingSchedules(Program)
     */
    public List<ScheduledRecording> getConflictingSchedules(Program program) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return Collections.emptyList();
        }
        return mScheduleManager.getConflictingSchedules(program);
    }

    /**
     * Returns priority ordered list of all scheduled recordings that will not be recorded if this
     * channel is.
     *
     * @see DvrScheduleManager#getConflictingSchedules(long, long, long)
     */
    public List<ScheduledRecording> getConflictingSchedules(
            long channelId, long startTimeMs, long endTimeMs) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return Collections.emptyList();
        }
        return mScheduleManager.getConflictingSchedules(channelId, startTimeMs, endTimeMs);
    }

    /**
     * Checks if the schedule is conflicting.
     *
     * <p>Note that the {@code schedule} should be the existing one. If not, this returns {@code
     * false}.
     */
    public boolean isConflicting(ScheduledRecording schedule) {
        return schedule != null
                && SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())
                && mScheduleManager.isConflicting(schedule);
    }

    /**
     * Returns priority ordered list of all scheduled recording that will not be recorded if this
     * channel is tuned to.
     *
     * @see DvrScheduleManager#getConflictingSchedulesForTune
     */
    public List<ScheduledRecording> getConflictingSchedulesForTune(long channelId) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return Collections.emptyList();
        }
        return mScheduleManager.getConflictingSchedulesForTune(channelId);
    }

    /** Sets the highest priority to the schedule. */
    public void setHighestPriority(ScheduledRecording schedule) {
        if (SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            long newPriority = mScheduleManager.suggestHighestPriority(schedule);
            if (newPriority != schedule.getPriority()) {
                mDataManager.updateScheduledRecording(
                        ScheduledRecording.buildFrom(schedule).setPriority(newPriority).build());
            }
        }
    }

    /** Suggests the higher priority than the schedules which overlap with {@code schedule}. */
    public long suggestHighestPriority(ScheduledRecording schedule) {
        if (SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return mScheduleManager.suggestHighestPriority(schedule);
        }
        return DvrScheduleManager.DEFAULT_PRIORITY;
    }

    /**
     * Returns {@code true} if the channel can be recorded.
     *
     * <p>Note that this method doesn't check the conflict of the schedule or available tuners. This
     * can be called from the UI before the schedules are loaded.
     */
    public boolean isChannelRecordable(Channel channel) {
        if (!mDataManager.isDvrScheduleLoadFinished() || channel == null) {
            return false;
        }
        if (channel.isRecordingProhibited()) {
            return false;
        }
        TvInputInfo info = Utils.getTvInputInfoForChannelId(mAppContext, channel.getId());
        if (info == null) {
            Log.w(TAG, "Could not find TvInputInfo for " + channel);
            return false;
        }
        if (!info.canRecord()) {
            return false;
        }
        Program program =
                TvSingletons.getSingletons(mAppContext)
                        .getProgramDataManager()
                        .getCurrentProgram(channel.getId());
        return program == null || !program.isRecordingProhibited();
    }

    /**
     * Returns {@code true} if the program can be recorded.
     *
     * <p>Note that this method doesn't check the conflict of the schedule or available tuners. This
     * can be called from the UI before the schedules are loaded.
     */
    public boolean isProgramRecordable(Program program) {
        if (!mDataManager.isInitialized()) {
            return false;
        }
        Channel channel =
                TvSingletons.getSingletons(mAppContext)
                        .getChannelDataManager()
                        .getChannel(program.getChannelId());
        if (channel == null || channel.isRecordingProhibited()) {
            return false;
        }
        TvInputInfo info = Utils.getTvInputInfoForChannelId(mAppContext, channel.getId());
        if (info == null) {
            Log.w(TAG, "Could not find TvInputInfo for " + program);
            return false;
        }
        return info.canRecord() && !program.isRecordingProhibited();
    }

    /**
     * Returns the current recording for the channel.
     *
     * <p>This can be called from the UI before the schedules are loaded.
     */
    public ScheduledRecording getCurrentRecording(long channelId) {
        if (!mDataManager.isDvrScheduleLoadFinished()) {
            return null;
        }
        for (ScheduledRecording recording : mDataManager.getStartedRecordings()) {
            if (recording.getChannelId() == channelId) {
                return recording;
            }
        }
        return null;
    }

    /**
     * Returns schedules which is available (i.e., isNotStarted or isInProgress) and belongs to the
     * series recording {@code seriesRecordingId}.
     */
    public List<ScheduledRecording> getAvailableScheduledRecording(long seriesRecordingId) {
        if (!mDataManager.isDvrScheduleLoadFinished()) {
            return Collections.emptyList();
        }
        List<ScheduledRecording> schedules = new ArrayList<>();
        for (ScheduledRecording schedule : mDataManager.getScheduledRecordings(seriesRecordingId)) {
            if (schedule.isInProgress() || schedule.isNotStarted()) {
                schedules.add(schedule);
            }
        }
        return schedules;
    }

    /** Returns the series recording related to the program. */
    @Nullable
    public SeriesRecording getSeriesRecording(Program program) {
        if (!SoftPreconditions.checkState(mDataManager.isDvrScheduleLoadFinished())) {
            return null;
        }
        return mDataManager.getSeriesRecording(program.getSeriesId());
    }

    /**
     * Returns if there are valid items. Valid item contains {@link RecordedProgram}, available
     * {@link ScheduledRecording} and {@link SeriesRecording}.
     */
    public boolean hasValidItems() {
        return !(mDataManager.getRecordedPrograms().isEmpty()
                && mDataManager.getStartedRecordings().isEmpty()
                && mDataManager.getNonStartedScheduledRecordings().isEmpty()
                && mDataManager.getSeriesRecordings().isEmpty());
    }

    @WorkerThread
    @VisibleForTesting
    // Should be public to use mock DvrManager object.
    public void addListener(Listener listener, @NonNull Handler handler) {
        SoftPreconditions.checkNotNull(handler);
        synchronized (mListener) {
            mListener.put(listener, handler);
        }
    }

    @WorkerThread
    @VisibleForTesting
    // Should be public to use mock DvrManager object.
    public void removeListener(Listener listener) {
        synchronized (mListener) {
            mListener.remove(listener);
        }
    }

    /**
     * Returns ScheduledRecording.builder based on {@code program}. If program is already started,
     * recording started time is clipped to the current time.
     */
    private ScheduledRecording.Builder createScheduledRecordingBuilder(
            String inputId, Program program) {
        ScheduledRecording.Builder builder = ScheduledRecording.builder(inputId, program);
        long time = System.currentTimeMillis();
        if (program.getStartTimeUtcMillis() < time && time < program.getEndTimeUtcMillis()) {
            builder.setStartTimeMs(time);
        }
        return builder;
    }

    /** Returns a schedule which matches to the given episode. */
    public ScheduledRecording getScheduledRecording(
            String title, String seasonNumber, String episodeNumber) {
        if (!SoftPreconditions.checkState(mDataManager.isInitialized())
                || title == null
                || seasonNumber == null
                || episodeNumber == null) {
            return null;
        }
        for (ScheduledRecording r : mDataManager.getAllScheduledRecordings()) {
            if (title.equals(r.getProgramTitle())
                    && seasonNumber.equals(r.getSeasonNumber())
                    && episodeNumber.equals(r.getEpisodeNumber())) {
                return r;
            }
        }
        return null;
    }

    /** Returns a recorded program which is the same episode as the given {@code program}. */
    public RecordedProgram getRecordedProgram(
            String title, String seasonNumber, String episodeNumber) {
        if (!SoftPreconditions.checkState(mDataManager.isInitialized())
                || title == null
                || seasonNumber == null
                || episodeNumber == null) {
            return null;
        }
        for (RecordedProgram r : mDataManager.getRecordedPrograms()) {
            if (title.equals(r.getTitle())
                    && seasonNumber.equals(r.getSeasonNumber())
                    && episodeNumber.equals(r.getEpisodeNumber())
                    && !r.isClipped()) {
                return r;
            }
        }
        return null;
    }

    @WorkerThread
    private void removeRecordedData(Uri dataUri) {
        try {
            if (dataUri != null
                    && ContentResolver.SCHEME_FILE.equals(dataUri.getScheme())
                    && dataUri.getPath() != null) {
                File recordedProgramPath = new File(dataUri.getPath());
                if (!recordedProgramPath.exists()) {
                    if (DEBUG) Log.d(TAG, "File to delete not exist: " + recordedProgramPath);
                } else {
                    CommonUtils.deleteDirOrFile(recordedProgramPath);
                    if (DEBUG) {
                        Log.d(TAG, "Sucessfully deleted files of the recorded program: " + dataUri);
                    }
                }
            }
        } catch (SecurityException e) {
            if (DEBUG) {
                Log.d(
                        TAG,
                        "To delete this recorded program, please manually delete video data at"
                                + "\nadb shell rm -rf "
                                + dataUri);
            }
        }
    }

    /**
     * Remove all the records related to the input.
     *
     * <p>Note that this should be called after the input was removed.
     */
    public void forgetStorage(String inputId) {
        if (mDataManager.isInitialized()) {
            mDataManager.forgetStorage(inputId);
        }
    }

    /**
     * Listener to stop recording request. Should only be internally used inside dvr and its
     * sub-package.
     */
    public interface Listener {
        void onStopRecordingRequested(ScheduledRecording scheduledRecording);
    }
}