Examples with InputDevice android.view.InputDevice used on opensource projects

Example 11 with InputDevice

use of android.view.InputDevice in project android_frameworks_base by ParanoidAndroid.

the class WindowManagerService method computeScreenConfigurationLocked.

boolean computeScreenConfigurationLocked(Configuration config) {
    if (!mDisplayReady) {
        return false;
    }
    // TODO(multidisplay): For now, apply Configuration to main screen only.
    final DisplayContent displayContent = getDefaultDisplayContentLocked();
    // Use the effective "visual" dimensions based on current rotation
    final boolean rotated = (mRotation == Surface.ROTATION_90 || mRotation == Surface.ROTATION_270);
    final int realdw = rotated ? displayContent.mBaseDisplayHeight : displayContent.mBaseDisplayWidth;
    final int realdh = rotated ? displayContent.mBaseDisplayWidth : displayContent.mBaseDisplayHeight;
    int dw = realdw;
    int dh = realdh;
    if (mAltOrientation) {
        if (realdw > realdh) {
            // Turn landscape into portrait.
            int maxw = (int) (realdh / 1.3f);
            if (maxw < realdw) {
                dw = maxw;
            }
        } else {
            // Turn portrait into landscape.
            int maxh = (int) (realdw / 1.3f);
            if (maxh < realdh) {
                dh = maxh;
            }
        }
    }
    if (config != null) {
        config.orientation = (dw <= dh) ? Configuration.ORIENTATION_PORTRAIT : Configuration.ORIENTATION_LANDSCAPE;
    }
    // Update application display metrics.
    final int appWidth = mPolicy.getNonDecorDisplayWidth(dw, dh, mRotation);
    final int appHeight = mPolicy.getNonDecorDisplayHeight(dw, dh, mRotation);
    final DisplayInfo displayInfo = displayContent.getDisplayInfo();
    synchronized (displayContent.mDisplaySizeLock) {
        displayInfo.rotation = mRotation;
        displayInfo.logicalWidth = dw;
        displayInfo.logicalHeight = dh;
        displayInfo.logicalDensityDpi = displayContent.mBaseDisplayDensity;
        displayInfo.appWidth = appWidth;
        displayInfo.appHeight = appHeight;
        displayInfo.getLogicalMetrics(mRealDisplayMetrics, null);
        displayInfo.getAppMetrics(mDisplayMetrics, null);
        mDisplayManagerService.setDisplayInfoOverrideFromWindowManager(displayContent.getDisplayId(), displayInfo);
    }
    if (false) {
        Slog.i(TAG, "Set app display size: " + appWidth + " x " + appHeight);
    }
    final DisplayMetrics dm = mDisplayMetrics;
    mCompatibleScreenScale = CompatibilityInfo.computeCompatibleScaling(dm, mCompatDisplayMetrics);
    if (config != null) {
        config.screenWidthDp = (int) (mPolicy.getConfigDisplayWidth(dw, dh, mRotation) / dm.density);
        config.screenHeightDp = (int) (mPolicy.getConfigDisplayHeight(dw, dh, mRotation) / dm.density);
        computeSizeRangesAndScreenLayout(displayInfo, rotated, dw, dh, dm.density, config);
        config.compatScreenWidthDp = (int) (config.screenWidthDp / mCompatibleScreenScale);
        config.compatScreenHeightDp = (int) (config.screenHeightDp / mCompatibleScreenScale);
        config.compatSmallestScreenWidthDp = computeCompatSmallestWidth(rotated, dm, dw, dh);
        config.densityDpi = displayContent.mBaseDisplayDensity;
        // Update the configuration based on available input devices, lid switch,
        // and platform configuration.
        config.touchscreen = Configuration.TOUCHSCREEN_NOTOUCH;
        config.keyboard = Configuration.KEYBOARD_NOKEYS;
        config.navigation = Configuration.NAVIGATION_NONAV;
        int keyboardPresence = 0;
        int navigationPresence = 0;
        final InputDevice[] devices = mInputManager.getInputDevices();
        final int len = devices.length;
        for (int i = 0; i < len; i++) {
            InputDevice device = devices[i];
            if (!device.isVirtual()) {
                final int sources = device.getSources();
                final int presenceFlag = device.isExternal() ? WindowManagerPolicy.PRESENCE_EXTERNAL : WindowManagerPolicy.PRESENCE_INTERNAL;
                if (mIsTouchDevice) {
                    if ((sources & InputDevice.SOURCE_TOUCHSCREEN) == InputDevice.SOURCE_TOUCHSCREEN) {
                        config.touchscreen = Configuration.TOUCHSCREEN_FINGER;
                    }
                } else {
                    config.touchscreen = Configuration.TOUCHSCREEN_NOTOUCH;
                }
                if ((sources & InputDevice.SOURCE_TRACKBALL) == InputDevice.SOURCE_TRACKBALL) {
                    config.navigation = Configuration.NAVIGATION_TRACKBALL;
                    navigationPresence |= presenceFlag;
                } else if ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD && config.navigation == Configuration.NAVIGATION_NONAV) {
                    config.navigation = Configuration.NAVIGATION_DPAD;
                    navigationPresence |= presenceFlag;
                }
                if (device.getKeyboardType() == InputDevice.KEYBOARD_TYPE_ALPHABETIC) {
                    config.keyboard = Configuration.KEYBOARD_QWERTY;
                    keyboardPresence |= presenceFlag;
                }
            }
        }
        // Determine whether a hard keyboard is available and enabled.
        boolean hardKeyboardAvailable = config.keyboard != Configuration.KEYBOARD_NOKEYS;
        if (hardKeyboardAvailable != mHardKeyboardAvailable) {
            mHardKeyboardAvailable = hardKeyboardAvailable;
            mHardKeyboardEnabled = hardKeyboardAvailable;
            mH.removeMessages(H.REPORT_HARD_KEYBOARD_STATUS_CHANGE);
            mH.sendEmptyMessage(H.REPORT_HARD_KEYBOARD_STATUS_CHANGE);
        }
        if (!mHardKeyboardEnabled) {
            config.keyboard = Configuration.KEYBOARD_NOKEYS;
        }
        // Let the policy update hidden states.
        config.keyboardHidden = Configuration.KEYBOARDHIDDEN_NO;
        config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_NO;
        config.navigationHidden = Configuration.NAVIGATIONHIDDEN_NO;
        mPolicy.adjustConfigurationLw(config, keyboardPresence, navigationPresence);
    }
    return true;
}

Example 12 with InputDevice

use of android.view.InputDevice in project android_frameworks_base by ParanoidAndroid.

the class InputManager method onInputDevicesChanged.

private void onInputDevicesChanged(int[] deviceIdAndGeneration) {
    if (DEBUG) {
        Log.d(TAG, "Received input devices changed.");
    }
    synchronized (mInputDevicesLock) {
        for (int i = mInputDevices.size(); --i > 0; ) {
            final int deviceId = mInputDevices.keyAt(i);
            if (!containsDeviceId(deviceIdAndGeneration, deviceId)) {
                if (DEBUG) {
                    Log.d(TAG, "Device removed: " + deviceId);
                }
                mInputDevices.removeAt(i);
                sendMessageToInputDeviceListenersLocked(MSG_DEVICE_REMOVED, deviceId);
            }
        }
        for (int i = 0; i < deviceIdAndGeneration.length; i += 2) {
            final int deviceId = deviceIdAndGeneration[i];
            int index = mInputDevices.indexOfKey(deviceId);
            if (index >= 0) {
                final InputDevice device = mInputDevices.valueAt(index);
                if (device != null) {
                    final int generation = deviceIdAndGeneration[i + 1];
                    if (device.getGeneration() != generation) {
                        if (DEBUG) {
                            Log.d(TAG, "Device changed: " + deviceId);
                        }
                        mInputDevices.setValueAt(index, null);
                        sendMessageToInputDeviceListenersLocked(MSG_DEVICE_CHANGED, deviceId);
                    }
                }
            } else {
                if (DEBUG) {
                    Log.d(TAG, "Device added: " + deviceId);
                }
                mInputDevices.put(deviceId, null);
                sendMessageToInputDeviceListenersLocked(MSG_DEVICE_ADDED, deviceId);
            }
        }
    }
}

Example 13 with InputDevice

use of android.view.InputDevice in project android_frameworks_base by ParanoidAndroid.

the class InputManager method getInputDevice.

/**
     * Gets information about the input device with the specified id.
     * @param id The device id.
     * @return The input device or null if not found.
     */
public InputDevice getInputDevice(int id) {
    synchronized (mInputDevicesLock) {
        populateInputDevicesLocked();
        int index = mInputDevices.indexOfKey(id);
        if (index < 0) {
            return null;
        }
        InputDevice inputDevice = mInputDevices.valueAt(index);
        if (inputDevice == null) {
            try {
                inputDevice = mIm.getInputDevice(id);
            } catch (RemoteException ex) {
                throw new RuntimeException("Could not get input device information.", ex);
            }
            if (inputDevice != null) {
                mInputDevices.setValueAt(index, inputDevice);
            }
        }
        return inputDevice;
    }
}

Example 14 with InputDevice

use of android.view.InputDevice in project android_frameworks_base by ResurrectionRemix.

the class MLand method thump.

private void thump(int playerIndex, long ms) {
    if (mAudioManager.getRingerMode() == AudioManager.RINGER_MODE_SILENT) {
        // No interruptions. Not even game haptics.
        return;
    }
    if (playerIndex < mGameControllers.size()) {
        int controllerId = mGameControllers.get(playerIndex);
        InputDevice dev = InputDevice.getDevice(controllerId);
        if (dev != null && dev.getVibrator().hasVibrator()) {
            dev.getVibrator().vibrate((long) (ms * CONTROLLER_VIBRATION_MULTIPLIER), mAudioAttrs);
            return;
        }
    }
    mVibrator.vibrate(ms, mAudioAttrs);
}

Example 15 with InputDevice

use of android.view.InputDevice in project Resurrection_packages_apps_Settings by ResurrectionRemix.

the class PhysicalKeyboardFragment method getHardKeyboards.

@NonNull
private static ArrayList<HardKeyboardDeviceInfo> getHardKeyboards() {
    final ArrayList<HardKeyboardDeviceInfo> keyboards = new ArrayList<>();
    final int[] devicesIds = InputDevice.getDeviceIds();
    for (int deviceId : devicesIds) {
        final InputDevice device = InputDevice.getDevice(deviceId);
        if (device != null && !device.isVirtual() && device.isFullKeyboard()) {
            keyboards.add(new HardKeyboardDeviceInfo(device.getName(), device.getIdentifier()));
        }
    }
    return keyboards;
}