src/com/android/tv/dvr/RecordingTask.java - platform/packages/apps/TV - Git at Google

 /*
  * 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.media.tv.TvContract;
 import android.media.tv.TvRecordingClient;
 import android.net.Uri;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 import android.support.annotation.VisibleForTesting;
 import android.support.annotation.WorkerThread;
 import android.util.Log;

 import com.android.tv.common.SoftPreconditions;
 import com.android.tv.data.Channel;
 import com.android.tv.util.Clock;
 import com.android.tv.util.Utils;

 import java.util.concurrent.TimeUnit;

 /**
  * A Handler that actually starts and stop a recording at the right time.
  *
  * <p>This is run on the looper of thread named {@value DvrRecordingService#HANDLER_THREAD_NAME}.
  * There is only one looper so messages must be handled quickly or start a separate thread.
  */
 @WorkerThread
 class RecordingTask extends TvRecordingClient.RecordingCallback
         implements Handler.Callback, DvrManager.Listener {
     private static final String TAG = "RecordingTask";
     private static final boolean DEBUG = false;

     @VisibleForTesting
     static final int MESSAGE_INIT = 1;
     @VisibleForTesting
     static final int MESSAGE_START_RECORDING = 2;
     @VisibleForTesting
     static final int MESSAGE_STOP_RECORDING = 3;

     @VisibleForTesting
     static final long MS_BEFORE_START = TimeUnit.SECONDS.toMillis(5);
     @VisibleForTesting
     static final long MS_AFTER_END = TimeUnit.SECONDS.toMillis(5);

     @VisibleForTesting
     enum State {
         NOT_STARTED,
         SESSION_ACQUIRED,
         CONNECTION_PENDING,
         CONNECTED,
         RECORDING_START_REQUESTED,
         RECORDING_STARTED,
         RECORDING_STOP_REQUESTED,
         ERROR,
         RELEASED,
     }
     private final DvrSessionManager mSessionManager;
     private final DvrManager mDvrManager;

     private final WritableDvrDataManager mDataManager;
     private final Handler mMainThreadHandler = new Handler(Looper.getMainLooper());
     private TvRecordingClient mTvRecordingClient;
     private Handler mHandler;
     private ScheduledRecording mScheduledRecording;
     private final Channel mChannel;
     private State mState = State.NOT_STARTED;
     private final Clock mClock;

     RecordingTask(ScheduledRecording scheduledRecording, Channel channel,
             DvrManager dvrManager, DvrSessionManager sessionManager,
             WritableDvrDataManager dataManager, Clock clock) {
         mScheduledRecording = scheduledRecording;
         mChannel = channel;
         mSessionManager = sessionManager;
         mDataManager = dataManager;
         mClock = clock;
         mDvrManager = dvrManager;

         if (DEBUG) Log.d(TAG, "created recording task " + mScheduledRecording);
     }

     public void setHandler(Handler handler) {
         mHandler = handler;
     }

     @Override
     public boolean handleMessage(Message msg) {
         if (DEBUG) Log.d(TAG, "handleMessage " + msg);
         SoftPreconditions
                 .checkState(msg.what == Scheduler.HandlerWrapper.MESSAGE_REMOVE || mHandler != null,
                         TAG, "Null handler trying to handle " + msg);
         try {
             switch (msg.what) {
                 case MESSAGE_INIT:
                     handleInit();
                     break;
                 case MESSAGE_START_RECORDING:
                     handleStartRecording();
                     break;
                 case MESSAGE_STOP_RECORDING:
                     handleStopRecording();
                     break;
                 case Scheduler.HandlerWrapper.MESSAGE_REMOVE:
                     // Clear the handler
                     mHandler = null;
                     release();
                     return false;
                 default:
                     SoftPreconditions.checkArgument(false, TAG, "unexpected message type " + msg);
             }
             return true;
         } catch (Exception e) {
             Log.w(TAG, "Error processing message " + msg + "  for " + mScheduledRecording, e);
             failAndQuit();
         }
         return false;
     }

     @Override
     public void onTuned(Uri channelUri) {
         if (DEBUG) {
             Log.d(TAG, "onTuned");
         }
         super.onTuned(channelUri);
         mState = State.CONNECTED;
         if (mHandler == null || !sendEmptyMessageAtAbsoluteTime(MESSAGE_START_RECORDING,
                 mScheduledRecording.getStartTimeMs() - MS_BEFORE_START)) {
             mState = State.ERROR;
             return;
         }
     }


     @Override
     public void onRecordingStopped(Uri recordedProgramUri) {
         super.onRecordingStopped(recordedProgramUri);
         mState = State.CONNECTED;
         updateRecording(ScheduledRecording.buildFrom(mScheduledRecording)
                 .setState(ScheduledRecording.STATE_RECORDING_FINISHED).build());
         sendRemove();
     }

     @Override
     public void onError(int reason) {
         if (DEBUG) Log.d(TAG, "onError reason " + reason);
         super.onError(reason);
         // TODO(dvr) handle success
         switch (reason) {
             default:
                 updateRecording(ScheduledRecording.buildFrom(mScheduledRecording)
                         .setState(ScheduledRecording.STATE_RECORDING_FAILED)
                         .build());
         }
         release();
         sendRemove();
     }

     private void handleInit() {
         if (DEBUG) Log.d(TAG, "handleInit " + mScheduledRecording);
         //TODO check recording preconditions

         if (mScheduledRecording.getEndTimeMs() < mClock.currentTimeMillis()) {
             Log.w(TAG, "End time already past, not recording " + mScheduledRecording);
             failAndQuit();
             return;
         }

         if (mChannel == null) {
             Log.w(TAG, "Null channel for " + mScheduledRecording);
             failAndQuit();
             return;
         }
         if (mChannel.getId() != mScheduledRecording.getChannelId()) {
             Log.w(TAG, "Channel" + mChannel + " does not match scheduled recording "
                     + mScheduledRecording);
             failAndQuit();
             return;
         }

         String inputId = mChannel.getInputId();
         if (mSessionManager.canAcquireDvrSession(inputId, mChannel)) {
             mTvRecordingClient = mSessionManager
                     .createTvRecordingClient("recordingTask-" + mScheduledRecording.getId(), this,
                             mHandler);
             mState = State.SESSION_ACQUIRED;
         } else {
             Log.w(TAG, "Unable to acquire a session for " + mScheduledRecording);
             failAndQuit();
             return;
         }
         mDvrManager.addListener(this, mHandler);
         mTvRecordingClient.tune(inputId, mChannel.getUri());
         mState = State.CONNECTION_PENDING;
     }

     private void failAndQuit() {
         if (DEBUG) Log.d(TAG, "failAndQuit");
         updateRecordingState(ScheduledRecording.STATE_RECORDING_FAILED);
         mState = State.ERROR;
         sendRemove();
     }

     private void sendRemove() {
         if (DEBUG) Log.d(TAG, "sendRemove");
         if (mHandler != null) {
             mHandler.sendEmptyMessage(Scheduler.HandlerWrapper.MESSAGE_REMOVE);
         }
     }

     private void handleStartRecording() {
         if (DEBUG) Log.d(TAG, "handleStartRecording " + mScheduledRecording);
         // TODO(DVR) handle errors
         long programId = mScheduledRecording.getProgramId();
         mTvRecordingClient.startRecording(programId == ScheduledRecording.ID_NOT_SET ? null
                 : TvContract.buildProgramUri(programId));
         updateRecording(ScheduledRecording.buildFrom(mScheduledRecording)
                 .setState(ScheduledRecording.STATE_RECORDING_IN_PROGRESS).build());
         mState = State.RECORDING_STARTED;

         if (mHandler == null || !sendEmptyMessageAtAbsoluteTime(MESSAGE_STOP_RECORDING,
                 mScheduledRecording.getEndTimeMs() + MS_AFTER_END)) {
             mState = State.ERROR;
             return;
         }
     }

     private void handleStopRecording() {
         if (DEBUG) Log.d(TAG, "handleStopRecording " + mScheduledRecording);
         mTvRecordingClient.stopRecording();
         mState = State.RECORDING_STOP_REQUESTED;
     }

     @VisibleForTesting
     State getState() {
         return mState;
     }

     private void release() {
         if (mTvRecordingClient != null) {
            mSessionManager.releaseTvRecordingClient(mTvRecordingClient);
         }
         mDvrManager.removeListener(this);
     }

     private boolean sendEmptyMessageAtAbsoluteTime(int what, long when) {
         long now = mClock.currentTimeMillis();
         long delay = Math.max(0L, when - now);
         if (DEBUG) {
             Log.d(TAG, "Sending message " + what + " with a delay of " + delay / 1000
                     + " seconds to arrive at " + Utils.toIsoDateTimeString(when));
         }
         return mHandler.sendEmptyMessageDelayed(what, delay);
     }

     private void updateRecordingState(@ScheduledRecording.RecordingState int state) {
         updateRecording(ScheduledRecording.buildFrom(mScheduledRecording).setState(state).build());
     }

     @VisibleForTesting
     static Uri getIdAsMediaUri(ScheduledRecording scheduledRecording) {
             // TODO define the URI format
         return new Uri.Builder().appendPath(String.valueOf(scheduledRecording.getId())).build();
     }

     private void updateRecording(ScheduledRecording updatedScheduledRecording) {
         if (DEBUG) Log.d(TAG, "updateScheduledRecording " + updatedScheduledRecording);
         mScheduledRecording = updatedScheduledRecording;
         mMainThreadHandler.post(new Runnable() {
             @Override
             public void run() {
                 mDataManager.updateScheduledRecording(mScheduledRecording);
             }
         });
     }

     @Override
     public void onStopRecordingRequested(ScheduledRecording recording) {
         if (recording.getId() != mScheduledRecording.getId()) {
             return;
         }
         switch (mState) {
             case RECORDING_STARTED:
                 mHandler.removeMessages(MESSAGE_STOP_RECORDING);
                 handleStopRecording();
                 break;
             case RECORDING_STOP_REQUESTED:
                 // Do nothing
                 break;
             case NOT_STARTED:
             case SESSION_ACQUIRED:
             case CONNECTION_PENDING:
             case CONNECTED:
             case RECORDING_START_REQUESTED:
             case ERROR:
             case RELEASED:
             default:
                 sendRemove();
                 break;
         }
     }

     @Override
     public String toString() {
         return getClass().getName() + "(" + mScheduledRecording + ")";
     }
 }
	/*
	* 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.media.tv.TvContract;
	import android.media.tv.TvRecordingClient;
	import android.net.Uri;
	import android.os.Handler;
	import android.os.Looper;
	import android.os.Message;
	import android.support.annotation.VisibleForTesting;
	import android.support.annotation.WorkerThread;
	import android.util.Log;

	import com.android.tv.common.SoftPreconditions;
	import com.android.tv.data.Channel;
	import com.android.tv.util.Clock;
	import com.android.tv.util.Utils;

	import java.util.concurrent.TimeUnit;

	/**
	* A Handler that actually starts and stop a recording at the right time.
	*
	* <p>This is run on the looper of thread named {@value DvrRecordingService#HANDLER_THREAD_NAME}.
	* There is only one looper so messages must be handled quickly or start a separate thread.
	*/
	@WorkerThread
	class RecordingTask extends TvRecordingClient.RecordingCallback
	implements Handler.Callback, DvrManager.Listener {
	private static final String TAG = "RecordingTask";
	private static final boolean DEBUG = false;

	@VisibleForTesting
	static final int MESSAGE_INIT = 1;
	@VisibleForTesting
	static final int MESSAGE_START_RECORDING = 2;
	@VisibleForTesting
	static final int MESSAGE_STOP_RECORDING = 3;

	@VisibleForTesting
	static final long MS_BEFORE_START = TimeUnit.SECONDS.toMillis(5);
	@VisibleForTesting
	static final long MS_AFTER_END = TimeUnit.SECONDS.toMillis(5);

	@VisibleForTesting
	enum State {
	NOT_STARTED,
	SESSION_ACQUIRED,
	CONNECTION_PENDING,
	CONNECTED,
	RECORDING_START_REQUESTED,
	RECORDING_STARTED,
	RECORDING_STOP_REQUESTED,
	ERROR,
	RELEASED,
	}
	private final DvrSessionManager mSessionManager;
	private final DvrManager mDvrManager;

	private final WritableDvrDataManager mDataManager;
	private final Handler mMainThreadHandler = new Handler(Looper.getMainLooper());
	private TvRecordingClient mTvRecordingClient;
	private Handler mHandler;
	private ScheduledRecording mScheduledRecording;
	private final Channel mChannel;
	private State mState = State.NOT_STARTED;
	private final Clock mClock;

	RecordingTask(ScheduledRecording scheduledRecording, Channel channel,
	DvrManager dvrManager, DvrSessionManager sessionManager,
	WritableDvrDataManager dataManager, Clock clock) {
	mScheduledRecording = scheduledRecording;
	mChannel = channel;
	mSessionManager = sessionManager;
	mDataManager = dataManager;
	mClock = clock;
	mDvrManager = dvrManager;

	if (DEBUG) Log.d(TAG, "created recording task " + mScheduledRecording);
	}

	public void setHandler(Handler handler) {
	mHandler = handler;
	}

	@Override
	public boolean handleMessage(Message msg) {
	if (DEBUG) Log.d(TAG, "handleMessage " + msg);
	SoftPreconditions
	.checkState(msg.what == Scheduler.HandlerWrapper.MESSAGE_REMOVE \|\| mHandler != null,
	TAG, "Null handler trying to handle " + msg);
	try {
	switch (msg.what) {
	case MESSAGE_INIT:
	handleInit();
	break;
	case MESSAGE_START_RECORDING:
	handleStartRecording();
	break;
	case MESSAGE_STOP_RECORDING:
	handleStopRecording();
	break;
	case Scheduler.HandlerWrapper.MESSAGE_REMOVE:
	// Clear the handler
	mHandler = null;
	release();
	return false;
	default:
	SoftPreconditions.checkArgument(false, TAG, "unexpected message type " + msg);
	}
	return true;
	} catch (Exception e) {
	Log.w(TAG, "Error processing message " + msg + " for " + mScheduledRecording, e);
	failAndQuit();
	}
	return false;
	}

	@Override
	public void onTuned(Uri channelUri) {
	if (DEBUG) {
	Log.d(TAG, "onTuned");
	}
	super.onTuned(channelUri);
	mState = State.CONNECTED;
	if (mHandler == null \|\| !sendEmptyMessageAtAbsoluteTime(MESSAGE_START_RECORDING,
	mScheduledRecording.getStartTimeMs() - MS_BEFORE_START)) {
	mState = State.ERROR;
	return;
	}
	}


	@Override
	public void onRecordingStopped(Uri recordedProgramUri) {
	super.onRecordingStopped(recordedProgramUri);
	mState = State.CONNECTED;
	updateRecording(ScheduledRecording.buildFrom(mScheduledRecording)
	.setState(ScheduledRecording.STATE_RECORDING_FINISHED).build());
	sendRemove();
	}

	@Override
	public void onError(int reason) {
	if (DEBUG) Log.d(TAG, "onError reason " + reason);
	super.onError(reason);
	// TODO(dvr) handle success
	switch (reason) {
	default:
	updateRecording(ScheduledRecording.buildFrom(mScheduledRecording)
	.setState(ScheduledRecording.STATE_RECORDING_FAILED)
	.build());
	}
	release();
	sendRemove();
	}

	private void handleInit() {
	if (DEBUG) Log.d(TAG, "handleInit " + mScheduledRecording);
	//TODO check recording preconditions

	if (mScheduledRecording.getEndTimeMs() < mClock.currentTimeMillis()) {
	Log.w(TAG, "End time already past, not recording " + mScheduledRecording);
	failAndQuit();
	return;
	}

	if (mChannel == null) {
	Log.w(TAG, "Null channel for " + mScheduledRecording);
	failAndQuit();
	return;
	}
	if (mChannel.getId() != mScheduledRecording.getChannelId()) {
	Log.w(TAG, "Channel" + mChannel + " does not match scheduled recording "
	+ mScheduledRecording);
	failAndQuit();
	return;
	}

	String inputId = mChannel.getInputId();
	if (mSessionManager.canAcquireDvrSession(inputId, mChannel)) {
	mTvRecordingClient = mSessionManager
	.createTvRecordingClient("recordingTask-" + mScheduledRecording.getId(), this,
	mHandler);
	mState = State.SESSION_ACQUIRED;
	} else {
	Log.w(TAG, "Unable to acquire a session for " + mScheduledRecording);
	failAndQuit();
	return;
	}
	mDvrManager.addListener(this, mHandler);
	mTvRecordingClient.tune(inputId, mChannel.getUri());
	mState = State.CONNECTION_PENDING;
	}

	private void failAndQuit() {
	if (DEBUG) Log.d(TAG, "failAndQuit");
	updateRecordingState(ScheduledRecording.STATE_RECORDING_FAILED);
	mState = State.ERROR;
	sendRemove();
	}

	private void sendRemove() {
	if (DEBUG) Log.d(TAG, "sendRemove");
	if (mHandler != null) {
	mHandler.sendEmptyMessage(Scheduler.HandlerWrapper.MESSAGE_REMOVE);
	}
	}

	private void handleStartRecording() {
	if (DEBUG) Log.d(TAG, "handleStartRecording " + mScheduledRecording);
	// TODO(DVR) handle errors
	long programId = mScheduledRecording.getProgramId();
	mTvRecordingClient.startRecording(programId == ScheduledRecording.ID_NOT_SET ? null
	: TvContract.buildProgramUri(programId));
	updateRecording(ScheduledRecording.buildFrom(mScheduledRecording)
	.setState(ScheduledRecording.STATE_RECORDING_IN_PROGRESS).build());
	mState = State.RECORDING_STARTED;

	if (mHandler == null \|\| !sendEmptyMessageAtAbsoluteTime(MESSAGE_STOP_RECORDING,
	mScheduledRecording.getEndTimeMs() + MS_AFTER_END)) {
	mState = State.ERROR;
	return;
	}
	}

	private void handleStopRecording() {
	if (DEBUG) Log.d(TAG, "handleStopRecording " + mScheduledRecording);
	mTvRecordingClient.stopRecording();
	mState = State.RECORDING_STOP_REQUESTED;
	}

	@VisibleForTesting
	State getState() {
	return mState;
	}

	private void release() {
	if (mTvRecordingClient != null) {
	mSessionManager.releaseTvRecordingClient(mTvRecordingClient);
	}
	mDvrManager.removeListener(this);
	}

	private boolean sendEmptyMessageAtAbsoluteTime(int what, long when) {
	long now = mClock.currentTimeMillis();
	long delay = Math.max(0L, when - now);
	if (DEBUG) {
	Log.d(TAG, "Sending message " + what + " with a delay of " + delay / 1000
	+ " seconds to arrive at " + Utils.toIsoDateTimeString(when));
	}
	return mHandler.sendEmptyMessageDelayed(what, delay);
	}

	private void updateRecordingState(@ScheduledRecording.RecordingState int state) {
	updateRecording(ScheduledRecording.buildFrom(mScheduledRecording).setState(state).build());
	}

	@VisibleForTesting
	static Uri getIdAsMediaUri(ScheduledRecording scheduledRecording) {
	// TODO define the URI format
	return new Uri.Builder().appendPath(String.valueOf(scheduledRecording.getId())).build();
	}

	private void updateRecording(ScheduledRecording updatedScheduledRecording) {
	if (DEBUG) Log.d(TAG, "updateScheduledRecording " + updatedScheduledRecording);
	mScheduledRecording = updatedScheduledRecording;
	mMainThreadHandler.post(new Runnable() {
	@Override
	public void run() {
	mDataManager.updateScheduledRecording(mScheduledRecording);
	}
	});
	}

	@Override
	public void onStopRecordingRequested(ScheduledRecording recording) {
	if (recording.getId() != mScheduledRecording.getId()) {
	return;
	}
	switch (mState) {
	case RECORDING_STARTED:
	mHandler.removeMessages(MESSAGE_STOP_RECORDING);
	handleStopRecording();
	break;
	case RECORDING_STOP_REQUESTED:
	// Do nothing
	break;
	case NOT_STARTED:
	case SESSION_ACQUIRED:
	case CONNECTION_PENDING:
	case CONNECTED:
	case RECORDING_START_REQUESTED:
	case ERROR:
	case RELEASED:
	default:
	sendRemove();
	break;
	}
	}

	@Override
	public String toString() {
	return getClass().getName() + "(" + mScheduledRecording + ")";
	}
	}