path: root/src/com/android/tv/dvr/Scheduler.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.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.media.tv.TvInputInfo;
import android.media.tv.TvInputManager.TvInputCallback;
import android.os.Looper;
import android.support.annotation.MainThread;
import android.support.annotation.VisibleForTesting;
import android.util.ArrayMap;
import android.util.Log;
import android.util.Range;

import com.android.tv.InputSessionManager;
import com.android.tv.data.ChannelDataManager;
import com.android.tv.data.ChannelDataManager.Listener;
import com.android.tv.dvr.DvrDataManager.OnDvrScheduleLoadFinishedListener;
import com.android.tv.dvr.DvrDataManager.ScheduledRecordingListener;
import com.android.tv.util.Clock;
import com.android.tv.util.TvInputManagerHelper;
import com.android.tv.util.Utils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * The core class to manage schedule and run actual recording.
 */
@MainThread
public class Scheduler extends TvInputCallback implements ScheduledRecordingListener {
    private static final String TAG = "Scheduler";
    private static final boolean DEBUG = false;

    private final static long SOON_DURATION_IN_MS = TimeUnit.MINUTES.toMillis(5);
    @VisibleForTesting final static long MS_TO_WAKE_BEFORE_START = TimeUnit.MINUTES.toMillis(1);

    private final Looper mLooper;
    private final InputSessionManager mSessionManager;
    private final WritableDvrDataManager mDataManager;
    private final DvrManager mDvrManager;
    private final ChannelDataManager mChannelDataManager;
    private final TvInputManagerHelper mInputManager;
    private final Context mContext;
    private final Clock mClock;
    private final AlarmManager mAlarmManager;

    private final Map<String, InputTaskScheduler> mInputSchedulerMap = new ArrayMap<>();
    private long mLastStartTimePendingMs;

    public Scheduler(Looper looper, DvrManager dvrManager, InputSessionManager sessionManager,
            WritableDvrDataManager dataManager, ChannelDataManager channelDataManager,
            TvInputManagerHelper inputManager, Context context, Clock clock,
            AlarmManager alarmManager) {
        mLooper = looper;
        mDvrManager = dvrManager;
        mSessionManager = sessionManager;
        mDataManager = dataManager;
        mChannelDataManager = channelDataManager;
        mInputManager = inputManager;
        mContext = context;
        mClock = clock;
        mAlarmManager = alarmManager;
    }

    /**
     * Starts the scheduler.
     */
    public void start() {
        mDataManager.addScheduledRecordingListener(this);
        mInputManager.addCallback(this);
        if (mDataManager.isDvrScheduleLoadFinished() && mChannelDataManager.isDbLoadFinished()) {
            updateInternal();
        } else {
            if (!mDataManager.isDvrScheduleLoadFinished()) {
                mDataManager.addDvrScheduleLoadFinishedListener(
                        new OnDvrScheduleLoadFinishedListener() {
                            @Override
                            public void onDvrScheduleLoadFinished() {
                                mDataManager.removeDvrScheduleLoadFinishedListener(this);
                                updateInternal();
                            }
                        });
            }
            if (!mChannelDataManager.isDbLoadFinished()) {
                mChannelDataManager.addListener(new Listener() {
                    @Override
                    public void onLoadFinished() {
                        mChannelDataManager.removeListener(this);
                        updateInternal();
                    }

                    @Override
                    public void onChannelListUpdated() { }

                    @Override
                    public void onChannelBrowsableChanged() { }
                });
            }
        }
    }

    /**
     * Stops the scheduler.
     */
    public void stop() {
        for (InputTaskScheduler inputTaskScheduler : mInputSchedulerMap.values()) {
            inputTaskScheduler.stop();
        }
        mInputManager.removeCallback(this);
        mDataManager.removeScheduledRecordingListener(this);
    }

    private void updatePendingRecordings() {
        List<ScheduledRecording> scheduledRecordings = mDataManager
                .getScheduledRecordings(new Range<>(mLastStartTimePendingMs,
                        mClock.currentTimeMillis() + SOON_DURATION_IN_MS),
                        ScheduledRecording.STATE_RECORDING_NOT_STARTED);
        for (ScheduledRecording r : scheduledRecordings) {
            scheduleRecordingSoon(r);
        }
    }

    /**
     * Start recording that will happen soon, and set the next alarm time.
     */
    public void update() {
        if (DEBUG) Log.d(TAG, "update");
        updateInternal();
    }

    private void updateInternal() {
        if (isInitialized()) {
            updatePendingRecordings();
            updateNextAlarm();
        }
    }

    private boolean isInitialized() {
        return mDataManager.isDvrScheduleLoadFinished() && mChannelDataManager.isDbLoadFinished();
    }

    @Override
    public void onScheduledRecordingAdded(ScheduledRecording... schedules) {
        if (DEBUG) Log.d(TAG, "added " + Arrays.asList(schedules));
        if (!isInitialized()) {
            return;
        }
        handleScheduleChange(schedules);
    }

    @Override
    public void onScheduledRecordingRemoved(ScheduledRecording... schedules) {
        if (DEBUG) Log.d(TAG, "removed " + Arrays.asList(schedules));
        if (!isInitialized()) {
            return;
        }
        boolean needToUpdateAlarm = false;
        for (ScheduledRecording schedule : schedules) {
            InputTaskScheduler scheduler = mInputSchedulerMap.get(schedule.getInputId());
            if (scheduler != null) {
                scheduler.removeSchedule(schedule);
                needToUpdateAlarm = true;
            }
        }
        if (needToUpdateAlarm) {
            updateNextAlarm();
        }
    }

    @Override
    public void onScheduledRecordingStatusChanged(ScheduledRecording... schedules) {
        if (DEBUG) Log.d(TAG, "state changed " + Arrays.asList(schedules));
        if (!isInitialized()) {
            return;
        }
        // Update the recordings.
        for (ScheduledRecording schedule : schedules) {
            InputTaskScheduler scheduler = mInputSchedulerMap.get(schedule.getInputId());
            if (scheduler != null) {
                scheduler.updateSchedule(schedule);
            }
        }
        handleScheduleChange(schedules);
    }

    private void handleScheduleChange(ScheduledRecording... schedules) {
        boolean needToUpdateAlarm = false;
        for (ScheduledRecording schedule : schedules) {
            if (schedule.getState() == ScheduledRecording.STATE_RECORDING_NOT_STARTED) {
                if (startsWithin(schedule, SOON_DURATION_IN_MS)) {
                    scheduleRecordingSoon(schedule);
                } else {
                    needToUpdateAlarm = true;
                }
            }
        }
        if (needToUpdateAlarm) {
            updateNextAlarm();
        }
    }

    private void scheduleRecordingSoon(ScheduledRecording schedule) {
        TvInputInfo input = Utils.getTvInputInfoForInputId(mContext, schedule.getInputId());
        if (input == null) {
            Log.e(TAG, "Can't find input for " + schedule);
            mDataManager.changeState(schedule, ScheduledRecording.STATE_RECORDING_FAILED);
            return;
        }
        if (!input.canRecord() || input.getTunerCount() <= 0) {
            Log.e(TAG, "TV input doesn't support recording: " + input);
            mDataManager.changeState(schedule, ScheduledRecording.STATE_RECORDING_FAILED);
            return;
        }
        InputTaskScheduler scheduler = mInputSchedulerMap.get(input.getId());
        if (scheduler == null) {
            scheduler = new InputTaskScheduler(mContext, input, mLooper, mChannelDataManager,
                    mDvrManager, mDataManager, mSessionManager, mClock);
            mInputSchedulerMap.put(input.getId(), scheduler);
        }
        scheduler.addSchedule(schedule);
        if (mLastStartTimePendingMs < schedule.getStartTimeMs()) {
            mLastStartTimePendingMs = schedule.getStartTimeMs();
        }
    }

    private void updateNextAlarm() {
        long nextStartTime = mDataManager.getNextScheduledStartTimeAfter(
                Math.max(mLastStartTimePendingMs, mClock.currentTimeMillis()));
        if (nextStartTime != DvrDataManager.NEXT_START_TIME_NOT_FOUND) {
            long wakeAt = nextStartTime - MS_TO_WAKE_BEFORE_START;
            if (DEBUG) Log.d(TAG, "Set alarm to record at " + wakeAt);
            Intent intent = new Intent(mContext, DvrStartRecordingReceiver.class);
            PendingIntent alarmIntent = PendingIntent.getBroadcast(mContext, 0, intent, 0);
            // This will cancel the previous alarm.
            mAlarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, wakeAt, alarmIntent);
        } else {
            if (DEBUG) Log.d(TAG, "No future recording, alarm not set");
        }
    }

    @VisibleForTesting
    boolean startsWithin(ScheduledRecording scheduledRecording, long durationInMs) {
        return mClock.currentTimeMillis() >= scheduledRecording.getStartTimeMs() - durationInMs;
    }

    // No need to remove input task scheduler when the input is removed. If the input is removed
    // temporarily, the scheduler should keep the non-started schedules.
    @Override
    public void onInputUpdated(String inputId) {
        InputTaskScheduler scheduler = mInputSchedulerMap.get(inputId);
        if (scheduler != null) {
            scheduler.updateTvInputInfo(Utils.getTvInputInfoForInputId(mContext, inputId));
        }
    }

    @Override
    public void onTvInputInfoUpdated(TvInputInfo input) {
        InputTaskScheduler scheduler = mInputSchedulerMap.get(input.getId());
        if (scheduler != null) {
            scheduler.updateTvInputInfo(input);
        }
    }
}