/*
|
* 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.Context;
|
import android.os.Handler;
|
import android.os.IBinder;
|
import android.os.Looper;
|
import android.os.Message;
|
import android.util.ArrayMap;
|
import android.util.Slog;
|
|
import com.android.server.SystemService;
|
import com.android.server.Watchdog;
|
|
import java.io.IOException;
|
import java.util.ArrayList;
|
import java.util.Map;
|
|
/**
|
* TvRemoteService represents a system service that allows a connected
|
* remote control (emote) service to inject white-listed input events
|
* and call other specified methods for functioning as an emote service.
|
* <p/>
|
* This service is intended for use only by white-listed packages.
|
*/
|
public class TvRemoteService extends SystemService implements Watchdog.Monitor {
|
private static final String TAG = "TvRemoteService";
|
private static final boolean DEBUG = false;
|
private static final boolean DEBUG_KEYS = false;
|
|
private Map<IBinder, UinputBridge> mBridgeMap = new ArrayMap();
|
private Map<IBinder, TvRemoteProviderProxy> mProviderMap = new ArrayMap();
|
private ArrayList<TvRemoteProviderProxy> mProviderList = new ArrayList<>();
|
|
/**
|
* State guarded by mLock.
|
* This is the second lock in sequence for an incoming call.
|
* The first lock is always {@link TvRemoteProviderProxy#mLock}
|
*
|
* There are currently no methods that break this sequence.
|
* Special note:
|
* Outgoing call informInputBridgeConnected(), which is called from
|
* openInputBridgeInternalLocked() uses a handler thereby relinquishing held locks.
|
*/
|
private final Object mLock = new Object();
|
|
public final UserHandler mHandler;
|
|
public TvRemoteService(Context context) {
|
super(context);
|
mHandler = new UserHandler(new UserProvider(TvRemoteService.this), context);
|
Watchdog.getInstance().addMonitor(this);
|
}
|
|
@Override
|
public void onStart() {
|
if (DEBUG) Slog.d(TAG, "onStart()");
|
}
|
|
@Override
|
public void monitor() {
|
synchronized (mLock) { /* check for deadlock */ }
|
}
|
|
@Override
|
public void onBootPhase(int phase) {
|
if (phase == SystemService.PHASE_THIRD_PARTY_APPS_CAN_START) {
|
if (DEBUG) Slog.d(TAG, "PHASE_THIRD_PARTY_APPS_CAN_START");
|
mHandler.sendEmptyMessage(UserHandler.MSG_START);
|
}
|
}
|
|
//Outgoing calls.
|
private void informInputBridgeConnected(IBinder token) {
|
mHandler.obtainMessage(UserHandler.MSG_INPUT_BRIDGE_CONNECTED, 0, 0, token).sendToTarget();
|
}
|
|
// Incoming calls.
|
private void openInputBridgeInternalLocked(TvRemoteProviderProxy provider, IBinder token,
|
String name, int width, int height,
|
int maxPointers) {
|
if (DEBUG) {
|
Slog.d(TAG, "openInputBridgeInternalLocked(), token: " + token + ", name: " + name +
|
", width: " + width + ", height: " + height + ", maxPointers: " + maxPointers);
|
}
|
|
try {
|
//Create a new bridge, if one does not exist already
|
if (mBridgeMap.containsKey(token)) {
|
if (DEBUG) Slog.d(TAG, "RemoteBridge already exists");
|
// Respond back with success.
|
informInputBridgeConnected(token);
|
return;
|
}
|
|
UinputBridge inputBridge = new UinputBridge(token, name, width, height, maxPointers);
|
|
mBridgeMap.put(token, inputBridge);
|
mProviderMap.put(token, provider);
|
|
// Respond back with success.
|
informInputBridgeConnected(token);
|
|
} catch (IOException ioe) {
|
Slog.e(TAG, "Cannot create device for " + name);
|
}
|
}
|
|
private void closeInputBridgeInternalLocked(IBinder token) {
|
if (DEBUG) {
|
Slog.d(TAG, "closeInputBridgeInternalLocked(), token: " + token);
|
}
|
|
// Close an existing RemoteBridge
|
UinputBridge inputBridge = mBridgeMap.get(token);
|
if (inputBridge != null) {
|
inputBridge.close(token);
|
}
|
|
mBridgeMap.remove(token);
|
}
|
|
|
private void clearInputBridgeInternalLocked(IBinder token) {
|
if (DEBUG) {
|
Slog.d(TAG, "clearInputBridgeInternalLocked(), token: " + token);
|
}
|
|
UinputBridge inputBridge = mBridgeMap.get(token);
|
if (inputBridge != null) {
|
inputBridge.clear(token);
|
}
|
}
|
|
private void sendTimeStampInternalLocked(IBinder token, long timestamp) {
|
UinputBridge inputBridge = mBridgeMap.get(token);
|
if (inputBridge != null) {
|
inputBridge.sendTimestamp(token, timestamp);
|
}
|
}
|
|
private void sendKeyDownInternalLocked(IBinder token, int keyCode) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendKeyDownInternalLocked(), token: " + token + ", keyCode: " + keyCode);
|
}
|
|
UinputBridge inputBridge = mBridgeMap.get(token);
|
if (inputBridge != null) {
|
inputBridge.sendKeyDown(token, keyCode);
|
}
|
}
|
|
private void sendKeyUpInternalLocked(IBinder token, int keyCode) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendKeyUpInternalLocked(), token: " + token + ", keyCode: " + keyCode);
|
}
|
|
UinputBridge inputBridge = mBridgeMap.get(token);
|
if (inputBridge != null) {
|
inputBridge.sendKeyUp(token, keyCode);
|
}
|
}
|
|
private void sendPointerDownInternalLocked(IBinder token, int pointerId, int x, int y) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendPointerDownInternalLocked(), token: " + token + ", pointerId: " +
|
pointerId + ", x: " + x + ", y: " + y);
|
}
|
|
UinputBridge inputBridge = mBridgeMap.get(token);
|
if (inputBridge != null) {
|
inputBridge.sendPointerDown(token, pointerId, x, y);
|
}
|
}
|
|
private void sendPointerUpInternalLocked(IBinder token, int pointerId) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendPointerUpInternalLocked(), token: " + token + ", pointerId: " +
|
pointerId);
|
}
|
|
UinputBridge inputBridge = mBridgeMap.get(token);
|
if (inputBridge != null) {
|
inputBridge.sendPointerUp(token, pointerId);
|
}
|
}
|
|
private void sendPointerSyncInternalLocked(IBinder token) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendPointerSyncInternalLocked(), token: " + token);
|
}
|
|
UinputBridge inputBridge = mBridgeMap.get(token);
|
if (inputBridge != null) {
|
inputBridge.sendPointerSync(token);
|
}
|
}
|
|
private final class UserHandler extends Handler {
|
|
public static final int MSG_START = 1;
|
public static final int MSG_INPUT_BRIDGE_CONNECTED = 2;
|
|
private final TvRemoteProviderWatcher mWatcher;
|
private boolean mRunning;
|
|
public UserHandler(UserProvider provider, Context context) {
|
super(Looper.getMainLooper(), null, true);
|
mWatcher = new TvRemoteProviderWatcher(context, provider, this);
|
}
|
|
@Override
|
public void handleMessage(Message msg) {
|
switch (msg.what) {
|
case MSG_START: {
|
start();
|
break;
|
}
|
case MSG_INPUT_BRIDGE_CONNECTED: {
|
IBinder token = (IBinder) msg.obj;
|
TvRemoteProviderProxy provider = mProviderMap.get(token);
|
if (provider != null) {
|
provider.inputBridgeConnected(token);
|
}
|
break;
|
}
|
}
|
}
|
|
private void start() {
|
if (!mRunning) {
|
mRunning = true;
|
mWatcher.start(); // also starts all providers
|
}
|
}
|
}
|
|
private final class UserProvider implements TvRemoteProviderWatcher.ProviderMethods,
|
TvRemoteProviderProxy.ProviderMethods {
|
|
private final TvRemoteService mService;
|
|
public UserProvider(TvRemoteService service) {
|
mService = service;
|
}
|
|
@Override
|
public void openInputBridge(TvRemoteProviderProxy provider, IBinder token, String name,
|
int width, int height, int maxPointers) {
|
if (DEBUG) {
|
Slog.d(TAG, "openInputBridge(), token: " + token +
|
", name: " + name + ", width: " + width +
|
", height: " + height + ", maxPointers: " + maxPointers);
|
}
|
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.openInputBridgeInternalLocked(provider, token, name, width, height,
|
maxPointers);
|
}
|
}
|
}
|
|
@Override
|
public void closeInputBridge(TvRemoteProviderProxy provider, IBinder token) {
|
if (DEBUG) Slog.d(TAG, "closeInputBridge(), token: " + token);
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.closeInputBridgeInternalLocked(token);
|
mProviderMap.remove(token);
|
}
|
}
|
}
|
|
@Override
|
public void clearInputBridge(TvRemoteProviderProxy provider, IBinder token) {
|
if (DEBUG) Slog.d(TAG, "clearInputBridge(), token: " + token);
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.clearInputBridgeInternalLocked(token);
|
}
|
}
|
}
|
|
@Override
|
public void sendTimeStamp(TvRemoteProviderProxy provider, IBinder token, long timestamp) {
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.sendTimeStampInternalLocked(token, timestamp);
|
}
|
}
|
}
|
|
@Override
|
public void sendKeyDown(TvRemoteProviderProxy provider, IBinder token, int keyCode) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendKeyDown(), token: " + token + ", keyCode: " + keyCode);
|
}
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.sendKeyDownInternalLocked(token, keyCode);
|
}
|
}
|
}
|
|
@Override
|
public void sendKeyUp(TvRemoteProviderProxy provider, IBinder token, int keyCode) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendKeyUp(), token: " + token + ", keyCode: " + keyCode);
|
}
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.sendKeyUpInternalLocked(token, keyCode);
|
}
|
}
|
}
|
|
@Override
|
public void sendPointerDown(TvRemoteProviderProxy provider, IBinder token, int pointerId,
|
int x, int y) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendPointerDown(), token: " + token + ", pointerId: " + pointerId);
|
}
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.sendPointerDownInternalLocked(token, pointerId, x, y);
|
}
|
}
|
}
|
|
@Override
|
public void sendPointerUp(TvRemoteProviderProxy provider, IBinder token, int pointerId) {
|
if (DEBUG_KEYS) {
|
Slog.d(TAG, "sendPointerUp(), token: " + token + ", pointerId: " + pointerId);
|
}
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.sendPointerUpInternalLocked(token, pointerId);
|
}
|
}
|
}
|
|
@Override
|
public void sendPointerSync(TvRemoteProviderProxy provider, IBinder token) {
|
if (DEBUG_KEYS) Slog.d(TAG, "sendPointerSync(), token: " + token);
|
synchronized (mLock) {
|
if (mProviderList.contains(provider)) {
|
mService.sendPointerSyncInternalLocked(token);
|
}
|
}
|
}
|
|
@Override
|
public void addProvider(TvRemoteProviderProxy provider) {
|
if (DEBUG) Slog.d(TAG, "addProvider " + provider);
|
synchronized (mLock) {
|
provider.setProviderSink(this);
|
mProviderList.add(provider);
|
Slog.d(TAG, "provider: " + provider.toString());
|
}
|
}
|
|
@Override
|
public void removeProvider(TvRemoteProviderProxy provider) {
|
if (DEBUG) Slog.d(TAG, "removeProvider " + provider);
|
synchronized (mLock) {
|
if (mProviderList.remove(provider) == false) {
|
Slog.e(TAG, "Unknown provider " + provider);
|
}
|
}
|
}
|
}
|
}
|
