services/core/jni/com_android_server_tv_TvUinputBridge.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright 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.
  */

 #define LOG_TAG "TvRemote-native-uiBridge"

 #include "com_android_server_tv_GamepadKeys.h"
 #include "com_android_server_tv_TvKeys.h"

 #include "jni.h"
 #include <android_runtime/AndroidRuntime.h>
 #include <nativehelper/ScopedUtfChars.h>
 #include <android/keycodes.h>

 #include <utils/BitSet.h>
 #include <utils/Errors.h>
 #include <utils/misc.h>
 #include <utils/Log.h>
 #include <utils/String8.h>

 #include <ctype.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <linux/uinput.h>
 #include <signal.h>
 #include <stdint.h>
 #include <sys/inotify.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 #include <unordered_map>

 #define SLOT_UNKNOWN -1

 namespace android {

 #define GOOGLE_VENDOR_ID 0x18d1

 #define GOOGLE_VIRTUAL_REMOTE_PRODUCT_ID 0x0100
 #define GOOGLE_VIRTUAL_GAMEPAD_PROUCT_ID 0x0200

 static std::unordered_map<int32_t, int> keysMap;
 static std::unordered_map<int32_t, int32_t> slotsMap;
 static BitSet32 mtSlots;

 // Maps android key code to linux key code.
 static std::unordered_map<int32_t, int> gamepadAndroidToLinuxKeyMap;

 // Maps an android gamepad axis to the index within the GAMEPAD_AXES array.
 static std::unordered_map<int32_t, int> gamepadAndroidAxisToIndexMap;

 static void initKeysMap() {
     if (keysMap.empty()) {
         for (size_t i = 0; i < NELEM(KEYS); i++) {
             keysMap[KEYS[i].androidKeyCode] = KEYS[i].linuxKeyCode;
         }
     }
 }

 static void initGamepadKeyMap() {
     if (gamepadAndroidToLinuxKeyMap.empty()) {
         for (size_t i = 0; i < NELEM(GAMEPAD_KEYS); i++) {
             gamepadAndroidToLinuxKeyMap[GAMEPAD_KEYS[i].androidKeyCode] =
                     GAMEPAD_KEYS[i].linuxUinputKeyCode;
         }
     }

     if (gamepadAndroidAxisToIndexMap.empty()) {
         for (size_t i = 0; i < NELEM(GAMEPAD_AXES); i++) {
             gamepadAndroidAxisToIndexMap[GAMEPAD_AXES[i].androidAxis] = i;
         }
     }
 }

 static int32_t getLinuxKeyCode(int32_t androidKeyCode) {
     std::unordered_map<int, int>::iterator it = keysMap.find(androidKeyCode);
     if (it != keysMap.end()) {
         return it->second;
     }
     return KEY_UNKNOWN;
 }

 static int getGamepadkeyCode(int32_t androidKeyCode) {
     std::unordered_map<int32_t, int>::iterator it =
             gamepadAndroidToLinuxKeyMap.find(androidKeyCode);
     if (it != gamepadAndroidToLinuxKeyMap.end()) {
         return it->second;
     }
     return KEY_UNKNOWN;
 }

 static const GamepadAxis* getGamepadAxis(int32_t androidAxisCode) {
     std::unordered_map<int32_t, int>::iterator it =
             gamepadAndroidAxisToIndexMap.find(androidAxisCode);
     if (it == gamepadAndroidAxisToIndexMap.end()) {
         return nullptr;
     }
     return &GAMEPAD_AXES[it->second];
 }

 static int findSlot(int32_t pointerId) {
     std::unordered_map<int, int>::iterator it = slotsMap.find(pointerId);
     if (it != slotsMap.end()) {
         return it->second;
     }
     return SLOT_UNKNOWN;
 }

 static int assignSlot(int32_t pointerId) {
     if (!mtSlots.isFull()) {
         uint32_t slot = mtSlots.markFirstUnmarkedBit();
         slotsMap[pointerId] = slot;
         return slot;
     }
     return SLOT_UNKNOWN;
 }

 static void unassignSlot(int32_t pointerId) {
     int slot = findSlot(pointerId);
     if (slot != SLOT_UNKNOWN) {
         mtSlots.clearBit(slot);
         slotsMap.erase(pointerId);
     }
 }

 static const int kInvalidFileDescriptor = -1;

 // Convenience class to manage an opened /dev/uinput device
 class UInputDescriptor {
 public:
     UInputDescriptor() : mFd(kInvalidFileDescriptor) {
         memset(&mUinputDescriptor, 0, sizeof(mUinputDescriptor));
     }

     // Auto-closes any open /dev/uinput descriptor unless detached.
     ~UInputDescriptor();

     // Open /dev/uinput and prepare to register
     // the device with the given name and unique Id
     bool Open(const char* name, const char* uniqueId, uint16_t product);

     // Checks if the current file descriptor is valid
     bool IsValid() const { return mFd != kInvalidFileDescriptor; }

     void EnableKey(int keyCode);

     void EnableAxesEvents();
     void EnableAxis(int axis, int rangeMin, int rangeMax);

     bool Create();

     // Detaches from the current file descriptor
     // Returns the file descriptor for /dev/uniput
     int Detach();

 private:
     int mFd;
     struct uinput_user_dev mUinputDescriptor;
 };

 UInputDescriptor::~UInputDescriptor() {
     if (mFd != kInvalidFileDescriptor) {
         close(mFd);
         mFd = kInvalidFileDescriptor;
     }
 }

 int UInputDescriptor::Detach() {
     int fd = mFd;
     mFd = kInvalidFileDescriptor;
     return fd;
 }

 bool UInputDescriptor::Open(const char* name, const char* uniqueId, uint16_t product) {
     if (IsValid()) {
         ALOGE("UInput device already open");
         return false;
     }

     mFd = ::open("/dev/uinput", O_WRONLY | O_NDELAY);
     if (mFd < 0) {
         ALOGE("Cannot open /dev/uinput: %s.", strerror(errno));
         mFd = kInvalidFileDescriptor;
         return false;
     }

     // write device unique id to the phys property
     ioctl(mFd, UI_SET_PHYS, uniqueId);

     memset(&mUinputDescriptor, 0, sizeof(mUinputDescriptor));
     strlcpy(mUinputDescriptor.name, name, UINPUT_MAX_NAME_SIZE);
     mUinputDescriptor.id.version = 1;
     mUinputDescriptor.id.bustype = BUS_VIRTUAL;
     mUinputDescriptor.id.vendor = GOOGLE_VENDOR_ID;
     mUinputDescriptor.id.product = product;

     // All UInput devices we use process keys
     ioctl(mFd, UI_SET_EVBIT, EV_KEY);

     return true;
 }

 void UInputDescriptor::EnableKey(int keyCode) {
     ioctl(mFd, UI_SET_KEYBIT, keyCode);
 }

 void UInputDescriptor::EnableAxesEvents() {
     ioctl(mFd, UI_SET_EVBIT, EV_ABS);
 }

 void UInputDescriptor::EnableAxis(int axis, int rangeMin, int rangeMax) {
     if ((axis < 0) || (axis >= NELEM(mUinputDescriptor.absmin))) {
         ALOGE("Invalid axis number: %d", axis);
         return;
     }

     if (ioctl(mFd, UI_SET_ABSBIT, axis) != 0) {
         ALOGE("Failed to set absbit for %d", axis);
     }

     mUinputDescriptor.absmin[axis] = rangeMin;
     mUinputDescriptor.absmax[axis] = rangeMax;
     mUinputDescriptor.absfuzz[axis] = 0;
     mUinputDescriptor.absflat[axis] = 0;
 }

 bool UInputDescriptor::Create() {
     // register the input device
     if (write(mFd, &mUinputDescriptor, sizeof(mUinputDescriptor)) != sizeof(mUinputDescriptor)) {
         ALOGE("Cannot write uinput_user_dev to fd %d: %s.", mFd, strerror(errno));
         return false;
     }

     if (ioctl(mFd, UI_DEV_CREATE) != 0) {
         ALOGE("Unable to create uinput device: %s.", strerror(errno));
         return false;
     }

     ALOGV("Created uinput device, fd=%d.", mFd);

     return true;
 }

 class NativeConnection {
 public:
     enum class ConnectionType {
         kRemoteDevice,
         kGamepadDevice,
     };

     ~NativeConnection();

     static NativeConnection* open(const char* name, const char* uniqueId,
             int32_t width, int32_t height, int32_t maxPointerId);

     static NativeConnection* openGamepad(const char* name, const char* uniqueId);

     void sendEvent(int32_t type, int32_t code, int32_t value);

     int32_t getMaxPointers() const { return mMaxPointers; }

     ConnectionType getType() const { return mType; }

     bool IsGamepad() const { return getType() == ConnectionType::kGamepadDevice; }

     bool IsRemote() const { return getType() == ConnectionType::kRemoteDevice; }

 private:
     NativeConnection(int fd, int32_t maxPointers, ConnectionType type);

     const int mFd;
     const int32_t mMaxPointers;
     const ConnectionType mType;
 };

 NativeConnection::NativeConnection(int fd, int32_t maxPointers, ConnectionType type)
       : mFd(fd), mMaxPointers(maxPointers), mType(type) {}

 NativeConnection::~NativeConnection() {
     ALOGI("Un-Registering uinput device %d.", mFd);
     ioctl(mFd, UI_DEV_DESTROY);
     close(mFd);
 }

 NativeConnection* NativeConnection::open(const char* name, const char* uniqueId,
         int32_t width, int32_t height, int32_t maxPointers) {
     ALOGI("Registering uinput device %s: touch pad size %dx%d, "
             "max pointers %d.", name, width, height, maxPointers);

     initKeysMap();

     UInputDescriptor descriptor;
     if (!descriptor.Open(name, uniqueId, GOOGLE_VIRTUAL_REMOTE_PRODUCT_ID)) {
         return nullptr;
     }

     // set the keys mapped
     for (size_t i = 0; i < NELEM(KEYS); i++) {
         descriptor.EnableKey(KEYS[i].linuxKeyCode);
     }

     if (!descriptor.Create()) {
         return nullptr;
     }

     return new NativeConnection(descriptor.Detach(), maxPointers, ConnectionType::kRemoteDevice);
 }

 NativeConnection* NativeConnection::openGamepad(const char* name, const char* uniqueId) {
     ALOGI("Registering uinput device %s: gamepad", name);

     initGamepadKeyMap();

     UInputDescriptor descriptor;
     if (!descriptor.Open(name, uniqueId, GOOGLE_VIRTUAL_GAMEPAD_PROUCT_ID)) {
         return nullptr;
     }

     // set the keys mapped for gamepads
     for (size_t i = 0; i < NELEM(GAMEPAD_KEYS); i++) {
         descriptor.EnableKey(GAMEPAD_KEYS[i].linuxUinputKeyCode);
     }

     // define the axes that are required
     descriptor.EnableAxesEvents();
     for (size_t i = 0; i < NELEM(GAMEPAD_AXES); i++) {
         const GamepadAxis& axis = GAMEPAD_AXES[i];
         descriptor.EnableAxis(axis.linuxUinputAxis, axis.linuxUinputRangeMin,
                               axis.linuxUinputRangeMax);
     }

     if (!descriptor.Create()) {
         return nullptr;
     }

     return new NativeConnection(descriptor.Detach(), 0, ConnectionType::kGamepadDevice);
 }

 void NativeConnection::sendEvent(int32_t type, int32_t code, int32_t value) {
     struct input_event iev;
     memset(&iev, 0, sizeof(iev));
     iev.type = type;
     iev.code = code;
     iev.value = value;
     write(mFd, &iev, sizeof(iev));
 }

 static jlong nativeOpen(JNIEnv* env, jclass clazz,
         jstring nameStr, jstring uniqueIdStr,
         jint width, jint height, jint maxPointers) {
     ScopedUtfChars name(env, nameStr);
     ScopedUtfChars uniqueId(env, uniqueIdStr);

     NativeConnection* connection = NativeConnection::open(name.c_str(), uniqueId.c_str(),
             width, height, maxPointers);
     return reinterpret_cast<jlong>(connection);
 }

 static jlong nativeGamepadOpen(JNIEnv* env, jclass clazz, jstring nameStr, jstring uniqueIdStr) {
     ScopedUtfChars name(env, nameStr);
     ScopedUtfChars uniqueId(env, uniqueIdStr);

     NativeConnection* connection = NativeConnection::openGamepad(name.c_str(), uniqueId.c_str());
     return reinterpret_cast<jlong>(connection);
 }

 static void nativeClose(JNIEnv* env, jclass clazz, jlong ptr) {
     NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);
     delete connection;
 }

 static void nativeSendKey(JNIEnv* env, jclass clazz, jlong ptr, jint keyCode, jboolean down) {
     int32_t code = getLinuxKeyCode(keyCode);
     NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

     if (connection->IsGamepad()) {
         ALOGE("Invalid key even for a gamepad - need to send gamepad events");
         return;
     }

     if (code != KEY_UNKNOWN) {
         connection->sendEvent(EV_KEY, code, down ? 1 : 0);
     } else {
         ALOGE("Received an unknown keycode of %d.", keyCode);
     }
 }

 static void nativeSendGamepadKey(JNIEnv* env, jclass clazz, jlong ptr, jint keyCode,
                                  jboolean down) {
     NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

     if (!connection->IsGamepad()) {
         ALOGE("Invalid gamepad key for non-gamepad device");
         return;
     }

     int linuxKeyCode = getGamepadkeyCode(keyCode);
     if (linuxKeyCode == KEY_UNKNOWN) {
         ALOGE("Gamepad: received an unknown keycode of %d.", keyCode);
         return;
     }
     connection->sendEvent(EV_KEY, linuxKeyCode, down ? 1 : 0);
 }

 static void nativeSendGamepadAxisValue(JNIEnv* env, jclass clazz, jlong ptr, jint axis,
                                        jfloat value) {
     NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

     if (!connection->IsGamepad()) {
         ALOGE("Invalid axis send for non-gamepad device");
         return;
     }

     const GamepadAxis* axisInfo = getGamepadAxis(axis);
     if (axisInfo == nullptr) {
         ALOGE("Invalid axis: %d", axis);
         return;
     }

     if (value > axisInfo->androidRangeMax) {
         value = axisInfo->androidRangeMax;
     } else if (value < axisInfo->androidRangeMin) {
         value = axisInfo->androidRangeMin;
     }

     // Converts the android range into the device range
     float movementPercent = (value - axisInfo->androidRangeMin) /
             (axisInfo->androidRangeMax - axisInfo->androidRangeMin);
     int axisRawValue = axisInfo->linuxUinputRangeMin +
             movementPercent * (axisInfo->linuxUinputRangeMax - axisInfo->linuxUinputRangeMin);

     connection->sendEvent(EV_ABS, axisInfo->linuxUinputAxis, axisRawValue);
 }

 static void nativeSendPointerDown(JNIEnv* env, jclass clazz, jlong ptr,
         jint pointerId, jint x, jint y) {
     NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

     if (connection->IsGamepad()) {
         ALOGE("Invalid pointer down event for a gamepad.");
         return;
     }

     int32_t slot = findSlot(pointerId);
     if (slot == SLOT_UNKNOWN) {
         slot = assignSlot(pointerId);
     }
     if (slot != SLOT_UNKNOWN) {
         connection->sendEvent(EV_ABS, ABS_MT_SLOT, slot);
         connection->sendEvent(EV_ABS, ABS_MT_TRACKING_ID, pointerId);
         connection->sendEvent(EV_ABS, ABS_MT_POSITION_X, x);
         connection->sendEvent(EV_ABS, ABS_MT_POSITION_Y, y);
     }
 }

 static void nativeSendPointerUp(JNIEnv* env, jclass clazz, jlong ptr,
         jint pointerId) {
     NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

     if (connection->IsGamepad()) {
         ALOGE("Invalid pointer up event for a gamepad.");
         return;
     }

     int32_t slot = findSlot(pointerId);
     if (slot != SLOT_UNKNOWN) {
         connection->sendEvent(EV_ABS, ABS_MT_SLOT, slot);
         connection->sendEvent(EV_ABS, ABS_MT_TRACKING_ID, -1);
         unassignSlot(pointerId);
     }
 }

 static void nativeSendPointerSync(JNIEnv* env, jclass clazz, jlong ptr) {
     NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);
     connection->sendEvent(EV_SYN, SYN_REPORT, 0);
 }

 static void nativeClear(JNIEnv* env, jclass clazz, jlong ptr) {
     NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

     // Clear keys.
     if (connection->IsRemote()) {
         for (size_t i = 0; i < NELEM(KEYS); i++) {
             connection->sendEvent(EV_KEY, KEYS[i].linuxKeyCode, 0);
         }

         // Clear pointers.
         int32_t slot = SLOT_UNKNOWN;
         for (int32_t i = 0; i < connection->getMaxPointers(); i++) {
             slot = findSlot(i);
             if (slot != SLOT_UNKNOWN) {
                 connection->sendEvent(EV_ABS, ABS_MT_SLOT, slot);
                 connection->sendEvent(EV_ABS, ABS_MT_TRACKING_ID, -1);
             }
         }
     } else {
         for (size_t i = 0; i < NELEM(GAMEPAD_KEYS); i++) {
             connection->sendEvent(EV_KEY, GAMEPAD_KEYS[i].linuxUinputKeyCode, 0);
         }

         for (size_t i = 0; i < NELEM(GAMEPAD_AXES); i++) {
             const GamepadAxis& axis = GAMEPAD_AXES[i];

             if ((axis.linuxUinputAxis == ABS_Z) || (axis.linuxUinputAxis == ABS_RZ)) {
                 // Mark triggers unpressed
                 connection->sendEvent(EV_ABS, axis.linuxUinputAxis, axis.linuxUinputRangeMin);
             } else {
                 // Joysticks and dpad rests on center
                 connection->sendEvent(EV_ABS, axis.linuxUinputAxis,
                                       (axis.linuxUinputRangeMin + axis.linuxUinputRangeMax) / 2);
             }
         }
     }

     // Sync pointer events
     connection->sendEvent(EV_SYN, SYN_REPORT, 0);
 }

 /*
  * JNI registration
  */

 static JNINativeMethod gUinputBridgeMethods[] = {
         {"nativeOpen", "(Ljava/lang/String;Ljava/lang/String;III)J", (void*)nativeOpen},
         {"nativeGamepadOpen", "(Ljava/lang/String;Ljava/lang/String;)J", (void*)nativeGamepadOpen},
         {"nativeClose", "(J)V", (void*)nativeClose},
         {"nativeSendKey", "(JIZ)V", (void*)nativeSendKey},
         {"nativeSendPointerDown", "(JIII)V", (void*)nativeSendPointerDown},
         {"nativeSendPointerUp", "(JI)V", (void*)nativeSendPointerUp},
         {"nativeClear", "(J)V", (void*)nativeClear},
         {"nativeSendPointerSync", "(J)V", (void*)nativeSendPointerSync},
         {"nativeSendGamepadKey", "(JIZ)V", (void*)nativeSendGamepadKey},
         {"nativeSendGamepadAxisValue", "(JIF)V", (void*)nativeSendGamepadAxisValue},
 };

 int register_android_server_tv_TvUinputBridge(JNIEnv* env) {
     int res = jniRegisterNativeMethods(env, "com/android/server/tv/UinputBridge",
               gUinputBridgeMethods, NELEM(gUinputBridgeMethods));

     LOG_FATAL_IF(res < 0, "Unable to register native methods.");
     (void)res; // Don't complain about unused variable in the LOG_NDEBUG case

     return 0;
 }

 } // namespace android
	/*
	* Copyright 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.
	*/

	#define LOG_TAG "TvRemote-native-uiBridge"

	#include "com_android_server_tv_GamepadKeys.h"
	#include "com_android_server_tv_TvKeys.h"

	#include "jni.h"
	#include <android_runtime/AndroidRuntime.h>
	#include <nativehelper/ScopedUtfChars.h>
	#include <android/keycodes.h>

	#include <utils/BitSet.h>
	#include <utils/Errors.h>
	#include <utils/misc.h>
	#include <utils/Log.h>
	#include <utils/String8.h>

	#include <ctype.h>
	#include <fcntl.h>
	#include <linux/input.h>
	#include <linux/uinput.h>
	#include <signal.h>
	#include <stdint.h>
	#include <sys/inotify.h>
	#include <sys/stat.h>
	#include <sys/time.h>
	#include <sys/types.h>
	#include <time.h>
	#include <unistd.h>
	#include <unordered_map>

	#define SLOT_UNKNOWN -1

	namespace android {

	#define GOOGLE_VENDOR_ID 0x18d1

	#define GOOGLE_VIRTUAL_REMOTE_PRODUCT_ID 0x0100
	#define GOOGLE_VIRTUAL_GAMEPAD_PROUCT_ID 0x0200

	static std::unordered_map<int32_t, int> keysMap;
	static std::unordered_map<int32_t, int32_t> slotsMap;
	static BitSet32 mtSlots;

	// Maps android key code to linux key code.
	static std::unordered_map<int32_t, int> gamepadAndroidToLinuxKeyMap;

	// Maps an android gamepad axis to the index within the GAMEPAD_AXES array.
	static std::unordered_map<int32_t, int> gamepadAndroidAxisToIndexMap;

	static void initKeysMap() {
	if (keysMap.empty()) {
	for (size_t i = 0; i < NELEM(KEYS); i++) {
	keysMap[KEYS[i].androidKeyCode] = KEYS[i].linuxKeyCode;
	}
	}
	}

	static void initGamepadKeyMap() {
	if (gamepadAndroidToLinuxKeyMap.empty()) {
	for (size_t i = 0; i < NELEM(GAMEPAD_KEYS); i++) {
	gamepadAndroidToLinuxKeyMap[GAMEPAD_KEYS[i].androidKeyCode] =
	GAMEPAD_KEYS[i].linuxUinputKeyCode;
	}
	}

	if (gamepadAndroidAxisToIndexMap.empty()) {
	for (size_t i = 0; i < NELEM(GAMEPAD_AXES); i++) {
	gamepadAndroidAxisToIndexMap[GAMEPAD_AXES[i].androidAxis] = i;
	}
	}
	}

	static int32_t getLinuxKeyCode(int32_t androidKeyCode) {
	std::unordered_map<int, int>::iterator it = keysMap.find(androidKeyCode);
	if (it != keysMap.end()) {
	return it->second;
	}
	return KEY_UNKNOWN;
	}

	static int getGamepadkeyCode(int32_t androidKeyCode) {
	std::unordered_map<int32_t, int>::iterator it =
	gamepadAndroidToLinuxKeyMap.find(androidKeyCode);
	if (it != gamepadAndroidToLinuxKeyMap.end()) {
	return it->second;
	}
	return KEY_UNKNOWN;
	}

	static const GamepadAxis* getGamepadAxis(int32_t androidAxisCode) {
	std::unordered_map<int32_t, int>::iterator it =
	gamepadAndroidAxisToIndexMap.find(androidAxisCode);
	if (it == gamepadAndroidAxisToIndexMap.end()) {
	return nullptr;
	}
	return &GAMEPAD_AXES[it->second];
	}

	static int findSlot(int32_t pointerId) {
	std::unordered_map<int, int>::iterator it = slotsMap.find(pointerId);
	if (it != slotsMap.end()) {
	return it->second;
	}
	return SLOT_UNKNOWN;
	}

	static int assignSlot(int32_t pointerId) {
	if (!mtSlots.isFull()) {
	uint32_t slot = mtSlots.markFirstUnmarkedBit();
	slotsMap[pointerId] = slot;
	return slot;
	}
	return SLOT_UNKNOWN;
	}

	static void unassignSlot(int32_t pointerId) {
	int slot = findSlot(pointerId);
	if (slot != SLOT_UNKNOWN) {
	mtSlots.clearBit(slot);
	slotsMap.erase(pointerId);
	}
	}

	static const int kInvalidFileDescriptor = -1;

	// Convenience class to manage an opened /dev/uinput device
	class UInputDescriptor {
	public:
	UInputDescriptor() : mFd(kInvalidFileDescriptor) {
	memset(&mUinputDescriptor, 0, sizeof(mUinputDescriptor));
	}

	// Auto-closes any open /dev/uinput descriptor unless detached.
	~UInputDescriptor();

	// Open /dev/uinput and prepare to register
	// the device with the given name and unique Id
	bool Open(const char* name, const char* uniqueId, uint16_t product);

	// Checks if the current file descriptor is valid
	bool IsValid() const { return mFd != kInvalidFileDescriptor; }

	void EnableKey(int keyCode);

	void EnableAxesEvents();
	void EnableAxis(int axis, int rangeMin, int rangeMax);

	bool Create();

	// Detaches from the current file descriptor
	// Returns the file descriptor for /dev/uniput
	int Detach();

	private:
	int mFd;
	struct uinput_user_dev mUinputDescriptor;
	};

	UInputDescriptor::~UInputDescriptor() {
	if (mFd != kInvalidFileDescriptor) {
	close(mFd);
	mFd = kInvalidFileDescriptor;
	}
	}

	int UInputDescriptor::Detach() {
	int fd = mFd;
	mFd = kInvalidFileDescriptor;
	return fd;
	}

	bool UInputDescriptor::Open(const char* name, const char* uniqueId, uint16_t product) {
	if (IsValid()) {
	ALOGE("UInput device already open");
	return false;
	}

	mFd = ::open("/dev/uinput", O_WRONLY \| O_NDELAY);
	if (mFd < 0) {
	ALOGE("Cannot open /dev/uinput: %s.", strerror(errno));
	mFd = kInvalidFileDescriptor;
	return false;
	}

	// write device unique id to the phys property
	ioctl(mFd, UI_SET_PHYS, uniqueId);

	memset(&mUinputDescriptor, 0, sizeof(mUinputDescriptor));
	strlcpy(mUinputDescriptor.name, name, UINPUT_MAX_NAME_SIZE);
	mUinputDescriptor.id.version = 1;
	mUinputDescriptor.id.bustype = BUS_VIRTUAL;
	mUinputDescriptor.id.vendor = GOOGLE_VENDOR_ID;
	mUinputDescriptor.id.product = product;

	// All UInput devices we use process keys
	ioctl(mFd, UI_SET_EVBIT, EV_KEY);

	return true;
	}

	void UInputDescriptor::EnableKey(int keyCode) {
	ioctl(mFd, UI_SET_KEYBIT, keyCode);
	}

	void UInputDescriptor::EnableAxesEvents() {
	ioctl(mFd, UI_SET_EVBIT, EV_ABS);
	}

	void UInputDescriptor::EnableAxis(int axis, int rangeMin, int rangeMax) {
	if ((axis < 0) \|\| (axis >= NELEM(mUinputDescriptor.absmin))) {
	ALOGE("Invalid axis number: %d", axis);
	return;
	}

	if (ioctl(mFd, UI_SET_ABSBIT, axis) != 0) {
	ALOGE("Failed to set absbit for %d", axis);
	}

	mUinputDescriptor.absmin[axis] = rangeMin;
	mUinputDescriptor.absmax[axis] = rangeMax;
	mUinputDescriptor.absfuzz[axis] = 0;
	mUinputDescriptor.absflat[axis] = 0;
	}

	bool UInputDescriptor::Create() {
	// register the input device
	if (write(mFd, &mUinputDescriptor, sizeof(mUinputDescriptor)) != sizeof(mUinputDescriptor)) {
	ALOGE("Cannot write uinput_user_dev to fd %d: %s.", mFd, strerror(errno));
	return false;
	}

	if (ioctl(mFd, UI_DEV_CREATE) != 0) {
	ALOGE("Unable to create uinput device: %s.", strerror(errno));
	return false;
	}

	ALOGV("Created uinput device, fd=%d.", mFd);

	return true;
	}

	class NativeConnection {
	public:
	enum class ConnectionType {
	kRemoteDevice,
	kGamepadDevice,
	};

	~NativeConnection();

	static NativeConnection* open(const char* name, const char* uniqueId,
	int32_t width, int32_t height, int32_t maxPointerId);

	static NativeConnection* openGamepad(const char* name, const char* uniqueId);

	void sendEvent(int32_t type, int32_t code, int32_t value);

	int32_t getMaxPointers() const { return mMaxPointers; }

	ConnectionType getType() const { return mType; }

	bool IsGamepad() const { return getType() == ConnectionType::kGamepadDevice; }

	bool IsRemote() const { return getType() == ConnectionType::kRemoteDevice; }

	private:
	NativeConnection(int fd, int32_t maxPointers, ConnectionType type);

	const int mFd;
	const int32_t mMaxPointers;
	const ConnectionType mType;
	};

	NativeConnection::NativeConnection(int fd, int32_t maxPointers, ConnectionType type)
	: mFd(fd), mMaxPointers(maxPointers), mType(type) {}

	NativeConnection::~NativeConnection() {
	ALOGI("Un-Registering uinput device %d.", mFd);
	ioctl(mFd, UI_DEV_DESTROY);
	close(mFd);
	}

	NativeConnection* NativeConnection::open(const char* name, const char* uniqueId,
	int32_t width, int32_t height, int32_t maxPointers) {
	ALOGI("Registering uinput device %s: touch pad size %dx%d, "
	"max pointers %d.", name, width, height, maxPointers);

	initKeysMap();

	UInputDescriptor descriptor;
	if (!descriptor.Open(name, uniqueId, GOOGLE_VIRTUAL_REMOTE_PRODUCT_ID)) {
	return nullptr;
	}

	// set the keys mapped
	for (size_t i = 0; i < NELEM(KEYS); i++) {
	descriptor.EnableKey(KEYS[i].linuxKeyCode);
	}

	if (!descriptor.Create()) {
	return nullptr;
	}

	return new NativeConnection(descriptor.Detach(), maxPointers, ConnectionType::kRemoteDevice);
	}

	NativeConnection* NativeConnection::openGamepad(const char* name, const char* uniqueId) {
	ALOGI("Registering uinput device %s: gamepad", name);

	initGamepadKeyMap();

	UInputDescriptor descriptor;
	if (!descriptor.Open(name, uniqueId, GOOGLE_VIRTUAL_GAMEPAD_PROUCT_ID)) {
	return nullptr;
	}

	// set the keys mapped for gamepads
	for (size_t i = 0; i < NELEM(GAMEPAD_KEYS); i++) {
	descriptor.EnableKey(GAMEPAD_KEYS[i].linuxUinputKeyCode);
	}

	// define the axes that are required
	descriptor.EnableAxesEvents();
	for (size_t i = 0; i < NELEM(GAMEPAD_AXES); i++) {
	const GamepadAxis& axis = GAMEPAD_AXES[i];
	descriptor.EnableAxis(axis.linuxUinputAxis, axis.linuxUinputRangeMin,
	axis.linuxUinputRangeMax);
	}

	if (!descriptor.Create()) {
	return nullptr;
	}

	return new NativeConnection(descriptor.Detach(), 0, ConnectionType::kGamepadDevice);
	}

	void NativeConnection::sendEvent(int32_t type, int32_t code, int32_t value) {
	struct input_event iev;
	memset(&iev, 0, sizeof(iev));
	iev.type = type;
	iev.code = code;
	iev.value = value;
	write(mFd, &iev, sizeof(iev));
	}

	static jlong nativeOpen(JNIEnv* env, jclass clazz,
	jstring nameStr, jstring uniqueIdStr,
	jint width, jint height, jint maxPointers) {
	ScopedUtfChars name(env, nameStr);
	ScopedUtfChars uniqueId(env, uniqueIdStr);

	NativeConnection* connection = NativeConnection::open(name.c_str(), uniqueId.c_str(),
	width, height, maxPointers);
	return reinterpret_cast<jlong>(connection);
	}

	static jlong nativeGamepadOpen(JNIEnv* env, jclass clazz, jstring nameStr, jstring uniqueIdStr) {
	ScopedUtfChars name(env, nameStr);
	ScopedUtfChars uniqueId(env, uniqueIdStr);

	NativeConnection* connection = NativeConnection::openGamepad(name.c_str(), uniqueId.c_str());
	return reinterpret_cast<jlong>(connection);
	}

	static void nativeClose(JNIEnv* env, jclass clazz, jlong ptr) {
	NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);
	delete connection;
	}

	static void nativeSendKey(JNIEnv* env, jclass clazz, jlong ptr, jint keyCode, jboolean down) {
	int32_t code = getLinuxKeyCode(keyCode);
	NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

	if (connection->IsGamepad()) {
	ALOGE("Invalid key even for a gamepad - need to send gamepad events");
	return;
	}

	if (code != KEY_UNKNOWN) {
	connection->sendEvent(EV_KEY, code, down ? 1 : 0);
	} else {
	ALOGE("Received an unknown keycode of %d.", keyCode);
	}
	}

	static void nativeSendGamepadKey(JNIEnv* env, jclass clazz, jlong ptr, jint keyCode,
	jboolean down) {
	NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

	if (!connection->IsGamepad()) {
	ALOGE("Invalid gamepad key for non-gamepad device");
	return;
	}

	int linuxKeyCode = getGamepadkeyCode(keyCode);
	if (linuxKeyCode == KEY_UNKNOWN) {
	ALOGE("Gamepad: received an unknown keycode of %d.", keyCode);
	return;
	}
	connection->sendEvent(EV_KEY, linuxKeyCode, down ? 1 : 0);
	}

	static void nativeSendGamepadAxisValue(JNIEnv* env, jclass clazz, jlong ptr, jint axis,
	jfloat value) {
	NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

	if (!connection->IsGamepad()) {
	ALOGE("Invalid axis send for non-gamepad device");
	return;
	}

	const GamepadAxis* axisInfo = getGamepadAxis(axis);
	if (axisInfo == nullptr) {
	ALOGE("Invalid axis: %d", axis);
	return;
	}

	if (value > axisInfo->androidRangeMax) {
	value = axisInfo->androidRangeMax;
	} else if (value < axisInfo->androidRangeMin) {
	value = axisInfo->androidRangeMin;
	}

	// Converts the android range into the device range
	float movementPercent = (value - axisInfo->androidRangeMin) /
	(axisInfo->androidRangeMax - axisInfo->androidRangeMin);
	int axisRawValue = axisInfo->linuxUinputRangeMin +
	movementPercent * (axisInfo->linuxUinputRangeMax - axisInfo->linuxUinputRangeMin);

	connection->sendEvent(EV_ABS, axisInfo->linuxUinputAxis, axisRawValue);
	}

	static void nativeSendPointerDown(JNIEnv* env, jclass clazz, jlong ptr,
	jint pointerId, jint x, jint y) {
	NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

	if (connection->IsGamepad()) {
	ALOGE("Invalid pointer down event for a gamepad.");
	return;
	}

	int32_t slot = findSlot(pointerId);
	if (slot == SLOT_UNKNOWN) {
	slot = assignSlot(pointerId);
	}
	if (slot != SLOT_UNKNOWN) {
	connection->sendEvent(EV_ABS, ABS_MT_SLOT, slot);
	connection->sendEvent(EV_ABS, ABS_MT_TRACKING_ID, pointerId);
	connection->sendEvent(EV_ABS, ABS_MT_POSITION_X, x);
	connection->sendEvent(EV_ABS, ABS_MT_POSITION_Y, y);
	}
	}

	static void nativeSendPointerUp(JNIEnv* env, jclass clazz, jlong ptr,
	jint pointerId) {
	NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

	if (connection->IsGamepad()) {
	ALOGE("Invalid pointer up event for a gamepad.");
	return;
	}

	int32_t slot = findSlot(pointerId);
	if (slot != SLOT_UNKNOWN) {
	connection->sendEvent(EV_ABS, ABS_MT_SLOT, slot);
	connection->sendEvent(EV_ABS, ABS_MT_TRACKING_ID, -1);
	unassignSlot(pointerId);
	}
	}

	static void nativeSendPointerSync(JNIEnv* env, jclass clazz, jlong ptr) {
	NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);
	connection->sendEvent(EV_SYN, SYN_REPORT, 0);
	}

	static void nativeClear(JNIEnv* env, jclass clazz, jlong ptr) {
	NativeConnection* connection = reinterpret_cast<NativeConnection*>(ptr);

	// Clear keys.
	if (connection->IsRemote()) {
	for (size_t i = 0; i < NELEM(KEYS); i++) {
	connection->sendEvent(EV_KEY, KEYS[i].linuxKeyCode, 0);
	}

	// Clear pointers.
	int32_t slot = SLOT_UNKNOWN;
	for (int32_t i = 0; i < connection->getMaxPointers(); i++) {
	slot = findSlot(i);
	if (slot != SLOT_UNKNOWN) {
	connection->sendEvent(EV_ABS, ABS_MT_SLOT, slot);
	connection->sendEvent(EV_ABS, ABS_MT_TRACKING_ID, -1);
	}
	}
	} else {
	for (size_t i = 0; i < NELEM(GAMEPAD_KEYS); i++) {
	connection->sendEvent(EV_KEY, GAMEPAD_KEYS[i].linuxUinputKeyCode, 0);
	}

	for (size_t i = 0; i < NELEM(GAMEPAD_AXES); i++) {
	const GamepadAxis& axis = GAMEPAD_AXES[i];

	if ((axis.linuxUinputAxis == ABS_Z) \|\| (axis.linuxUinputAxis == ABS_RZ)) {
	// Mark triggers unpressed
	connection->sendEvent(EV_ABS, axis.linuxUinputAxis, axis.linuxUinputRangeMin);
	} else {
	// Joysticks and dpad rests on center
	connection->sendEvent(EV_ABS, axis.linuxUinputAxis,
	(axis.linuxUinputRangeMin + axis.linuxUinputRangeMax) / 2);
	}
	}
	}

	// Sync pointer events
	connection->sendEvent(EV_SYN, SYN_REPORT, 0);
	}

	/*
	* JNI registration
	*/

	static JNINativeMethod gUinputBridgeMethods[] = {
	{"nativeOpen", "(Ljava/lang/String;Ljava/lang/String;III)J", (void*)nativeOpen},
	{"nativeGamepadOpen", "(Ljava/lang/String;Ljava/lang/String;)J", (void*)nativeGamepadOpen},
	{"nativeClose", "(J)V", (void*)nativeClose},
	{"nativeSendKey", "(JIZ)V", (void*)nativeSendKey},
	{"nativeSendPointerDown", "(JIII)V", (void*)nativeSendPointerDown},
	{"nativeSendPointerUp", "(JI)V", (void*)nativeSendPointerUp},
	{"nativeClear", "(J)V", (void*)nativeClear},
	{"nativeSendPointerSync", "(J)V", (void*)nativeSendPointerSync},
	{"nativeSendGamepadKey", "(JIZ)V", (void*)nativeSendGamepadKey},
	{"nativeSendGamepadAxisValue", "(JIF)V", (void*)nativeSendGamepadAxisValue},
	};

	int register_android_server_tv_TvUinputBridge(JNIEnv* env) {
	int res = jniRegisterNativeMethods(env, "com/android/server/tv/UinputBridge",
	gUinputBridgeMethods, NELEM(gUinputBridgeMethods));

	LOG_FATAL_IF(res < 0, "Unable to register native methods.");
	(void)res; // Don't complain about unused variable in the LOG_NDEBUG case

	return 0;
	}

	} // namespace android