Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 34aa961e authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Update InputListener usages in InputManagerService 

The input components such as InputReader, InputDispatcher are no longer
returned as pointers.
We never checked them for nullness previously, so the code using
references will be more correct.

Bug: 198472780
Test: adb shell monkey 1000
Change-Id: Ie1239cd42ac6bfa9219e4b0cc87b205a412da0e8
parent 6c67b563

services/core/jni/com_android_server_input_InputManagerService.cpp

+81 −81
Original line number Diff line number Diff line
@@ -451,13 +451,13 @@ void NativeInputManager::dump(std::string& dump) { 
    }

    dump += "\n";



    mInputManager->getReader()->dump(dump);

    mInputManager->getReader().dump(dump);

    dump += "\n";



    mInputManager->getClassifier()->dump(dump);

    mInputManager->getClassifier().dump(dump);

    dump += "\n";



    mInputManager->getDispatcher()->dump(dump);

    mInputManager->getDispatcher().dump(dump);

    dump += "\n";

}
@@ -505,33 +505,33 @@ void NativeInputManager::setDisplayViewports(JNIEnv* env, jobjectArray viewportO 
        }

    } // release lock



    mInputManager->getReader()->requestRefreshConfiguration(

    mInputManager->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_DISPLAY_INFO);

}



base::Result<std::unique_ptr<InputChannel>> NativeInputManager::createInputChannel(

        JNIEnv* /* env */, const std::string& name) {

    ATRACE_CALL();

    return mInputManager->getDispatcher()->createInputChannel(name);

    return mInputManager->getDispatcher().createInputChannel(name);

}



base::Result<std::unique_ptr<InputChannel>> NativeInputManager::createInputMonitor(

        JNIEnv* /* env */, int32_t displayId, bool isGestureMonitor, const std::string& name,

        int32_t pid) {

    ATRACE_CALL();

    return mInputManager->getDispatcher()->createInputMonitor(displayId, isGestureMonitor, name,

    return mInputManager->getDispatcher().createInputMonitor(displayId, isGestureMonitor, name,

                                                             pid);

}



status_t NativeInputManager::removeInputChannel(JNIEnv* /* env */,

                                                const sp<IBinder>& connectionToken) {

    ATRACE_CALL();

    return mInputManager->getDispatcher()->removeInputChannel(connectionToken);

    return mInputManager->getDispatcher().removeInputChannel(connectionToken);

}



status_t NativeInputManager::pilferPointers(const sp<IBinder>& token) {

    ATRACE_CALL();

    return mInputManager->getDispatcher()->pilferPointers(token);

    return mInputManager->getDispatcher().pilferPointers(token);

}



void NativeInputManager::getReaderConfiguration(InputReaderConfiguration* outConfig) {
@@ -998,7 +998,7 @@ void NativeInputManager::getDispatcherConfiguration(InputDispatcherConfiguration 
}



void NativeInputManager::displayRemoved(JNIEnv* env, int32_t displayId) {

    mInputManager->getDispatcher()->displayRemoved(displayId);

    mInputManager->getDispatcher().displayRemoved(displayId);

}



void NativeInputManager::setFocusedApplication(JNIEnv* env, int32_t displayId,
@@ -1009,15 +1009,15 @@ void NativeInputManager::setFocusedApplication(JNIEnv* env, int32_t displayId, 
    std::shared_ptr<InputApplicationHandle> applicationHandle =

            android_view_InputApplicationHandle_getHandle(env, applicationHandleObj);

    applicationHandle->updateInfo();

    mInputManager->getDispatcher()->setFocusedApplication(displayId, applicationHandle);

    mInputManager->getDispatcher().setFocusedApplication(displayId, applicationHandle);

}



void NativeInputManager::setFocusedDisplay(JNIEnv* env, int32_t displayId) {

    mInputManager->getDispatcher()->setFocusedDisplay(displayId);

    mInputManager->getDispatcher().setFocusedDisplay(displayId);

}



void NativeInputManager::setInputDispatchMode(bool enabled, bool frozen) {

    mInputManager->getDispatcher()->setInputDispatchMode(enabled, frozen);

    mInputManager->getDispatcher().setInputDispatchMode(enabled, frozen);

}



void NativeInputManager::setSystemUiLightsOut(bool lightsOut) {
@@ -1051,7 +1051,7 @@ void NativeInputManager::setPointerSpeed(int32_t speed) { 
        mLocked.pointerSpeed = speed;

    } // release lock



    mInputManager->getReader()->requestRefreshConfiguration(

    mInputManager->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_POINTER_SPEED);

}
@@ -1069,7 +1069,7 @@ void NativeInputManager::setInputDeviceEnabled(uint32_t deviceId, bool enabled) 
        }

    } // release lock



    mInputManager->getReader()->requestRefreshConfiguration(

    mInputManager->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_ENABLED_STATE);

}
@@ -1085,12 +1085,12 @@ void NativeInputManager::setShowTouches(bool enabled) { 
        mLocked.showTouches = enabled;

    } // release lock



    mInputManager->getReader()->requestRefreshConfiguration(

    mInputManager->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_SHOW_TOUCHES);

}



void NativeInputManager::requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) {

    mInputManager->getDispatcher()->requestPointerCapture(windowToken, enabled);

    mInputManager->getDispatcher().requestPointerCapture(windowToken, enabled);

}



void NativeInputManager::setInteractive(bool interactive) {
@@ -1098,7 +1098,7 @@ void NativeInputManager::setInteractive(bool interactive) { 
}



void NativeInputManager::reloadCalibration() {

    mInputManager->getReader()->requestRefreshConfiguration(

    mInputManager->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_TOUCH_AFFINE_TRANSFORMATION);

}
@@ -1396,7 +1396,7 @@ void NativeInputManager::setPointerCapture(const PointerCaptureRequest& request) 
        mLocked.pointerCaptureRequest = request;

    } // release lock



    mInputManager->getReader()->requestRefreshConfiguration(

    mInputManager->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_POINTER_CAPTURE);

}
@@ -1481,7 +1481,7 @@ int32_t NativeInputManager::getCustomPointerIconId() { 
}



void NativeInputManager::setMotionClassifierEnabled(bool enabled) {

    mInputManager->getClassifier()->setMotionClassifierEnabled(enabled);

    mInputManager->getClassifier().setMotionClassifierEnabled(enabled);

}



// ----------------------------------------------------------------------------
@@ -1519,24 +1519,24 @@ static jint nativeGetScanCodeState(JNIEnv* /* env */, jclass /* clazz */, 
        jlong ptr, jint deviceId, jint sourceMask, jint scanCode) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    return (jint) im->getInputManager()->getReader()->getScanCodeState(

            deviceId, uint32_t(sourceMask), scanCode);

    return (jint)im->getInputManager()->getReader().getScanCodeState(deviceId, uint32_t(sourceMask),

                                                                     scanCode);

}



static jint nativeGetKeyCodeState(JNIEnv* /* env */, jclass /* clazz */,

        jlong ptr, jint deviceId, jint sourceMask, jint keyCode) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    return (jint) im->getInputManager()->getReader()->getKeyCodeState(

            deviceId, uint32_t(sourceMask), keyCode);

    return (jint)im->getInputManager()->getReader().getKeyCodeState(deviceId, uint32_t(sourceMask),

                                                                    keyCode);

}



static jint nativeGetSwitchState(JNIEnv* /* env */, jclass /* clazz */,

        jlong ptr, jint deviceId, jint sourceMask, jint sw) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    return (jint) im->getInputManager()->getReader()->getSwitchState(

            deviceId, uint32_t(sourceMask), sw);

    return (jint)im->getInputManager()->getReader().getSwitchState(deviceId, uint32_t(sourceMask),

                                                                   sw);

}



static jboolean nativeHasKeys(JNIEnv* env, jclass /* clazz */,
@@ -1548,8 +1548,8 @@ static jboolean nativeHasKeys(JNIEnv* env, jclass /* clazz */, 
    jsize numCodes = env->GetArrayLength(keyCodes);

    jboolean result;

    if (numCodes == env->GetArrayLength(keyCodes)) {

        if (im->getInputManager()->getReader()->hasKeys(

                deviceId, uint32_t(sourceMask), numCodes, codes, flags)) {

        if (im->getInputManager()->getReader().hasKeys(deviceId, uint32_t(sourceMask), numCodes,

                                                       codes, flags)) {

            result = JNI_TRUE;

        } else {

            result = JNI_FALSE;
@@ -1655,28 +1655,28 @@ static void nativeSetInputFilterEnabled(JNIEnv* /* env */, jclass /* clazz */, 
        jlong ptr, jboolean enabled) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getDispatcher()->setInputFilterEnabled(enabled);

    im->getInputManager()->getDispatcher().setInputFilterEnabled(enabled);

}



static void nativeSetInTouchMode(JNIEnv* /* env */, jclass /* clazz */,

        jlong ptr, jboolean inTouchMode) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getDispatcher()->setInTouchMode(inTouchMode);

    im->getInputManager()->getDispatcher().setInTouchMode(inTouchMode);

}



static void nativeSetMaximumObscuringOpacityForTouch(JNIEnv* /* env */, jclass /* clazz */,

                                                     jlong ptr, jfloat opacity) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getDispatcher()->setMaximumObscuringOpacityForTouch(opacity);

    im->getInputManager()->getDispatcher().setMaximumObscuringOpacityForTouch(opacity);

}



static void nativeSetBlockUntrustedTouchesMode(JNIEnv* env, jclass /* clazz */, jlong ptr,

                                               jint mode) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getDispatcher()->setBlockUntrustedTouchesMode(

    im->getInputManager()->getDispatcher().setBlockUntrustedTouchesMode(

            static_cast<BlockUntrustedTouchesMode>(mode));

}
@@ -1697,7 +1697,7 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass /* clazz */, 
        }



        const InputEventInjectionResult result =

                im->getInputManager()->getDispatcher()->injectInputEvent(&keyEvent, injectorPid,

                im->getInputManager()->getDispatcher().injectInputEvent(&keyEvent, injectorPid,

                                                                        injectorUid, mode,

                                                                        std::chrono::milliseconds(

                                                                                timeoutMillis),
@@ -1711,7 +1711,7 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass /* clazz */, 
        }



        const InputEventInjectionResult result =

                im->getInputManager()->getDispatcher()->injectInputEvent(motionEvent, injectorPid,

                im->getInputManager()->getDispatcher().injectInputEvent(motionEvent, injectorPid,

                                                                        injectorUid, mode,

                                                                        std::chrono::milliseconds(

                                                                                timeoutMillis),
@@ -1736,7 +1736,7 @@ static jobject nativeVerifyInputEvent(JNIEnv* env, jclass /* clazz */, jlong ptr 
        }



        std::unique_ptr<VerifiedInputEvent> verifiedEvent =

                im->getInputManager()->getDispatcher()->verifyInputEvent(keyEvent);

                im->getInputManager()->getDispatcher().verifyInputEvent(keyEvent);

        if (verifiedEvent == nullptr) {

            return nullptr;

        }
@@ -1751,7 +1751,7 @@ static jobject nativeVerifyInputEvent(JNIEnv* env, jclass /* clazz */, jlong ptr 
        }



        std::unique_ptr<VerifiedInputEvent> verifiedEvent =

                im->getInputManager()->getDispatcher()->verifyInputEvent(*motionEvent);

                im->getInputManager()->getDispatcher().verifyInputEvent(*motionEvent);



        if (verifiedEvent == nullptr) {

            return nullptr;
@@ -1770,7 +1770,7 @@ static void nativeToggleCapsLock(JNIEnv* env, jclass /* clazz */, 
         jlong ptr, jint deviceId) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->toggleCapsLockState(deviceId);

    im->getInputManager()->getReader().toggleCapsLockState(deviceId);

}



static void nativeDisplayRemoved(JNIEnv* env, jclass /* clazz */, jlong ptr, jint displayId) {
@@ -1826,7 +1826,7 @@ static jboolean nativeTransferTouchFocus(JNIEnv* env, jclass /* clazz */, jlong 
    sp<IBinder> toChannelToken = ibinderForJavaObject(env, toChannelTokenObj);



    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    if (im->getInputManager()->getDispatcher()->transferTouchFocus(fromChannelToken, toChannelToken,

    if (im->getInputManager()->getDispatcher().transferTouchFocus(fromChannelToken, toChannelToken,

                                                                  isDragDrop)) {

        return JNI_TRUE;

    } else {
@@ -1839,7 +1839,7 @@ static jboolean nativeTransferTouch(JNIEnv* env, jclass /* clazz */, jlong ptr, 
    sp<IBinder> destChannelToken = ibinderForJavaObject(env, destChannelTokenObj);



    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    if (im->getInputManager()->getDispatcher()->transferTouch(destChannelToken)) {

    if (im->getInputManager()->getDispatcher().transferTouch(destChannelToken)) {

        return JNI_TRUE;

    } else {

        return JNI_FALSE;
@@ -1889,7 +1889,7 @@ static void nativeVibrate(JNIEnv* env, jclass /* clazz */, jlong ptr, jint devic 
    jint* amplitudes = static_cast<jint*>(env->GetPrimitiveArrayCritical(amplitudesObj, nullptr));



    VibrationSequence sequence(patternSize);

    std::vector<int32_t> vibrators = im->getInputManager()->getReader()->getVibratorIds(deviceId);

    std::vector<int32_t> vibrators = im->getInputManager()->getReader().getVibratorIds(deviceId);

    for (size_t i = 0; i < patternSize; i++) {

        // VibrationEffect.validate guarantees duration > 0.

        std::chrono::milliseconds duration(patternMillis[i]);
@@ -1904,7 +1904,7 @@ static void nativeVibrate(JNIEnv* env, jclass /* clazz */, jlong ptr, jint devic 
    env->ReleasePrimitiveArrayCritical(patternObj, patternMillis, JNI_ABORT);

    env->ReleasePrimitiveArrayCritical(amplitudesObj, amplitudes, JNI_ABORT);



    im->getInputManager()->getReader()->vibrate(deviceId, sequence, repeat, token);

    im->getInputManager()->getReader().vibrate(deviceId, sequence, repeat, token);

}



static void nativeVibrateCombined(JNIEnv* env, jclass /* clazz */, jlong ptr, jint deviceId,
@@ -1954,25 +1954,25 @@ static void nativeVibrateCombined(JNIEnv* env, jclass /* clazz */, jlong ptr, ji 
        sequence.addElement(element);

    }



    im->getInputManager()->getReader()->vibrate(deviceId, sequence, repeat, token);

    im->getInputManager()->getReader().vibrate(deviceId, sequence, repeat, token);

}



static void nativeCancelVibrate(JNIEnv* /* env */,

        jclass /* clazz */, jlong ptr, jint deviceId, jint token) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->cancelVibrate(deviceId, token);

    im->getInputManager()->getReader().cancelVibrate(deviceId, token);

}



static bool nativeIsVibrating(JNIEnv* /* env */, jclass /* clazz */, jlong ptr, jint deviceId) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    return im->getInputManager()->getReader()->isVibrating(deviceId);

    return im->getInputManager()->getReader().isVibrating(deviceId);

}



static jintArray nativeGetVibratorIds(JNIEnv* env, jclass clazz, jlong ptr, jint deviceId) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    std::vector<int32_t> vibrators = im->getInputManager()->getReader()->getVibratorIds(deviceId);

    std::vector<int32_t> vibrators = im->getInputManager()->getReader().getVibratorIds(deviceId);



    jintArray vibIdArray = env->NewIntArray(vibrators.size());

    if (vibIdArray != nullptr) {
@@ -1986,7 +1986,7 @@ static jobject nativeGetLights(JNIEnv* env, jclass clazz, jlong ptr, jint device 
    jobject jLights = env->NewObject(gArrayListClassInfo.clazz, gArrayListClassInfo.constructor);



    std::vector<InputDeviceLightInfo> lights =

            im->getInputManager()->getReader()->getLights(deviceId);

            im->getInputManager()->getReader().getLights(deviceId);



    for (size_t i = 0; i < lights.size(); i++) {

        const InputDeviceLightInfo& lightInfo = lights[i];
@@ -2031,7 +2031,7 @@ static jint nativeGetLightPlayerId(JNIEnv* env, jclass /* clazz */, jlong ptr, j 
    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    std::optional<int32_t> ret =

            im->getInputManager()->getReader()->getLightPlayerId(deviceId, lightId);

            im->getInputManager()->getReader().getLightPlayerId(deviceId, lightId);



    return static_cast<jint>(ret.value_or(0));

}
@@ -2041,7 +2041,7 @@ static jint nativeGetLightColor(JNIEnv* env, jclass /* clazz */, jlong ptr, jint 
    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    std::optional<int32_t> ret =

            im->getInputManager()->getReader()->getLightColor(deviceId, lightId);

            im->getInputManager()->getReader().getLightColor(deviceId, lightId);

    return static_cast<jint>(ret.value_or(0));

}
@@ -2049,27 +2049,27 @@ static void nativeSetLightPlayerId(JNIEnv* env, jclass /* clazz */, jlong ptr, j 
                                   jint lightId, jint playerId) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->setLightPlayerId(deviceId, lightId, playerId);

    im->getInputManager()->getReader().setLightPlayerId(deviceId, lightId, playerId);

}



static void nativeSetLightColor(JNIEnv* env, jclass /* clazz */, jlong ptr, jint deviceId,

                                jint lightId, jint color) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->setLightColor(deviceId, lightId, color);

    im->getInputManager()->getReader().setLightColor(deviceId, lightId, color);

}



static jint nativeGetBatteryCapacity(JNIEnv* env, jclass /* clazz */, jlong ptr, jint deviceId) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    std::optional<int32_t> ret = im->getInputManager()->getReader()->getBatteryCapacity(deviceId);

    std::optional<int32_t> ret = im->getInputManager()->getReader().getBatteryCapacity(deviceId);

    return static_cast<jint>(ret.value_or(android::os::IInputConstants::INVALID_BATTERY_CAPACITY));

}



static jint nativeGetBatteryStatus(JNIEnv* env, jclass /* clazz */, jlong ptr, jint deviceId) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    std::optional<int32_t> ret = im->getInputManager()->getReader()->getBatteryStatus(deviceId);

    std::optional<int32_t> ret = im->getInputManager()->getReader().getBatteryStatus(deviceId);

    return static_cast<jint>(ret.value_or(BATTERY_STATUS_UNKNOWN));

}
@@ -2077,7 +2077,7 @@ static void nativeReloadKeyboardLayouts(JNIEnv* /* env */, 
        jclass /* clazz */, jlong ptr) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->requestRefreshConfiguration(

    im->getInputManager()->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_KEYBOARD_LAYOUTS);

}
@@ -2085,7 +2085,7 @@ static void nativeReloadDeviceAliases(JNIEnv* /* env */, 
        jclass /* clazz */, jlong ptr) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->requestRefreshConfiguration(

    im->getInputManager()->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_DEVICE_ALIAS);

}
@@ -2100,15 +2100,15 @@ static jstring nativeDump(JNIEnv* env, jclass /* clazz */, jlong ptr) { 
static void nativeMonitor(JNIEnv* /* env */, jclass /* clazz */, jlong ptr) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->monitor();

    im->getInputManager()->getDispatcher()->monitor();

    im->getInputManager()->getReader().monitor();

    im->getInputManager()->getDispatcher().monitor();

}



static jboolean nativeIsInputDeviceEnabled(JNIEnv* env /* env */,

        jclass /* clazz */, jlong ptr, jint deviceId) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    return im->getInputManager()->getReader()->isInputDeviceEnabled(deviceId);

    return im->getInputManager()->getReader().isInputDeviceEnabled(deviceId);

}



static void nativeEnableInputDevice(JNIEnv* /* env */,
@@ -2157,18 +2157,18 @@ static jboolean nativeCanDispatchToDisplay(JNIEnv* env, jclass /* clazz */, jlon 
        jint deviceId, jint displayId) {



    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    return im->getInputManager()->getReader()->canDispatchToDisplay(deviceId, displayId);

    return im->getInputManager()->getReader().canDispatchToDisplay(deviceId, displayId);

}



static void nativeNotifyPortAssociationsChanged(JNIEnv* env, jclass /* clazz */, jlong ptr) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    im->getInputManager()->getReader()->requestRefreshConfiguration(

    im->getInputManager()->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_DISPLAY_INFO);

}



static void nativeChangeUniqueIdAssociation(JNIEnv* env, jclass /* clazz */, jlong ptr) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    im->getInputManager()->getReader()->requestRefreshConfiguration(

    im->getInputManager()->getReader().requestRefreshConfiguration(

            InputReaderConfiguration::CHANGE_DISPLAY_INFO);

}
@@ -2213,7 +2213,7 @@ static jobject createInputSensorInfo(JNIEnv* env, jstring name, jstring vendor, 
static jobjectArray nativeGetSensorList(JNIEnv* env, jclass /* clazz */, jlong ptr, jint deviceId) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    std::vector<InputDeviceSensorInfo> sensors =

            im->getInputManager()->getReader()->getSensors(deviceId);

            im->getInputManager()->getReader().getSensors(deviceId);



    jobjectArray arr = env->NewObjectArray(sensors.size(), gInputSensorInfo.clazz, nullptr);

    for (int i = 0; i < sensors.size(); i++) {
@@ -2247,7 +2247,7 @@ static jboolean nativeEnableSensor(JNIEnv* env, jclass /* clazz */, jlong ptr, j 


    return im->getInputManager()

            ->getReader()

            ->enableSensor(deviceId, static_cast<InputDeviceSensorType>(sensorType),

            .enableSensor(deviceId, static_cast<InputDeviceSensorType>(sensorType),

                          std::chrono::microseconds(samplingPeriodUs),

                          std::chrono::microseconds(maxBatchReportLatencyUs));

}
@@ -2256,7 +2256,7 @@ static void nativeDisableSensor(JNIEnv* env, jclass /* clazz */, jlong ptr, jint 
                                jint sensorType) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->disableSensor(deviceId,

    im->getInputManager()->getReader().disableSensor(deviceId,

                                                     static_cast<InputDeviceSensorType>(

                                                             sensorType));

}
@@ -2265,9 +2265,9 @@ static jboolean nativeFlushSensor(JNIEnv* env, jclass /* clazz */, jlong ptr, ji 
                                  jint sensorType) {

    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);



    im->getInputManager()->getReader()->flushSensor(deviceId,

    im->getInputManager()->getReader().flushSensor(deviceId,

                                                   static_cast<InputDeviceSensorType>(sensorType));

    return im->getInputManager()->getDispatcher()->flushSensor(deviceId,

    return im->getInputManager()->getDispatcher().flushSensor(deviceId,

                                                              static_cast<InputDeviceSensorType>(

                                                                      sensorType));

}