Merge "TIF: Rearchitecting TvInputPassthroughWrapperService." into lmp-dev (e377ea5d) · Commits · e / os / android_frameworks_base

api/current.txt

+8 −16

Original line number	Diff line number	Diff line
		@@ -17057,22 +17057,6 @@ package android.media.tv {
		method public void onInputStateChanged(java.lang.String, int);
		}

		public abstract class TvInputPassthroughWrapperService extends android.media.tv.TvInputService {
		ctor public TvInputPassthroughWrapperService();
		method public abstract java.lang.String getPassthroughInputId(java.lang.String);
		method public abstract android.media.tv.TvInputPassthroughWrapperService.PassthroughWrapperSession onCreatePassthroughWrapperSession();
		method public final android.media.tv.TvInputService.Session onCreateSession(java.lang.String);
		}

		public abstract class TvInputPassthroughWrapperService.PassthroughWrapperSession extends android.media.tv.TvInputService.Session {
		ctor public TvInputPassthroughWrapperService.PassthroughWrapperSession();
		method public abstract void onPassthroughSessionCreationFailed();
		method public abstract void onPassthroughSessionReleased();
		method public abstract void onPassthroughVideoAvailable();
		method public abstract void onPassthroughVideoUnavailable(int);
		method public final boolean onSetSurface(android.view.Surface);
		}

		public abstract class TvInputService extends android.app.Service {
		ctor public TvInputService();
		method public final android.os.IBinder onBind(android.content.Intent);
		@@ -17081,6 +17065,14 @@ package android.media.tv {
		field public static final java.lang.String SERVICE_META_DATA = "android.media.tv.input";
		}

		public abstract class TvInputService.HardwareSession extends android.media.tv.TvInputService.Session {
		ctor public TvInputService.HardwareSession();
		method public abstract java.lang.String getHardwareInputId();
		method public void onHardwareVideoAvailable();
		method public void onHardwareVideoUnavailable(int);
		method public final boolean onSetSurface(android.view.Surface);
		}

		public abstract class TvInputService.Session implements android.view.KeyEvent.Callback {
		ctor public TvInputService.Session();
		method public void notifyChannelRetuned(android.net.Uri);

media/java/android/media/tv/ITvInputServiceCallback.aidl

+0 −1

Original line number	Diff line number	Diff line
		@@ -27,5 +27,4 @@ oneway interface ITvInputServiceCallback {
		void addHardwareTvInput(in int deviceID, in TvInputInfo inputInfo);
		void addHdmiCecTvInput(in int logicalAddress, in TvInputInfo inputInfo);
		void removeTvInput(in String inputId);
		void setWrappedInputId(in String inputId, in String wrappedInputId);
		}

media/java/android/media/tv/ITvInputSessionCallback.aidl

+1 −1

Original line number	Diff line number	Diff line
		@@ -27,7 +27,7 @@ import android.os.Bundle;
		* @hide
		*/
		oneway interface ITvInputSessionCallback {
		void onSessionCreated(ITvInputSession session);
		void onSessionCreated(ITvInputSession session, in IBinder hardwareSessionToken);
		void onSessionEvent(in String name, in Bundle args);
		void onChannelRetuned(in Uri channelUri);
		void onTracksChanged(in List<TvTrackInfo> tracks);

media/java/android/media/tv/TvInputManager.java

+4 −0

Original line number	Diff line number	Diff line
		@@ -1454,6 +1454,10 @@ public final class TvInputManager {
		mPendingEventPool.release(p);
		}

		IBinder getToken() {
		return mToken;
		}

		private void releaseInternal() {
		mToken = null;
		synchronized (mHandler) {

media/java/android/media/tv/TvInputPassthroughWrapperService.java

deleted100644 → 0

+0 −259

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 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 android.media.tv;

		import android.content.Context;
		import android.os.Bundle;
		import android.os.Handler;
		import android.util.Log;
		import android.view.Surface;

		/**
		* TvInputPassthroughWrapperService represents a TV input which controls an external device
		* connected to a pass-through TV input (e.g. HDMI 1).
		* <p>
		* This service wraps around a pass-through TV input and delegates the {@link Surface} to the
		* connected TV input so that the application can show the pass-through TV input while
		* TvInputPassthroughWrapperService controls the underlying external device via a separate
		* connection. In the setup activity, the TV input should get the pass-through TV input ID, around
		* which this service will wrap. The service implementation should pass the ID via
		* {@link TvInputPassthroughWrapperService#getPassthroughInputId(String)}. In addition,
		* it needs to implement {@link TvInputPassthroughWrapperService#onCreatePassthroughWrapperSession}
		* to handle requests from the application.
		* </p>
		*/
		public abstract class TvInputPassthroughWrapperService extends TvInputService {
		private static final String TAG = "TvInputPassthroughWrapperService";
		// STOPSHIP: Turn debugging off.
		private static final boolean DEBUG = true;
		private TvInputManager mTvInputManager;
		private Handler mHandler;

		@Override
		public void onCreate() {
		if (DEBUG) Log.d(TAG, "onCreate()");
		super.onCreate();
		mTvInputManager = (TvInputManager) getSystemService(Context.TV_INPUT_SERVICE);
		mHandler = new Handler();
		}

		@Override
		public final Session onCreateSession(String inputId) {
		if (DEBUG) Log.d(TAG, "onCreateSession()");
		// Checks the pass-through TV input is properly setup.
		String passthroughInputId = getPassthroughInputId(inputId);
		if (passthroughInputId == null) {
		Log.w(TAG, "The passthrough TV input for input id(" + inputId + ") is not setup yet.");
		return null;
		}
		// Checks if input id from the derived class is really pass-through type.
		TvInputInfo info = mTvInputManager.getTvInputInfo(passthroughInputId);
		if (info == null \|\| !info.isPassthroughInputType()) {
		Log.w(TAG, "Invalid TV input id from derived class: " + passthroughInputId);
		return null;
		}
		// Creates a PassthroughWrapperSession.
		PassthroughWrapperSession session = onCreatePassthroughWrapperSession();
		if (session == null) {
		return null;
		}
		// Connects to the pass-through input the external device is connected to.
		if (!session.connect(passthroughInputId)) {
		throw new IllegalStateException("WrapperSession cannot be reused.");
		}
		notifyWrappedInputId(inputId, passthroughInputId);
		return session;
		}

		/**
		* Returns an implementation of {@link PassthroughWrapperSession}.
		* <p>
		* May return {@code null} if {@link TvInputPassthroughWrapperService} fails to create a
		* session.
		* </p>
		*/
		public abstract PassthroughWrapperSession onCreatePassthroughWrapperSession();

		/**
		* Returns the TV input id the external device is connected to.
		* <p>
		* {@link TvInputPassthroughWrapperService} is expected to identify the pass-though TV
		* input the external device is connected to in the setup phase of this TV input.
		* May return {@code null} if the pass-though TV input is not identified yet.
		* </p>
		* @param inputId The ID of the TV input which controls the external device.
		*/
		public abstract String getPassthroughInputId(String inputId);

		/**
		* Base session class for derived classes to handle the request from the application. This
		* creates additional session to the pass-through TV input internally and delegates the
		* {@link Surface} given from the application.
		*/
		public abstract class PassthroughWrapperSession extends Session {
		private static final float VOLUME_ON = 1.0f;
		private static final float VOLUME_OFF = 0f;
		private TvInputManager.Session mSession;
		private Surface mSurface;
		private Float mVolume;
		private boolean mReleased;
		private int mSurfaceFormat;
		private int mSurfaceWidth;
		private int mSurfaceHeight;
		private boolean mSurfaceChanged;
		private boolean mConnectionRequested;

		private final TvInputManager.SessionCallback mSessionCallback =
		new TvInputManager.SessionCallback() {
		@Override
		public void onSessionCreated(TvInputManager.Session session) {
		if (session == null) {
		Log.w(TAG, "Failed to create session.");
		onPassthroughSessionCreationFailed();
		return;
		}
		if (mReleased) {
		session.release();
		return;
		}
		if (mSurface != null) {
		session.setSurface(mSurface);
		mSurface = null;
		}
		if (mVolume != null) {
		session.setStreamVolume(mVolume);
		mVolume = null;
		}
		if (mSurfaceChanged) {
		session.dispatchSurfaceChanged(mSurfaceFormat, mSurfaceWidth, mSurfaceHeight);
		mSurfaceChanged = false;
		}
		mSession = session;
		}

		@Override
		public void onSessionReleased(TvInputManager.Session session) {
		mReleased = true;
		mSession = null;
		onPassthroughSessionReleased();
		}

		@Override
		public void onVideoAvailable(TvInputManager.Session session) {
		if (mSession == session) {
		onPassthroughVideoAvailable();
		}
		}

		@Override
		public void onVideoUnavailable(TvInputManager.Session session, int reason) {
		if (mSession == session) {
		onPassthroughVideoUnavailable(reason);
		}
		}

		@Override
		public void onSessionEvent(TvInputManager.Session session, String eventType,
		Bundle eventArgs) {
		if (mSession == session) {
		notifySessionEvent(eventType, eventArgs);
		}
		}
		};

		/**
		* Called when failed to create a session for pass-through TV input.
		*/
		public abstract void onPassthroughSessionCreationFailed();

		/**
		* Called when the pass-through TV input session is released. This typically happens when
		* the process hosting the pass-through TV input has crashed or been killed.
		*/
		public abstract void onPassthroughSessionReleased();

		/**
		* Called when the underlying pass-through TV input session calls
		* {@link #notifyVideoAvailable()}.
		*/
		public abstract void onPassthroughVideoAvailable();

		/**
		* Called when the underlying pass-through TV input session calls
		* {@link #notifyVideoUnavailable(int)}.
		*
		* @param reason The reason why the pass-through TV input stopped the playback.
		*/
		public abstract void onPassthroughVideoUnavailable(int reason);

		@Override
		public final boolean onSetSurface(Surface surface) {
		if (DEBUG) Log.d(TAG, "onSetSurface(" + surface + ")");
		if (mSession == null) {
		mSurface = surface;
		} else {
		mSession.setSurface(surface);
		}
		return true;
		}

		private boolean connect(String inputId) {
		if (mConnectionRequested) {
		return false;
		}
		mTvInputManager.createSession(inputId, mSessionCallback, mHandler);
		mConnectionRequested = true;
		return true;
		}

		@Override
		void release() {
		super.release();
		mReleased = true;
		if (mSession != null) {
		mSession.release();
		}
		}

		@Override
		void dispatchSurfaceChanged(int format, int width, int height) {
		super.dispatchSurfaceChanged(format, width, height);
		if (mSession == null) {
		mSurfaceFormat = format;
		mSurfaceWidth = width;
		mSurfaceHeight = height;
		mSurfaceChanged = true;
		} else {
		mSession.dispatchSurfaceChanged(format, width, height);
		}
		}

		@Override
		void setStreamVolume(float volume) {
		super.setStreamVolume(volume);
		// Here, we let the pass-through TV input know only whether volume is on or off and
		// make the fine control done in the derived class to prevent that the volume is
		// controlled in the both side.
		float volumeForPassthriughInput = (volume > 0.0f) ? VOLUME_ON : VOLUME_OFF;
		if (mSession == null) {
		mVolume = Float.valueOf(volumeForPassthriughInput);
		} else {
		mSession.setStreamVolume(volumeForPassthriughInput);
		}
		}
		}
		}