/*
|
* Copyright (C) 2016 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.server.tv;
|
|
import android.content.ComponentName;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.ServiceConnection;
|
import android.media.tv.ITvRemoteProvider;
|
import android.media.tv.ITvRemoteServiceInput;
|
import android.os.Binder;
|
import android.os.Handler;
|
import android.os.IBinder;
|
import android.os.RemoteException;
|
import android.os.UserHandle;
|
import android.util.Log;
|
import android.util.Slog;
|
|
import java.io.PrintWriter;
|
import java.lang.ref.WeakReference;
|
|
/**
|
* Maintains a connection to a tv remote provider service.
|
*/
|
final class TvRemoteProviderProxy implements ServiceConnection {
|
private static final String TAG = "TvRemoteProvProxy"; // max. 23 chars
|
private static final boolean DEBUG = Log.isLoggable(TAG, Log.VERBOSE);
|
private static final boolean DEBUG_KEY = false;
|
|
|
// This should match TvRemoteProvider.ACTION_TV_REMOTE_PROVIDER
|
protected static final String SERVICE_INTERFACE =
|
"com.android.media.tv.remoteprovider.TvRemoteProvider";
|
private final Context mContext;
|
private final ComponentName mComponentName;
|
private final int mUserId;
|
private final int mUid;
|
private final Handler mHandler;
|
|
/**
|
* State guarded by mLock.
|
* This is the first lock in sequence for an incoming call.
|
* The second lock is always {@link TvRemoteService#mLock}
|
*
|
* There are currently no methods that break this sequence.
|
*/
|
private final Object mLock = new Object();
|
|
private ProviderMethods mProviderMethods;
|
// Connection state
|
private boolean mRunning;
|
private boolean mBound;
|
private Connection mActiveConnection;
|
private boolean mConnectionReady;
|
|
public TvRemoteProviderProxy(Context context, ComponentName componentName, int userId,
|
int uid) {
|
mContext = context;
|
mComponentName = componentName;
|
mUserId = userId;
|
mUid = uid;
|
mHandler = new Handler();
|
}
|
|
public void dump(PrintWriter pw, String prefix) {
|
pw.println(prefix + "Proxy");
|
pw.println(prefix + " mUserId=" + mUserId);
|
pw.println(prefix + " mRunning=" + mRunning);
|
pw.println(prefix + " mBound=" + mBound);
|
pw.println(prefix + " mActiveConnection=" + mActiveConnection);
|
pw.println(prefix + " mConnectionReady=" + mConnectionReady);
|
}
|
|
public void setProviderSink(ProviderMethods provider) {
|
mProviderMethods = provider;
|
}
|
|
public boolean hasComponentName(String packageName, String className) {
|
return mComponentName.getPackageName().equals(packageName)
|
&& mComponentName.getClassName().equals(className);
|
}
|
|
public void start() {
|
if (!mRunning) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": Starting");
|
}
|
|
mRunning = true;
|
updateBinding();
|
}
|
}
|
|
public void stop() {
|
if (mRunning) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": Stopping");
|
}
|
|
mRunning = false;
|
updateBinding();
|
}
|
}
|
|
public void rebindIfDisconnected() {
|
synchronized (mLock) {
|
if (mActiveConnection == null && shouldBind()) {
|
unbind();
|
bind();
|
}
|
}
|
}
|
|
private void updateBinding() {
|
if (shouldBind()) {
|
bind();
|
} else {
|
unbind();
|
}
|
}
|
|
private boolean shouldBind() {
|
return mRunning;
|
}
|
|
private void bind() {
|
if (!mBound) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": Binding");
|
}
|
|
Intent service = new Intent(SERVICE_INTERFACE);
|
service.setComponent(mComponentName);
|
try {
|
mBound = mContext.bindServiceAsUser(service, this,
|
Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE,
|
new UserHandle(mUserId));
|
if (!mBound && DEBUG) {
|
Slog.d(TAG, this + ": Bind failed");
|
}
|
} catch (SecurityException ex) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": Bind failed", ex);
|
}
|
}
|
}
|
}
|
|
private void unbind() {
|
if (mBound) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": Unbinding");
|
}
|
|
mBound = false;
|
disconnect();
|
mContext.unbindService(this);
|
}
|
}
|
|
@Override
|
public void onServiceConnected(ComponentName name, IBinder service) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": onServiceConnected()");
|
}
|
|
if (mBound) {
|
disconnect();
|
|
ITvRemoteProvider provider = ITvRemoteProvider.Stub.asInterface(service);
|
if (provider != null) {
|
Connection connection = new Connection(provider);
|
if (connection.register()) {
|
synchronized (mLock) {
|
mActiveConnection = connection;
|
}
|
if (DEBUG) {
|
Slog.d(TAG, this + ": Connected successfully.");
|
}
|
} else {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": Registration failed");
|
}
|
}
|
} else {
|
Slog.e(TAG, this + ": Service returned invalid remote-control provider binder");
|
}
|
}
|
}
|
|
@Override
|
public void onServiceDisconnected(ComponentName name) {
|
if (DEBUG) Slog.d(TAG, this + ": Service disconnected");
|
disconnect();
|
}
|
|
|
private void onConnectionReady(Connection connection) {
|
synchronized (mLock) {
|
if (DEBUG) Slog.d(TAG, "onConnectionReady");
|
if (mActiveConnection == connection) {
|
if (DEBUG) Slog.d(TAG, "mConnectionReady = true");
|
mConnectionReady = true;
|
}
|
}
|
}
|
|
private void onConnectionDied(Connection connection) {
|
if (mActiveConnection == connection) {
|
if (DEBUG) Slog.d(TAG, this + ": Service connection died");
|
disconnect();
|
}
|
}
|
|
private void disconnect() {
|
synchronized (mLock) {
|
if (mActiveConnection != null) {
|
mConnectionReady = false;
|
mActiveConnection.dispose();
|
mActiveConnection = null;
|
}
|
}
|
}
|
|
// Provider helpers
|
public void inputBridgeConnected(IBinder token) {
|
synchronized (mLock) {
|
if (DEBUG) Slog.d(TAG, this + ": inputBridgeConnected token: " + token);
|
if (mConnectionReady) {
|
mActiveConnection.onInputBridgeConnected(token);
|
}
|
}
|
}
|
|
public interface ProviderMethods {
|
// InputBridge
|
void openInputBridge(TvRemoteProviderProxy provider, IBinder token, String name,
|
int width, int height, int maxPointers);
|
|
void closeInputBridge(TvRemoteProviderProxy provider, IBinder token);
|
|
void clearInputBridge(TvRemoteProviderProxy provider, IBinder token);
|
|
void sendTimeStamp(TvRemoteProviderProxy provider, IBinder token, long timestamp);
|
|
void sendKeyDown(TvRemoteProviderProxy provider, IBinder token, int keyCode);
|
|
void sendKeyUp(TvRemoteProviderProxy provider, IBinder token, int keyCode);
|
|
void sendPointerDown(TvRemoteProviderProxy provider, IBinder token, int pointerId, int x,
|
int y);
|
|
void sendPointerUp(TvRemoteProviderProxy provider, IBinder token, int pointerId);
|
|
void sendPointerSync(TvRemoteProviderProxy provider, IBinder token);
|
}
|
|
private final class Connection implements IBinder.DeathRecipient {
|
private final ITvRemoteProvider mTvRemoteProvider;
|
private final RemoteServiceInputProvider mServiceInputProvider;
|
|
public Connection(ITvRemoteProvider provider) {
|
mTvRemoteProvider = provider;
|
mServiceInputProvider = new RemoteServiceInputProvider(this);
|
}
|
|
public boolean register() {
|
if (DEBUG) Slog.d(TAG, "Connection::register()");
|
try {
|
mTvRemoteProvider.asBinder().linkToDeath(this, 0);
|
mTvRemoteProvider.setRemoteServiceInputSink(mServiceInputProvider);
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
onConnectionReady(Connection.this);
|
}
|
});
|
return true;
|
} catch (RemoteException ex) {
|
binderDied();
|
}
|
return false;
|
}
|
|
public void dispose() {
|
if (DEBUG) Slog.d(TAG, "Connection::dispose()");
|
mTvRemoteProvider.asBinder().unlinkToDeath(this, 0);
|
mServiceInputProvider.dispose();
|
}
|
|
|
public void onInputBridgeConnected(IBinder token) {
|
if (DEBUG) Slog.d(TAG, this + ": onInputBridgeConnected");
|
try {
|
mTvRemoteProvider.onInputBridgeConnected(token);
|
} catch (RemoteException ex) {
|
Slog.e(TAG, "Failed to deliver onInputBridgeConnected. ", ex);
|
}
|
}
|
|
@Override
|
public void binderDied() {
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
onConnectionDied(Connection.this);
|
}
|
});
|
}
|
|
void openInputBridge(final IBinder token, final String name, final int width,
|
final int height, final int maxPointers) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": openInputBridge," +
|
" token=" + token + ", name=" + name);
|
}
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.openInputBridge(TvRemoteProviderProxy.this, token,
|
name, width, height, maxPointers);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"openInputBridge, Invalid connection or incorrect uid: " + Binder
|
.getCallingUid());
|
}
|
}
|
}
|
}
|
|
void closeInputBridge(final IBinder token) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": closeInputBridge," +
|
" token=" + token);
|
}
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.closeInputBridge(TvRemoteProviderProxy.this, token);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"closeInputBridge, Invalid connection or incorrect uid: " +
|
Binder.getCallingUid());
|
}
|
}
|
}
|
}
|
|
void clearInputBridge(final IBinder token) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
if (DEBUG) {
|
Slog.d(TAG, this + ": clearInputBridge," +
|
" token=" + token);
|
}
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.clearInputBridge(TvRemoteProviderProxy.this, token);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"clearInputBridge, Invalid connection or incorrect uid: " +
|
Binder.getCallingUid());
|
}
|
}
|
}
|
}
|
|
void sendTimestamp(final IBinder token, final long timestamp) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.sendTimeStamp(TvRemoteProviderProxy.this, token,
|
timestamp);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"sendTimeStamp, Invalid connection or incorrect uid: " + Binder
|
.getCallingUid());
|
}
|
}
|
}
|
}
|
|
void sendKeyDown(final IBinder token, final int keyCode) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
if (DEBUG_KEY) {
|
Slog.d(TAG, this + ": sendKeyDown," +
|
" token=" + token + ", keyCode=" + keyCode);
|
}
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.sendKeyDown(TvRemoteProviderProxy.this, token,
|
keyCode);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"sendKeyDown, Invalid connection or incorrect uid: " + Binder
|
.getCallingUid());
|
}
|
}
|
}
|
}
|
|
void sendKeyUp(final IBinder token, final int keyCode) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
if (DEBUG_KEY) {
|
Slog.d(TAG, this + ": sendKeyUp," +
|
" token=" + token + ", keyCode=" + keyCode);
|
}
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.sendKeyUp(TvRemoteProviderProxy.this, token, keyCode);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"sendKeyUp, Invalid connection or incorrect uid: " + Binder
|
.getCallingUid());
|
}
|
}
|
}
|
}
|
|
void sendPointerDown(final IBinder token, final int pointerId, final int x, final int y) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
if (DEBUG_KEY) {
|
Slog.d(TAG, this + ": sendPointerDown," +
|
" token=" + token + ", pointerId=" + pointerId);
|
}
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.sendPointerDown(TvRemoteProviderProxy.this, token,
|
pointerId, x, y);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"sendPointerDown, Invalid connection or incorrect uid: " + Binder
|
.getCallingUid());
|
}
|
}
|
}
|
}
|
|
void sendPointerUp(final IBinder token, final int pointerId) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
if (DEBUG_KEY) {
|
Slog.d(TAG, this + ": sendPointerUp," +
|
" token=" + token + ", pointerId=" + pointerId);
|
}
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.sendPointerUp(TvRemoteProviderProxy.this, token,
|
pointerId);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"sendPointerUp, Invalid connection or incorrect uid: " + Binder
|
.getCallingUid());
|
}
|
}
|
}
|
}
|
|
void sendPointerSync(final IBinder token) {
|
synchronized (mLock) {
|
if (mActiveConnection == this && Binder.getCallingUid() == mUid) {
|
if (DEBUG_KEY) {
|
Slog.d(TAG, this + ": sendPointerSync," +
|
" token=" + token);
|
}
|
final long idToken = Binder.clearCallingIdentity();
|
try {
|
if (mProviderMethods != null) {
|
mProviderMethods.sendPointerSync(TvRemoteProviderProxy.this, token);
|
}
|
} finally {
|
Binder.restoreCallingIdentity(idToken);
|
}
|
} else {
|
if (DEBUG) {
|
Slog.w(TAG,
|
"sendPointerSync, Invalid connection or incorrect uid: " + Binder
|
.getCallingUid());
|
}
|
}
|
}
|
}
|
}
|
|
/**
|
* Receives events from the connected provider.
|
* <p>
|
* This inner class is static and only retains a weak reference to the connection
|
* to prevent the client from being leaked in case the service is holding an
|
* active reference to the client's callback.
|
* </p>
|
*/
|
private static final class RemoteServiceInputProvider extends ITvRemoteServiceInput.Stub {
|
private final WeakReference<Connection> mConnectionRef;
|
|
public RemoteServiceInputProvider(Connection connection) {
|
mConnectionRef = new WeakReference<Connection>(connection);
|
}
|
|
public void dispose() {
|
// Terminate the connection.
|
mConnectionRef.clear();
|
}
|
|
@Override
|
public void openInputBridge(IBinder token, String name, int width,
|
int height, int maxPointers) throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.openInputBridge(token, name, width, height, maxPointers);
|
}
|
}
|
|
@Override
|
public void closeInputBridge(IBinder token) throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.closeInputBridge(token);
|
}
|
}
|
|
@Override
|
public void clearInputBridge(IBinder token) throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.clearInputBridge(token);
|
}
|
}
|
|
@Override
|
public void sendTimestamp(IBinder token, long timestamp) throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.sendTimestamp(token, timestamp);
|
}
|
}
|
|
@Override
|
public void sendKeyDown(IBinder token, int keyCode) throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.sendKeyDown(token, keyCode);
|
}
|
}
|
|
@Override
|
public void sendKeyUp(IBinder token, int keyCode) throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.sendKeyUp(token, keyCode);
|
}
|
}
|
|
@Override
|
public void sendPointerDown(IBinder token, int pointerId, int x, int y)
|
throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.sendPointerDown(token, pointerId, x, y);
|
}
|
}
|
|
@Override
|
public void sendPointerUp(IBinder token, int pointerId) throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.sendPointerUp(token, pointerId);
|
}
|
}
|
|
@Override
|
public void sendPointerSync(IBinder token) throws RemoteException {
|
Connection connection = mConnectionRef.get();
|
if (connection != null) {
|
connection.sendPointerSync(token);
|
}
|
}
|
}
|
}
|
