// // Copyright 2010 The Android Open Source Project // // The input reader. // #define LOG_TAG "InputReader" //#define LOG_NDEBUG 0 // Log debug messages for each raw event received from the EventHub. #define DEBUG_RAW_EVENTS 0 // Log debug messages about touch screen filtering hacks. #define DEBUG_HACKS 0 // Log debug messages about virtual key processing. #define DEBUG_VIRTUAL_KEYS 0 // Log debug messages about pointers. #define DEBUG_POINTERS 0 // Log debug messages about pointer assignment calculations. #define DEBUG_POINTER_ASSIGNMENT 0 #include #include #include #include #include #include #include /** Amount that trackball needs to move in order to generate a key event. */ #define TRACKBALL_MOVEMENT_THRESHOLD 6 namespace android { // --- Static Functions --- template inline static T abs(const T& value) { return value < 0 ? - value : value; } template inline static T min(const T& a, const T& b) { return a < b ? a : b; } template inline static void swap(T& a, T& b) { T temp = a; a = b; b = temp; } int32_t updateMetaState(int32_t keyCode, bool down, int32_t oldMetaState) { int32_t mask; switch (keyCode) { case AKEYCODE_ALT_LEFT: mask = AMETA_ALT_LEFT_ON; break; case AKEYCODE_ALT_RIGHT: mask = AMETA_ALT_RIGHT_ON; break; case AKEYCODE_SHIFT_LEFT: mask = AMETA_SHIFT_LEFT_ON; break; case AKEYCODE_SHIFT_RIGHT: mask = AMETA_SHIFT_RIGHT_ON; break; case AKEYCODE_SYM: mask = AMETA_SYM_ON; break; default: return oldMetaState; } int32_t newMetaState = down ? oldMetaState | mask : oldMetaState & ~ mask & ~ (AMETA_ALT_ON | AMETA_SHIFT_ON); if (newMetaState & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) { newMetaState |= AMETA_ALT_ON; } if (newMetaState & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) { newMetaState |= AMETA_SHIFT_ON; } return newMetaState; } static const int32_t keyCodeRotationMap[][4] = { // key codes enumerated counter-clockwise with the original (unrotated) key first // no rotation, 90 degree rotation, 180 degree rotation, 270 degree rotation { AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT }, { AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN }, { AKEYCODE_DPAD_UP, AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT }, { AKEYCODE_DPAD_LEFT, AKEYCODE_DPAD_DOWN, AKEYCODE_DPAD_RIGHT, AKEYCODE_DPAD_UP }, }; static const int keyCodeRotationMapSize = sizeof(keyCodeRotationMap) / sizeof(keyCodeRotationMap[0]); int32_t rotateKeyCode(int32_t keyCode, int32_t orientation) { if (orientation != InputReaderPolicyInterface::ROTATION_0) { for (int i = 0; i < keyCodeRotationMapSize; i++) { if (keyCode == keyCodeRotationMap[i][0]) { return keyCodeRotationMap[i][orientation]; } } } return keyCode; } // --- InputReader --- InputReader::InputReader(const sp& eventHub, const sp& policy, const sp& dispatcher) : mEventHub(eventHub), mPolicy(policy), mDispatcher(dispatcher) { configureExcludedDevices(); resetGlobalMetaState(); resetDisplayProperties(); updateExportedVirtualKeyState(); } InputReader::~InputReader() { for (size_t i = 0; i < mDevices.size(); i++) { delete mDevices.valueAt(i); } } void InputReader::loopOnce() { RawEvent rawEvent; mEventHub->getEvent(& rawEvent.deviceId, & rawEvent.type, & rawEvent.scanCode, & rawEvent.keyCode, & rawEvent.flags, & rawEvent.value, & rawEvent.when); // Replace the event timestamp so it is in same timebase as java.lang.System.nanoTime() // and android.os.SystemClock.uptimeMillis() as expected by the rest of the system. rawEvent.when = systemTime(SYSTEM_TIME_MONOTONIC); #if DEBUG_RAW_EVENTS LOGD("Input event: device=0x%x type=0x%x scancode=%d keycode=%d value=%d", rawEvent.deviceId, rawEvent.type, rawEvent.scanCode, rawEvent.keyCode, rawEvent.value); #endif process(& rawEvent); } void InputReader::process(const RawEvent* rawEvent) { switch (rawEvent->type) { case EventHubInterface::DEVICE_ADDED: handleDeviceAdded(rawEvent); break; case EventHubInterface::DEVICE_REMOVED: handleDeviceRemoved(rawEvent); break; case EV_SYN: handleSync(rawEvent); break; case EV_KEY: handleKey(rawEvent); break; case EV_REL: handleRelativeMotion(rawEvent); break; case EV_ABS: handleAbsoluteMotion(rawEvent); break; case EV_SW: handleSwitch(rawEvent); break; } } void InputReader::handleDeviceAdded(const RawEvent* rawEvent) { InputDevice* device = getDevice(rawEvent->deviceId); if (device) { LOGW("Ignoring spurious device added event for deviceId %d.", rawEvent->deviceId); return; } addDevice(rawEvent->when, rawEvent->deviceId); } void InputReader::handleDeviceRemoved(const RawEvent* rawEvent) { InputDevice* device = getDevice(rawEvent->deviceId); if (! device) { LOGW("Ignoring spurious device removed event for deviceId %d.", rawEvent->deviceId); return; } removeDevice(rawEvent->when, device); } void InputReader::handleSync(const RawEvent* rawEvent) { InputDevice* device = getNonIgnoredDevice(rawEvent->deviceId); if (! device) return; if (rawEvent->scanCode == SYN_MT_REPORT) { // MultiTouch Sync: The driver has returned all data for *one* of the pointers. // We drop pointers with pressure <= 0 since that indicates they are not down. if (device->isMultiTouchScreen()) { uint32_t pointerIndex = device->multiTouchScreen.accumulator.pointerCount; if (device->multiTouchScreen.accumulator.pointers[pointerIndex].fields) { if (pointerIndex == MAX_POINTERS) { LOGW("MultiTouch device driver returned more than maximum of %d pointers.", MAX_POINTERS); } else { pointerIndex += 1; device->multiTouchScreen.accumulator.pointerCount = pointerIndex; } } device->multiTouchScreen.accumulator.pointers[pointerIndex].clear(); } } else if (rawEvent->scanCode == SYN_REPORT) { // General Sync: The driver has returned all data for the current event update. if (device->isMultiTouchScreen()) { if (device->multiTouchScreen.accumulator.isDirty()) { onMultiTouchScreenStateChanged(rawEvent->when, device); device->multiTouchScreen.accumulator.clear(); } } else if (device->isSingleTouchScreen()) { if (device->singleTouchScreen.accumulator.isDirty()) { onSingleTouchScreenStateChanged(rawEvent->when, device); device->singleTouchScreen.accumulator.clear(); } } if (device->trackball.accumulator.isDirty()) { onTrackballStateChanged(rawEvent->when, device); device->trackball.accumulator.clear(); } } } void InputReader::handleKey(const RawEvent* rawEvent) { InputDevice* device = getNonIgnoredDevice(rawEvent->deviceId); if (! device) return; bool down = rawEvent->value != 0; int32_t scanCode = rawEvent->scanCode; if (device->isSingleTouchScreen()) { switch (rawEvent->scanCode) { case BTN_TOUCH: device->singleTouchScreen.accumulator.fields |= InputDevice::SingleTouchScreenState::Accumulator::FIELD_BTN_TOUCH; device->singleTouchScreen.accumulator.btnTouch = down; return; } } if (device->isTrackball()) { switch (rawEvent->scanCode) { case BTN_MOUSE: device->trackball.accumulator.fields |= InputDevice::TrackballState::Accumulator::FIELD_BTN_MOUSE; device->trackball.accumulator.btnMouse = down; return; } } if (device->isKeyboard()) { int32_t keyCode = rawEvent->keyCode; onKey(rawEvent->when, device, down, keyCode, scanCode, rawEvent->flags); } } void InputReader::handleRelativeMotion(const RawEvent* rawEvent) { InputDevice* device = getNonIgnoredDevice(rawEvent->deviceId); if (! device) return; if (device->isTrackball()) { switch (rawEvent->scanCode) { case REL_X: device->trackball.accumulator.fields |= InputDevice::TrackballState::Accumulator::FIELD_REL_X; device->trackball.accumulator.relX = rawEvent->value; break; case REL_Y: device->trackball.accumulator.fields |= InputDevice::TrackballState::Accumulator::FIELD_REL_Y; device->trackball.accumulator.relY = rawEvent->value; break; } } } void InputReader::handleAbsoluteMotion(const RawEvent* rawEvent) { InputDevice* device = getNonIgnoredDevice(rawEvent->deviceId); if (! device) return; if (device->isMultiTouchScreen()) { uint32_t pointerIndex = device->multiTouchScreen.accumulator.pointerCount; InputDevice::MultiTouchScreenState::Accumulator::Pointer* pointer = & device->multiTouchScreen.accumulator.pointers[pointerIndex]; switch (rawEvent->scanCode) { case ABS_MT_POSITION_X: pointer->fields |= InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_POSITION_X; pointer->absMTPositionX = rawEvent->value; break; case ABS_MT_POSITION_Y: pointer->fields |= InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_POSITION_Y; pointer->absMTPositionY = rawEvent->value; break; case ABS_MT_TOUCH_MAJOR: pointer->fields |= InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TOUCH_MAJOR; pointer->absMTTouchMajor = rawEvent->value; break; case ABS_MT_TOUCH_MINOR: pointer->fields |= InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TOUCH_MINOR; pointer->absMTTouchMinor = rawEvent->value; break; case ABS_MT_WIDTH_MAJOR: pointer->fields |= InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_WIDTH_MAJOR; pointer->absMTWidthMajor = rawEvent->value; break; case ABS_MT_WIDTH_MINOR: pointer->fields |= InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_WIDTH_MINOR; pointer->absMTWidthMinor = rawEvent->value; break; case ABS_MT_ORIENTATION: pointer->fields |= InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_ORIENTATION; pointer->absMTOrientation = rawEvent->value; break; case ABS_MT_TRACKING_ID: pointer->fields |= InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TRACKING_ID; pointer->absMTTrackingId = rawEvent->value; break; } } else if (device->isSingleTouchScreen()) { switch (rawEvent->scanCode) { case ABS_X: device->singleTouchScreen.accumulator.fields |= InputDevice::SingleTouchScreenState::Accumulator::FIELD_ABS_X; device->singleTouchScreen.accumulator.absX = rawEvent->value; break; case ABS_Y: device->singleTouchScreen.accumulator.fields |= InputDevice::SingleTouchScreenState::Accumulator::FIELD_ABS_Y; device->singleTouchScreen.accumulator.absY = rawEvent->value; break; case ABS_PRESSURE: device->singleTouchScreen.accumulator.fields |= InputDevice::SingleTouchScreenState::Accumulator::FIELD_ABS_PRESSURE; device->singleTouchScreen.accumulator.absPressure = rawEvent->value; break; case ABS_TOOL_WIDTH: device->singleTouchScreen.accumulator.fields |= InputDevice::SingleTouchScreenState::Accumulator::FIELD_ABS_TOOL_WIDTH; device->singleTouchScreen.accumulator.absToolWidth = rawEvent->value; break; } } } void InputReader::handleSwitch(const RawEvent* rawEvent) { InputDevice* device = getNonIgnoredDevice(rawEvent->deviceId); if (! device) return; onSwitch(rawEvent->when, device, rawEvent->scanCode, rawEvent->value); } void InputReader::onKey(nsecs_t when, InputDevice* device, bool down, int32_t keyCode, int32_t scanCode, uint32_t policyFlags) { /* Refresh display properties so we can rotate key codes according to display orientation */ if (! refreshDisplayProperties()) { return; } /* Update device state */ int32_t oldMetaState = device->keyboard.current.metaState; int32_t newMetaState = updateMetaState(keyCode, down, oldMetaState); if (oldMetaState != newMetaState) { device->keyboard.current.metaState = newMetaState; resetGlobalMetaState(); } // FIXME if we send a down event about a rotated key press we should ensure that we send // a corresponding up event about the rotated key press even if the orientation // has changed in the meantime keyCode = rotateKeyCode(keyCode, mDisplayOrientation); if (down) { device->keyboard.current.downTime = when; } /* Apply policy */ int32_t policyActions = mPolicy->interceptKey(when, device->id, down, keyCode, scanCode, policyFlags); if (! applyStandardInputDispatchPolicyActions(when, policyActions, & policyFlags)) { return; // event dropped } /* Enqueue key event for dispatch */ int32_t keyEventAction; if (down) { device->keyboard.current.downTime = when; keyEventAction = AKEY_EVENT_ACTION_DOWN; } else { keyEventAction = AKEY_EVENT_ACTION_UP; } int32_t keyEventFlags = AKEY_EVENT_FLAG_FROM_SYSTEM; if (policyActions & InputReaderPolicyInterface::ACTION_WOKE_HERE) { keyEventFlags = keyEventFlags | AKEY_EVENT_FLAG_WOKE_HERE; } mDispatcher->notifyKey(when, device->id, AINPUT_SOURCE_KEYBOARD, policyFlags, keyEventAction, keyEventFlags, keyCode, scanCode, device->keyboard.current.metaState, device->keyboard.current.downTime); } void InputReader::onSwitch(nsecs_t when, InputDevice* device, int32_t switchCode, int32_t switchValue) { int32_t policyActions = mPolicy->interceptSwitch(when, switchCode, switchValue); uint32_t policyFlags = 0; applyStandardInputDispatchPolicyActions(when, policyActions, & policyFlags); } void InputReader::onMultiTouchScreenStateChanged(nsecs_t when, InputDevice* device) { static const uint32_t REQUIRED_FIELDS = InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_POSITION_X | InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_POSITION_Y | InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TOUCH_MAJOR | InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_WIDTH_MAJOR; /* Refresh display properties so we can map touch screen coords into display coords */ if (! refreshDisplayProperties()) { return; } /* Update device state */ InputDevice::MultiTouchScreenState* in = & device->multiTouchScreen; InputDevice::TouchData* out = & device->touchScreen.currentTouch; uint32_t inCount = in->accumulator.pointerCount; uint32_t outCount = 0; bool havePointerIds = true; out->clear(); for (uint32_t inIndex = 0; inIndex < inCount; inIndex++) { uint32_t fields = in->accumulator.pointers[inIndex].fields; if ((fields & REQUIRED_FIELDS) != REQUIRED_FIELDS) { #if DEBUG_POINTERS LOGD("Pointers: Missing required multitouch pointer fields: index=%d, fields=%d", inIndex, fields); continue; #endif } if (in->accumulator.pointers[inIndex].absMTTouchMajor <= 0) { // Pointer is not down. Drop it. continue; } out->pointers[outCount].x = in->accumulator.pointers[inIndex].absMTPositionX; out->pointers[outCount].y = in->accumulator.pointers[inIndex].absMTPositionY; out->pointers[outCount].touchMajor = in->accumulator.pointers[inIndex].absMTTouchMajor; out->pointers[outCount].touchMinor = (fields & InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TOUCH_MINOR) != 0 ? in->accumulator.pointers[inIndex].absMTTouchMinor : in->accumulator.pointers[inIndex].absMTTouchMajor; out->pointers[outCount].toolMajor = in->accumulator.pointers[inIndex].absMTWidthMajor; out->pointers[outCount].toolMinor = (fields & InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_WIDTH_MINOR) != 0 ? in->accumulator.pointers[inIndex].absMTWidthMinor : in->accumulator.pointers[inIndex].absMTWidthMajor; out->pointers[outCount].orientation = (fields & InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_ORIENTATION) != 0 ? in->accumulator.pointers[inIndex].absMTOrientation : 0; // Derive an approximation of pressure and size. // FIXME assignment of pressure may be incorrect, probably better to let // pressure = touch / width. Later on we pass width to MotionEvent as a size, which // isn't quite right either. Should be using touch for that. out->pointers[outCount].pressure = in->accumulator.pointers[inIndex].absMTTouchMajor; out->pointers[outCount].size = in->accumulator.pointers[inIndex].absMTWidthMajor; if (havePointerIds) { if (fields & InputDevice::MultiTouchScreenState::Accumulator:: FIELD_ABS_MT_TRACKING_ID) { uint32_t id = uint32_t(in->accumulator.pointers[inIndex].absMTTrackingId); if (id > MAX_POINTER_ID) { #if DEBUG_POINTERS LOGD("Pointers: Ignoring driver provided pointer id %d because " "it is larger than max supported id %d for optimizations", id, MAX_POINTER_ID); #endif havePointerIds = false; } else { out->pointers[outCount].id = id; out->idToIndex[id] = outCount; out->idBits.markBit(id); } } else { havePointerIds = false; } } outCount += 1; } out->pointerCount = outCount; onTouchScreenChanged(when, device, havePointerIds); } void InputReader::onSingleTouchScreenStateChanged(nsecs_t when, InputDevice* device) { /* Refresh display properties so we can map touch screen coords into display coords */ if (! refreshDisplayProperties()) { return; } /* Update device state */ InputDevice::SingleTouchScreenState* in = & device->singleTouchScreen; InputDevice::TouchData* out = & device->touchScreen.currentTouch; uint32_t fields = in->accumulator.fields; if (fields & InputDevice::SingleTouchScreenState::Accumulator::FIELD_BTN_TOUCH) { in->current.down = in->accumulator.btnTouch; } if (fields & InputDevice::SingleTouchScreenState::Accumulator::FIELD_ABS_X) { in->current.x = in->accumulator.absX; } if (fields & InputDevice::SingleTouchScreenState::Accumulator::FIELD_ABS_Y) { in->current.y = in->accumulator.absY; } if (fields & InputDevice::SingleTouchScreenState::Accumulator::FIELD_ABS_PRESSURE) { in->current.pressure = in->accumulator.absPressure; } if (fields & InputDevice::SingleTouchScreenState::Accumulator::FIELD_ABS_TOOL_WIDTH) { in->current.size = in->accumulator.absToolWidth; } out->clear(); if (in->current.down) { out->pointerCount = 1; out->pointers[0].id = 0; out->pointers[0].x = in->current.x; out->pointers[0].y = in->current.y; out->pointers[0].pressure = in->current.pressure; out->pointers[0].size = in->current.size; out->pointers[0].touchMajor = in->current.pressure; out->pointers[0].touchMinor = in->current.pressure; out->pointers[0].toolMajor = in->current.size; out->pointers[0].toolMinor = in->current.size; out->pointers[0].orientation = 0; out->idToIndex[0] = 0; out->idBits.markBit(0); } onTouchScreenChanged(when, device, true); } void InputReader::onTouchScreenChanged(nsecs_t when, InputDevice* device, bool havePointerIds) { /* Apply policy */ int32_t policyActions = mPolicy->interceptTouch(when); uint32_t policyFlags = 0; if (! applyStandardInputDispatchPolicyActions(when, policyActions, & policyFlags)) { device->touchScreen.lastTouch.clear(); return; // event dropped } /* Preprocess pointer data */ if (device->touchScreen.parameters.useBadTouchFilter) { if (device->touchScreen.applyBadTouchFilter()) { havePointerIds = false; } } if (device->touchScreen.parameters.useJumpyTouchFilter) { if (device->touchScreen.applyJumpyTouchFilter()) { havePointerIds = false; } } if (! havePointerIds) { device->touchScreen.calculatePointerIds(); } InputDevice::TouchData temp; InputDevice::TouchData* savedTouch; if (device->touchScreen.parameters.useAveragingTouchFilter) { temp.copyFrom(device->touchScreen.currentTouch); savedTouch = & temp; device->touchScreen.applyAveragingTouchFilter(); } else { savedTouch = & device->touchScreen.currentTouch; } /* Process virtual keys or touches */ if (! consumeVirtualKeyTouches(when, device, policyFlags)) { dispatchTouches(when, device, policyFlags); } // Copy current touch to last touch in preparation for the next cycle. device->touchScreen.lastTouch.copyFrom(*savedTouch); } bool InputReader::consumeVirtualKeyTouches(nsecs_t when, InputDevice* device, uint32_t policyFlags) { switch (device->touchScreen.currentVirtualKey.status) { case InputDevice::TouchScreenState::CurrentVirtualKeyState::STATUS_CANCELED: if (device->touchScreen.currentTouch.pointerCount == 0) { // Pointer went up after virtual key canceled. device->touchScreen.currentVirtualKey.status = InputDevice::TouchScreenState::CurrentVirtualKeyState::STATUS_UP; } return true; // consumed case InputDevice::TouchScreenState::CurrentVirtualKeyState::STATUS_DOWN: if (device->touchScreen.currentTouch.pointerCount == 0) { // Pointer went up while virtual key was down. device->touchScreen.currentVirtualKey.status = InputDevice::TouchScreenState::CurrentVirtualKeyState::STATUS_UP; #if DEBUG_VIRTUAL_KEYS LOGD("VirtualKeys: Generating key up: keyCode=%d, scanCode=%d", device->touchScreen.currentVirtualKey.keyCode, device->touchScreen.currentVirtualKey.scanCode); #endif dispatchVirtualKey(when, device, policyFlags, AKEY_EVENT_ACTION_UP, AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); return true; // consumed } if (device->touchScreen.currentTouch.pointerCount == 1) { const InputDevice::VirtualKey* virtualKey = device->touchScreen.findVirtualKeyHit(); if (virtualKey && virtualKey->keyCode == device->touchScreen.currentVirtualKey.keyCode) { // Pointer is still within the space of the virtual key. return true; // consumed } } // Pointer left virtual key area or another pointer also went down. // Send key cancellation. device->touchScreen.currentVirtualKey.status = InputDevice::TouchScreenState::CurrentVirtualKeyState::STATUS_CANCELED; #if DEBUG_VIRTUAL_KEYS LOGD("VirtualKeys: Canceling key: keyCode=%d, scanCode=%d", device->touchScreen.currentVirtualKey.keyCode, device->touchScreen.currentVirtualKey.scanCode); #endif dispatchVirtualKey(when, device, policyFlags, AKEY_EVENT_ACTION_UP, AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY | AKEY_EVENT_FLAG_CANCELED); return true; // consumed default: if (device->touchScreen.currentTouch.pointerCount == 1 && device->touchScreen.lastTouch.pointerCount == 0) { // Pointer just went down. Check for virtual key hit. const InputDevice::VirtualKey* virtualKey = device->touchScreen.findVirtualKeyHit(); if (virtualKey) { device->touchScreen.currentVirtualKey.status = InputDevice::TouchScreenState::CurrentVirtualKeyState::STATUS_DOWN; device->touchScreen.currentVirtualKey.downTime = when; device->touchScreen.currentVirtualKey.keyCode = virtualKey->keyCode; device->touchScreen.currentVirtualKey.scanCode = virtualKey->scanCode; #if DEBUG_VIRTUAL_KEYS LOGD("VirtualKeys: Generating key down: keyCode=%d, scanCode=%d", device->touchScreen.currentVirtualKey.keyCode, device->touchScreen.currentVirtualKey.scanCode); #endif dispatchVirtualKey(when, device, policyFlags, AKEY_EVENT_ACTION_DOWN, AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); return true; // consumed } } return false; // not consumed } } void InputReader::dispatchVirtualKey(nsecs_t when, InputDevice* device, uint32_t policyFlags, int32_t keyEventAction, int32_t keyEventFlags) { updateExportedVirtualKeyState(); int32_t keyCode = device->touchScreen.currentVirtualKey.keyCode; int32_t scanCode = device->touchScreen.currentVirtualKey.scanCode; nsecs_t downTime = device->touchScreen.currentVirtualKey.downTime; int32_t metaState = globalMetaState(); if (keyEventAction == AKEY_EVENT_ACTION_DOWN) { mPolicy->virtualKeyDownFeedback(); } int32_t policyActions = mPolicy->interceptKey(when, device->id, keyEventAction == AKEY_EVENT_ACTION_DOWN, keyCode, scanCode, policyFlags); if (applyStandardInputDispatchPolicyActions(when, policyActions, & policyFlags)) { mDispatcher->notifyKey(when, device->id, AINPUT_SOURCE_KEYBOARD, policyFlags, keyEventAction, keyEventFlags, keyCode, scanCode, metaState, downTime); } } void InputReader::dispatchTouches(nsecs_t when, InputDevice* device, uint32_t policyFlags) { uint32_t currentPointerCount = device->touchScreen.currentTouch.pointerCount; uint32_t lastPointerCount = device->touchScreen.lastTouch.pointerCount; if (currentPointerCount == 0 && lastPointerCount == 0) { return; // nothing to do! } BitSet32 currentIdBits = device->touchScreen.currentTouch.idBits; BitSet32 lastIdBits = device->touchScreen.lastTouch.idBits; if (currentIdBits == lastIdBits) { // No pointer id changes so this is a move event. // The dispatcher takes care of batching moves so we don't have to deal with that here. int32_t motionEventAction = AMOTION_EVENT_ACTION_MOVE; dispatchTouch(when, device, policyFlags, & device->touchScreen.currentTouch, currentIdBits, motionEventAction); } else { // There may be pointers going up and pointers going down at the same time when pointer // ids are reported by the device driver. BitSet32 upIdBits(lastIdBits.value & ~ currentIdBits.value); BitSet32 downIdBits(currentIdBits.value & ~ lastIdBits.value); BitSet32 activeIdBits(lastIdBits.value); while (! upIdBits.isEmpty()) { uint32_t upId = upIdBits.firstMarkedBit(); upIdBits.clearBit(upId); BitSet32 oldActiveIdBits = activeIdBits; activeIdBits.clearBit(upId); int32_t motionEventAction; if (activeIdBits.isEmpty()) { motionEventAction = AMOTION_EVENT_ACTION_UP; } else { motionEventAction = AMOTION_EVENT_ACTION_POINTER_UP | (upId << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT); } dispatchTouch(when, device, policyFlags, & device->touchScreen.lastTouch, oldActiveIdBits, motionEventAction); } while (! downIdBits.isEmpty()) { uint32_t downId = downIdBits.firstMarkedBit(); downIdBits.clearBit(downId); BitSet32 oldActiveIdBits = activeIdBits; activeIdBits.markBit(downId); int32_t motionEventAction; if (oldActiveIdBits.isEmpty()) { motionEventAction = AMOTION_EVENT_ACTION_DOWN; device->touchScreen.downTime = when; } else { motionEventAction = AMOTION_EVENT_ACTION_POINTER_DOWN | (downId << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT); } dispatchTouch(when, device, policyFlags, & device->touchScreen.currentTouch, activeIdBits, motionEventAction); } } } void InputReader::dispatchTouch(nsecs_t when, InputDevice* device, uint32_t policyFlags, InputDevice::TouchData* touch, BitSet32 idBits, int32_t motionEventAction) { int32_t orientedWidth, orientedHeight; switch (mDisplayOrientation) { case InputReaderPolicyInterface::ROTATION_90: case InputReaderPolicyInterface::ROTATION_270: orientedWidth = mDisplayHeight; orientedHeight = mDisplayWidth; break; default: orientedWidth = mDisplayWidth; orientedHeight = mDisplayHeight; break; } uint32_t pointerCount = 0; int32_t pointerIds[MAX_POINTERS]; PointerCoords pointerCoords[MAX_POINTERS]; const InputDevice::TouchScreenState::Precalculated& precalculated = device->touchScreen.precalculated; // Walk through the the active pointers and map touch screen coordinates (TouchData) into // display coordinates (PointerCoords) and adjust for display orientation. while (! idBits.isEmpty()) { uint32_t id = idBits.firstMarkedBit(); idBits.clearBit(id); uint32_t index = touch->idToIndex[id]; float x = float(touch->pointers[index].x - precalculated.xOrigin) * precalculated.xScale; float y = float(touch->pointers[index].y - precalculated.yOrigin) * precalculated.yScale; float pressure = float(touch->pointers[index].pressure - precalculated.pressureOrigin) * precalculated.pressureScale; float size = float(touch->pointers[index].size - precalculated.sizeOrigin) * precalculated.sizeScale; float orientation = float(touch->pointers[index].orientation) * precalculated.orientationScale; bool vertical = abs(orientation) <= M_PI / 8; switch (mDisplayOrientation) { case InputReaderPolicyInterface::ROTATION_90: { float xTemp = x; x = y; y = mDisplayWidth - xTemp; vertical = ! vertical; break; } case InputReaderPolicyInterface::ROTATION_180: { x = mDisplayWidth - x; y = mDisplayHeight - y; break; } case InputReaderPolicyInterface::ROTATION_270: { float xTemp = x; x = mDisplayHeight - y; y = xTemp; vertical = ! vertical; break; } } float touchMajor, touchMinor, toolMajor, toolMinor; if (vertical) { touchMajor = float(touch->pointers[index].touchMajor) * precalculated.yScale; touchMinor = float(touch->pointers[index].touchMinor) * precalculated.xScale; toolMajor = float(touch->pointers[index].toolMajor) * precalculated.yScale; toolMinor = float(touch->pointers[index].toolMinor) * precalculated.xScale; } else { touchMajor = float(touch->pointers[index].touchMajor) * precalculated.xScale; touchMinor = float(touch->pointers[index].touchMinor) * precalculated.yScale; toolMajor = float(touch->pointers[index].toolMajor) * precalculated.xScale; toolMinor = float(touch->pointers[index].toolMinor) * precalculated.yScale; } pointerIds[pointerCount] = int32_t(id); pointerCoords[pointerCount].x = x; pointerCoords[pointerCount].y = y; pointerCoords[pointerCount].pressure = pressure; pointerCoords[pointerCount].size = size; pointerCoords[pointerCount].touchMajor = touchMajor; pointerCoords[pointerCount].touchMinor = touchMinor; pointerCoords[pointerCount].toolMajor = toolMajor; pointerCoords[pointerCount].toolMinor = toolMinor; pointerCoords[pointerCount].orientation = orientation; pointerCount += 1; } // Check edge flags by looking only at the first pointer since the flags are // global to the event. // XXX Maybe we should revise the edge flags API to work on a per-pointer basis. int32_t motionEventEdgeFlags = 0; if (motionEventAction == AMOTION_EVENT_ACTION_DOWN) { if (pointerCoords[0].x <= 0) { motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_LEFT; } else if (pointerCoords[0].x >= orientedWidth) { motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_RIGHT; } if (pointerCoords[0].y <= 0) { motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_TOP; } else if (pointerCoords[0].y >= orientedHeight) { motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_BOTTOM; } } nsecs_t downTime = device->touchScreen.downTime; mDispatcher->notifyMotion(when, device->id, AINPUT_SOURCE_TOUCHSCREEN, policyFlags, motionEventAction, globalMetaState(), motionEventEdgeFlags, pointerCount, pointerIds, pointerCoords, 0, 0, downTime); } void InputReader::onTrackballStateChanged(nsecs_t when, InputDevice* device) { static const uint32_t DELTA_FIELDS = InputDevice::TrackballState::Accumulator::FIELD_REL_X | InputDevice::TrackballState::Accumulator::FIELD_REL_Y; /* Refresh display properties so we can trackball moves according to display orientation */ if (! refreshDisplayProperties()) { return; } /* Update device state */ uint32_t fields = device->trackball.accumulator.fields; bool downChanged = fields & InputDevice::TrackballState::Accumulator::FIELD_BTN_MOUSE; bool deltaChanged = fields & DELTA_FIELDS; bool down; if (downChanged) { if (device->trackball.accumulator.btnMouse) { device->trackball.current.down = true; device->trackball.current.downTime = when; down = true; } else { device->trackball.current.down = false; down = false; } } else { down = device->trackball.current.down; } /* Apply policy */ int32_t policyActions = mPolicy->interceptTrackball(when, downChanged, down, deltaChanged); uint32_t policyFlags = 0; if (! applyStandardInputDispatchPolicyActions(when, policyActions, & policyFlags)) { return; // event dropped } /* Enqueue motion event for dispatch */ int32_t motionEventAction; if (downChanged) { motionEventAction = down ? AMOTION_EVENT_ACTION_DOWN : AMOTION_EVENT_ACTION_UP; } else { motionEventAction = AMOTION_EVENT_ACTION_MOVE; } int32_t pointerId = 0; PointerCoords pointerCoords; pointerCoords.x = fields & InputDevice::TrackballState::Accumulator::FIELD_REL_X ? device->trackball.accumulator.relX * device->trackball.precalculated.xScale : 0; pointerCoords.y = fields & InputDevice::TrackballState::Accumulator::FIELD_REL_Y ? device->trackball.accumulator.relY * device->trackball.precalculated.yScale : 0; pointerCoords.pressure = 1.0f; // XXX Consider making this 1.0f if down, 0 otherwise. pointerCoords.size = 0; pointerCoords.touchMajor = 0; pointerCoords.touchMinor = 0; pointerCoords.toolMajor = 0; pointerCoords.toolMinor = 0; pointerCoords.orientation = 0; float temp; switch (mDisplayOrientation) { case InputReaderPolicyInterface::ROTATION_90: temp = pointerCoords.x; pointerCoords.x = pointerCoords.y; pointerCoords.y = - temp; break; case InputReaderPolicyInterface::ROTATION_180: pointerCoords.x = - pointerCoords.x; pointerCoords.y = - pointerCoords.y; break; case InputReaderPolicyInterface::ROTATION_270: temp = pointerCoords.x; pointerCoords.x = - pointerCoords.y; pointerCoords.y = temp; break; } mDispatcher->notifyMotion(when, device->id, AINPUT_SOURCE_TRACKBALL, policyFlags, motionEventAction, globalMetaState(), AMOTION_EVENT_EDGE_FLAG_NONE, 1, & pointerId, & pointerCoords, device->trackball.precalculated.xPrecision, device->trackball.precalculated.yPrecision, device->trackball.current.downTime); } void InputReader::onConfigurationChanged(nsecs_t when) { // Reset global meta state because it depends on the list of all configured devices. resetGlobalMetaState(); // Reset virtual keys, just in case. updateExportedVirtualKeyState(); // Update input configuration. updateExportedInputConfiguration(); // Enqueue configuration changed. mDispatcher->notifyConfigurationChanged(when); } bool InputReader::applyStandardInputDispatchPolicyActions(nsecs_t when, int32_t policyActions, uint32_t* policyFlags) { if (policyActions & InputReaderPolicyInterface::ACTION_APP_SWITCH_COMING) { mDispatcher->notifyAppSwitchComing(when); } if (policyActions & InputReaderPolicyInterface::ACTION_WOKE_HERE) { *policyFlags |= POLICY_FLAG_WOKE_HERE; } if (policyActions & InputReaderPolicyInterface::ACTION_BRIGHT_HERE) { *policyFlags |= POLICY_FLAG_BRIGHT_HERE; } return policyActions & InputReaderPolicyInterface::ACTION_DISPATCH; } void InputReader::resetDisplayProperties() { mDisplayWidth = mDisplayHeight = -1; mDisplayOrientation = -1; } bool InputReader::refreshDisplayProperties() { int32_t newWidth, newHeight, newOrientation; if (mPolicy->getDisplayInfo(0, & newWidth, & newHeight, & newOrientation)) { if (newWidth != mDisplayWidth || newHeight != mDisplayHeight) { LOGD("Display size changed from %dx%d to %dx%d, updating device configuration", mDisplayWidth, mDisplayHeight, newWidth, newHeight); mDisplayWidth = newWidth; mDisplayHeight = newHeight; for (size_t i = 0; i < mDevices.size(); i++) { configureDeviceForCurrentDisplaySize(mDevices.valueAt(i)); } } if (newOrientation != mDisplayOrientation) { LOGD("Display orientation changed to %d", mDisplayOrientation); mDisplayOrientation = newOrientation; } return true; } else { resetDisplayProperties(); return false; } } InputDevice* InputReader::getDevice(int32_t deviceId) { ssize_t index = mDevices.indexOfKey(deviceId); return index >= 0 ? mDevices.valueAt((size_t) index) : NULL; } InputDevice* InputReader::getNonIgnoredDevice(int32_t deviceId) { InputDevice* device = getDevice(deviceId); return device && ! device->ignored ? device : NULL; } void InputReader::addDevice(nsecs_t when, int32_t deviceId) { uint32_t classes = mEventHub->getDeviceClasses(deviceId); String8 name = mEventHub->getDeviceName(deviceId); InputDevice* device = new InputDevice(deviceId, classes, name); if (classes != 0) { LOGI("Device added: id=0x%x, name=%s, classes=%02x", device->id, device->name.string(), device->classes); configureDevice(device); } else { LOGI("Device added: id=0x%x, name=%s (ignored non-input device)", device->id, device->name.string()); device->ignored = true; } device->reset(); mDevices.add(deviceId, device); if (! device->ignored) { onConfigurationChanged(when); } } void InputReader::removeDevice(nsecs_t when, InputDevice* device) { mDevices.removeItem(device->id); if (! device->ignored) { LOGI("Device removed: id=0x%x, name=%s, classes=%02x", device->id, device->name.string(), device->classes); onConfigurationChanged(when); } else { LOGI("Device removed: id=0x%x, name=%s (ignored non-input device)", device->id, device->name.string()); } delete device; } void InputReader::configureDevice(InputDevice* device) { if (device->isMultiTouchScreen()) { configureAbsoluteAxisInfo(device, ABS_MT_POSITION_X, "X", & device->touchScreen.parameters.xAxis); configureAbsoluteAxisInfo(device, ABS_MT_POSITION_Y, "Y", & device->touchScreen.parameters.yAxis); configureAbsoluteAxisInfo(device, ABS_MT_TOUCH_MAJOR, "Pressure", & device->touchScreen.parameters.pressureAxis); configureAbsoluteAxisInfo(device, ABS_MT_WIDTH_MAJOR, "Size", & device->touchScreen.parameters.sizeAxis); configureAbsoluteAxisInfo(device, ABS_MT_ORIENTATION, "Orientation", & device->touchScreen.parameters.orientationAxis); } else if (device->isSingleTouchScreen()) { configureAbsoluteAxisInfo(device, ABS_X, "X", & device->touchScreen.parameters.xAxis); configureAbsoluteAxisInfo(device, ABS_Y, "Y", & device->touchScreen.parameters.yAxis); configureAbsoluteAxisInfo(device, ABS_PRESSURE, "Pressure", & device->touchScreen.parameters.pressureAxis); configureAbsoluteAxisInfo(device, ABS_TOOL_WIDTH, "Size", & device->touchScreen.parameters.sizeAxis); device->touchScreen.parameters.orientationAxis.valid = false; } if (device->isTouchScreen()) { device->touchScreen.parameters.useBadTouchFilter = mPolicy->filterTouchEvents(); device->touchScreen.parameters.useAveragingTouchFilter = mPolicy->filterTouchEvents(); device->touchScreen.parameters.useJumpyTouchFilter = mPolicy->filterJumpyTouchEvents(); if (device->touchScreen.parameters.pressureAxis.valid) { device->touchScreen.precalculated.pressureOrigin = device->touchScreen.parameters.pressureAxis.minValue; device->touchScreen.precalculated.pressureScale = 1.0f / device->touchScreen.parameters.pressureAxis.range; } else { device->touchScreen.precalculated.pressureOrigin = 0; device->touchScreen.precalculated.pressureScale = 1.0f; } if (device->touchScreen.parameters.sizeAxis.valid) { device->touchScreen.precalculated.sizeOrigin = device->touchScreen.parameters.sizeAxis.minValue; device->touchScreen.precalculated.sizeScale = 1.0f / device->touchScreen.parameters.sizeAxis.range; } else { device->touchScreen.precalculated.sizeOrigin = 0; device->touchScreen.precalculated.sizeScale = 1.0f; } if (device->touchScreen.parameters.orientationAxis.valid && device->touchScreen.parameters.orientationAxis.maxValue > 0) { device->touchScreen.precalculated.orientationScale = M_PI_4 / device->touchScreen.parameters.orientationAxis.maxValue; } else { device->touchScreen.precalculated.orientationScale = 0.0f; } } if (device->isTrackball()) { device->trackball.precalculated.xPrecision = TRACKBALL_MOVEMENT_THRESHOLD; device->trackball.precalculated.yPrecision = TRACKBALL_MOVEMENT_THRESHOLD; device->trackball.precalculated.xScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD; device->trackball.precalculated.yScale = 1.0f / TRACKBALL_MOVEMENT_THRESHOLD; } configureDeviceForCurrentDisplaySize(device); } void InputReader::configureDeviceForCurrentDisplaySize(InputDevice* device) { if (device->isTouchScreen()) { if (device->touchScreen.parameters.xAxis.valid && device->touchScreen.parameters.yAxis.valid) { device->touchScreen.precalculated.xOrigin = device->touchScreen.parameters.xAxis.minValue; device->touchScreen.precalculated.yOrigin = device->touchScreen.parameters.yAxis.minValue; if (mDisplayWidth < 0) { LOGD("Skipping part of touch screen configuration since display size is unknown."); device->touchScreen.precalculated.xScale = 1.0f; device->touchScreen.precalculated.yScale = 1.0f; } else { LOGI("Device configured: id=0x%x, name=%s (display size was changed)", device->id, device->name.string()); device->touchScreen.precalculated.xScale = float(mDisplayWidth) / device->touchScreen.parameters.xAxis.range; device->touchScreen.precalculated.yScale = float(mDisplayHeight) / device->touchScreen.parameters.yAxis.range; configureVirtualKeys(device); } } else { device->touchScreen.precalculated.xOrigin = 0; device->touchScreen.precalculated.xScale = 1.0f; device->touchScreen.precalculated.yOrigin = 0; device->touchScreen.precalculated.yScale = 1.0f; } } } void InputReader::configureVirtualKeys(InputDevice* device) { assert(device->touchScreen.parameters.xAxis.valid && device->touchScreen.parameters.yAxis.valid); device->touchScreen.virtualKeys.clear(); Vector virtualKeyDefinitions; mPolicy->getVirtualKeyDefinitions(device->name, virtualKeyDefinitions); if (virtualKeyDefinitions.size() == 0) { return; } device->touchScreen.virtualKeys.setCapacity(virtualKeyDefinitions.size()); int32_t touchScreenLeft = device->touchScreen.parameters.xAxis.minValue; int32_t touchScreenTop = device->touchScreen.parameters.yAxis.minValue; int32_t touchScreenWidth = device->touchScreen.parameters.xAxis.range; int32_t touchScreenHeight = device->touchScreen.parameters.yAxis.range; for (size_t i = 0; i < virtualKeyDefinitions.size(); i++) { const InputReaderPolicyInterface::VirtualKeyDefinition& virtualKeyDefinition = virtualKeyDefinitions[i]; device->touchScreen.virtualKeys.add(); InputDevice::VirtualKey& virtualKey = device->touchScreen.virtualKeys.editTop(); virtualKey.scanCode = virtualKeyDefinition.scanCode; int32_t keyCode; uint32_t flags; if (mEventHub->scancodeToKeycode(device->id, virtualKey.scanCode, & keyCode, & flags)) { LOGW(" VirtualKey %d: could not obtain key code, ignoring", virtualKey.scanCode); device->touchScreen.virtualKeys.pop(); // drop the key continue; } virtualKey.keyCode = keyCode; virtualKey.flags = flags; // convert the key definition's display coordinates into touch coordinates for a hit box int32_t halfWidth = virtualKeyDefinition.width / 2; int32_t halfHeight = virtualKeyDefinition.height / 2; virtualKey.hitLeft = (virtualKeyDefinition.centerX - halfWidth) * touchScreenWidth / mDisplayWidth + touchScreenLeft; virtualKey.hitRight= (virtualKeyDefinition.centerX + halfWidth) * touchScreenWidth / mDisplayWidth + touchScreenLeft; virtualKey.hitTop = (virtualKeyDefinition.centerY - halfHeight) * touchScreenHeight / mDisplayHeight + touchScreenTop; virtualKey.hitBottom = (virtualKeyDefinition.centerY + halfHeight) * touchScreenHeight / mDisplayHeight + touchScreenTop; LOGI(" VirtualKey %d: keyCode=%d hitLeft=%d hitRight=%d hitTop=%d hitBottom=%d", virtualKey.scanCode, virtualKey.keyCode, virtualKey.hitLeft, virtualKey.hitRight, virtualKey.hitTop, virtualKey.hitBottom); } } void InputReader::configureAbsoluteAxisInfo(InputDevice* device, int axis, const char* name, InputDevice::AbsoluteAxisInfo* out) { if (! mEventHub->getAbsoluteInfo(device->id, axis, & out->minValue, & out->maxValue, & out->flat, &out->fuzz)) { out->range = out->maxValue - out->minValue; if (out->range != 0) { LOGI(" %s: min=%d max=%d flat=%d fuzz=%d", name, out->minValue, out->maxValue, out->flat, out->fuzz); out->valid = true; return; } } out->valid = false; out->minValue = 0; out->maxValue = 0; out->flat = 0; out->fuzz = 0; out->range = 0; LOGI(" %s: unknown axis values, marking as invalid", name); } void InputReader::configureExcludedDevices() { Vector excludedDeviceNames; mPolicy->getExcludedDeviceNames(excludedDeviceNames); for (size_t i = 0; i < excludedDeviceNames.size(); i++) { mEventHub->addExcludedDevice(excludedDeviceNames[i]); } } void InputReader::resetGlobalMetaState() { mGlobalMetaState = -1; } int32_t InputReader::globalMetaState() { if (mGlobalMetaState == -1) { mGlobalMetaState = 0; for (size_t i = 0; i < mDevices.size(); i++) { InputDevice* device = mDevices.valueAt(i); if (device->isKeyboard()) { mGlobalMetaState |= device->keyboard.current.metaState; } } } return mGlobalMetaState; } void InputReader::updateExportedVirtualKeyState() { int32_t keyCode = -1, scanCode = -1; for (size_t i = 0; i < mDevices.size(); i++) { InputDevice* device = mDevices.valueAt(i); if (device->isTouchScreen()) { if (device->touchScreen.currentVirtualKey.status == InputDevice::TouchScreenState::CurrentVirtualKeyState::STATUS_DOWN) { keyCode = device->touchScreen.currentVirtualKey.keyCode; scanCode = device->touchScreen.currentVirtualKey.scanCode; } } } { // acquire exported state lock AutoMutex _l(mExportedStateLock); mExportedVirtualKeyCode = keyCode; mExportedVirtualScanCode = scanCode; } // release exported state lock } bool InputReader::getCurrentVirtualKey(int32_t* outKeyCode, int32_t* outScanCode) const { { // acquire exported state lock AutoMutex _l(mExportedStateLock); *outKeyCode = mExportedVirtualKeyCode; *outScanCode = mExportedVirtualScanCode; return mExportedVirtualKeyCode != -1; } // release exported state lock } void InputReader::updateExportedInputConfiguration() { int32_t touchScreenConfig = InputConfiguration::TOUCHSCREEN_NOTOUCH; int32_t keyboardConfig = InputConfiguration::KEYBOARD_NOKEYS; int32_t navigationConfig = InputConfiguration::NAVIGATION_NONAV; for (size_t i = 0; i < mDevices.size(); i++) { InputDevice* device = mDevices.valueAt(i); int32_t deviceClasses = device->classes; if (deviceClasses & INPUT_DEVICE_CLASS_TOUCHSCREEN) { touchScreenConfig = InputConfiguration::TOUCHSCREEN_FINGER; } if (deviceClasses & INPUT_DEVICE_CLASS_ALPHAKEY) { keyboardConfig = InputConfiguration::KEYBOARD_QWERTY; } if (deviceClasses & INPUT_DEVICE_CLASS_TRACKBALL) { navigationConfig = InputConfiguration::NAVIGATION_TRACKBALL; } else if (deviceClasses & INPUT_DEVICE_CLASS_DPAD) { navigationConfig = InputConfiguration::NAVIGATION_DPAD; } } { // acquire exported state lock AutoMutex _l(mExportedStateLock); mExportedInputConfiguration.touchScreen = touchScreenConfig; mExportedInputConfiguration.keyboard = keyboardConfig; mExportedInputConfiguration.navigation = navigationConfig; } // release exported state lock } void InputReader::getCurrentInputConfiguration(InputConfiguration* outConfiguration) const { { // acquire exported state lock AutoMutex _l(mExportedStateLock); *outConfiguration = mExportedInputConfiguration; } // release exported state lock } int32_t InputReader::getCurrentScanCodeState(int32_t deviceId, int32_t deviceClasses, int32_t scanCode) const { { // acquire exported state lock AutoMutex _l(mExportedStateLock); if (mExportedVirtualScanCode == scanCode) { return AKEY_STATE_VIRTUAL; } } // release exported state lock return mEventHub->getScanCodeState(deviceId, deviceClasses, scanCode); } int32_t InputReader::getCurrentKeyCodeState(int32_t deviceId, int32_t deviceClasses, int32_t keyCode) const { { // acquire exported state lock AutoMutex _l(mExportedStateLock); if (mExportedVirtualKeyCode == keyCode) { return AKEY_STATE_VIRTUAL; } } // release exported state lock return mEventHub->getKeyCodeState(deviceId, deviceClasses, keyCode); } int32_t InputReader::getCurrentSwitchState(int32_t deviceId, int32_t deviceClasses, int32_t sw) const { return mEventHub->getSwitchState(deviceId, deviceClasses, sw); } bool InputReader::hasKeys(size_t numCodes, const int32_t* keyCodes, uint8_t* outFlags) const { return mEventHub->hasKeys(numCodes, keyCodes, outFlags); } // --- InputReaderThread --- InputReaderThread::InputReaderThread(const sp& reader) : Thread(/*canCallJava*/ true), mReader(reader) { } InputReaderThread::~InputReaderThread() { } bool InputReaderThread::threadLoop() { mReader->loopOnce(); return true; } } // namespace android