Stylus updater in ConnectedDevicesGroupController.

This updater is responsible for listening to USI stylus battery usage, and bluetooth stylus connection, to determine whether to show the USI stylus preference on the Connected devices page. Adds an entrypoint to the StylusUsiDetailsFragment that shows details for USI styluses. Bug: 250909304 Test: StylusDeviceUpdaterTest Change-Id: I6ae6b6ef880b3b3cd7430d4d35d471b14283369f
2022-10-28 12:27:46 +01:00
parent 850f857ce5
commit dc2980d220
8 changed files with 608 additions and 16 deletions
--- a/src/com/android/settings/connecteddevice/ConnectedDeviceGroupController.java
+++ b/src/com/android/settings/connecteddevice/ConnectedDeviceGroupController.java
@@ -17,6 +17,9 @@ package com.android.settings.connecteddevice;

 import android.content.Context;
 import android.content.pm.PackageManager;
+import android.hardware.input.InputManager;
+import android.util.FeatureFlagUtils;
+import android.view.InputDevice;

 import androidx.annotation.VisibleForTesting;
 import androidx.preference.Preference;
@@ -26,6 +29,7 @@ import androidx.preference.PreferenceScreen;
 import com.android.settings.bluetooth.BluetoothDeviceUpdater;
 import com.android.settings.bluetooth.ConnectedBluetoothDeviceUpdater;
 import com.android.settings.connecteddevice.dock.DockUpdater;
+import com.android.settings.connecteddevice.stylus.StylusDeviceUpdater;
 import com.android.settings.connecteddevice.usb.ConnectedUsbDeviceUpdater;
 import com.android.settings.core.BasePreferenceController;
 import com.android.settings.core.PreferenceControllerMixin;
@@ -51,11 +55,14 @@ public class ConnectedDeviceGroupController extends BasePreferenceController
    private BluetoothDeviceUpdater mBluetoothDeviceUpdater;
    private ConnectedUsbDeviceUpdater mConnectedUsbDeviceUpdater;
    private DockUpdater mConnectedDockUpdater;
+    private StylusDeviceUpdater mStylusDeviceUpdater;
    private final PackageManager mPackageManager;
+    private final InputManager mInputManager;

    public ConnectedDeviceGroupController(Context context) {
        super(context, KEY);
        mPackageManager = context.getPackageManager();
+        mInputManager = context.getSystemService(InputManager.class);
    }

    @Override
@@ -69,7 +76,13 @@ public class ConnectedDeviceGroupController extends BasePreferenceController
            mConnectedUsbDeviceUpdater.registerCallback();
        }

-        mConnectedDockUpdater.registerCallback();
+        if (mConnectedDockUpdater != null) {
+            mConnectedDockUpdater.registerCallback();
+        }
+
+        if (mStylusDeviceUpdater != null) {
+            mStylusDeviceUpdater.registerCallback();
+        }
    }

    @Override
@@ -82,7 +95,13 @@ public class ConnectedDeviceGroupController extends BasePreferenceController
            mConnectedUsbDeviceUpdater.unregisterCallback();
        }

-        mConnectedDockUpdater.unregisterCallback();
+        if (mConnectedDockUpdater != null) {
+            mConnectedDockUpdater.unregisterCallback();
+        }
+
+        if (mStylusDeviceUpdater != null) {
+            mStylusDeviceUpdater.unregisterCallback();
+        }
    }

    @Override
@@ -103,8 +122,15 @@ public class ConnectedDeviceGroupController extends BasePreferenceController
                mConnectedUsbDeviceUpdater.initUsbPreference(context);
            }

-            mConnectedDockUpdater.setPreferenceContext(context);
-            mConnectedDockUpdater.forceUpdate();
+            if (mConnectedDockUpdater != null) {
+                mConnectedDockUpdater.setPreferenceContext(context);
+                mConnectedDockUpdater.forceUpdate();
+            }
+
+            if (mStylusDeviceUpdater != null) {
+                mStylusDeviceUpdater.setPreferenceContext(context);
+                mStylusDeviceUpdater.forceUpdate();
+            }
        }
    }

@@ -112,6 +138,7 @@ public class ConnectedDeviceGroupController extends BasePreferenceController
    public int getAvailabilityStatus() {
        return (hasBluetoothFeature()
                || hasUsbFeature()
+                || hasUsiStylusFeature()
                || mConnectedDockUpdater != null)
                ? AVAILABLE_UNSEARCHABLE
                : UNSUPPORTED_ON_DEVICE;
@@ -141,11 +168,13 @@ public class ConnectedDeviceGroupController extends BasePreferenceController
    @VisibleForTesting
    void init(BluetoothDeviceUpdater bluetoothDeviceUpdater,
            ConnectedUsbDeviceUpdater connectedUsbDeviceUpdater,
-            DockUpdater connectedDockUpdater) {
+            DockUpdater connectedDockUpdater,
+            StylusDeviceUpdater connectedStylusDeviceUpdater) {

        mBluetoothDeviceUpdater = bluetoothDeviceUpdater;
        mConnectedUsbDeviceUpdater = connectedUsbDeviceUpdater;
        mConnectedDockUpdater = connectedDockUpdater;
+        mStylusDeviceUpdater = connectedStylusDeviceUpdater;
    }

    public void init(DashboardFragment fragment) {
@@ -160,7 +189,10 @@ public class ConnectedDeviceGroupController extends BasePreferenceController
                hasUsbFeature()
                        ? new ConnectedUsbDeviceUpdater(context, fragment, this)
                        : null,
-                connectedDockUpdater);
+                connectedDockUpdater,
+                hasUsiStylusFeature()
+                        ? new StylusDeviceUpdater(context, fragment, this)
+                        : null);
    }

    private boolean hasBluetoothFeature() {
@@ -171,4 +203,21 @@ public class ConnectedDeviceGroupController extends BasePreferenceController
        return mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_ACCESSORY)
                || mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST);
    }
+
+    private boolean hasUsiStylusFeature() {
+        if (!FeatureFlagUtils.isEnabled(mContext,
+                FeatureFlagUtils.SETTINGS_SHOW_STYLUS_PREFERENCES)) {
+            return false;
+        }
+
+        for (int deviceId : mInputManager.getInputDeviceIds()) {
+            InputDevice device = mInputManager.getInputDevice(deviceId);
+            if (device != null
+                    && device.supportsSource(InputDevice.SOURCE_STYLUS)
+                    && !device.isExternal()) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
--- a/src/com/android/settings/connecteddevice/stylus/StylusDeviceUpdater.java
+++ b/src/com/android/settings/connecteddevice/stylus/StylusDeviceUpdater.java
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.connecteddevice.stylus;
+
+import android.content.Context;
+import android.hardware.BatteryState;
+import android.hardware.input.InputManager;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import android.util.Log;
+import android.view.InputDevice;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+import androidx.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settings.connecteddevice.DevicePreferenceCallback;
+import com.android.settings.core.SubSettingLauncher;
+import com.android.settings.dashboard.DashboardFragment;
+import com.android.settings.overlay.FeatureFactory;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Controller to maintain available USI stylus devices. Listens to bluetooth
+ * stylus connection to determine whether to show the USI preference.
+ */
+public class StylusDeviceUpdater implements InputManager.InputDeviceListener,
+        InputManager.InputDeviceBatteryListener {
+
+    private static final String TAG = "StylusDeviceUpdater";
+    private static final String PREF_KEY = "stylus_usi_device";
+    private static final String INPUT_ID_ARG = "device_input_id";
+
+    private final DevicePreferenceCallback mDevicePreferenceCallback;
+    private final List<Integer> mRegisteredBatteryCallbackIds;
+    private final DashboardFragment mFragment;
+    private final InputManager mInputManager;
+    private final MetricsFeatureProvider mMetricsFeatureProvider;
+
+    private long mLastUsiSeenTime = 0;
+    private Context mContext;
+
+    @VisibleForTesting
+    Integer mLastDetectedUsiId;
+
+    @VisibleForTesting
+    Preference mUsiPreference;
+
+
+    public StylusDeviceUpdater(Context context, DashboardFragment fragment,
+            DevicePreferenceCallback devicePreferenceCallback) {
+        mFragment = fragment;
+        mRegisteredBatteryCallbackIds = new ArrayList<>();
+        mDevicePreferenceCallback = devicePreferenceCallback;
+        mMetricsFeatureProvider = FeatureFactory.getFactory(context).getMetricsFeatureProvider();
+        mContext = context;
+        mInputManager = context.getSystemService(InputManager.class);
+
+    }
+
+    /**
+     * Register the stylus event callback and update the list
+     */
+    public void registerCallback() {
+        for (int deviceId : mInputManager.getInputDeviceIds()) {
+            onInputDeviceAdded(deviceId);
+        }
+        mInputManager.registerInputDeviceListener(this, new Handler(Looper.myLooper()));
+        forceUpdate();
+    }
+
+    /**
+     * Unregister the stylus event callback
+     */
+    public void unregisterCallback() {
+        for (int deviceId : mRegisteredBatteryCallbackIds) {
+            mInputManager.removeInputDeviceBatteryListener(deviceId, this);
+        }
+        mInputManager.unregisterInputDeviceListener(this);
+    }
+
+    @Override
+    public void onInputDeviceAdded(int deviceId) {
+        InputDevice inputDevice = mInputManager.getInputDevice(deviceId);
+        if (inputDevice.supportsSource(InputDevice.SOURCE_STYLUS)
+                && !inputDevice.isExternal()) {
+            try {
+                mInputManager.addInputDeviceBatteryListener(deviceId,
+                        mContext.getMainExecutor(), this);
+                mRegisteredBatteryCallbackIds.add(deviceId);
+            } catch (IllegalArgumentException e) {
+                Log.e(TAG, e.getMessage());
+            }
+        }
+        forceUpdate();
+    }
+
+    @Override
+    public void onInputDeviceRemoved(int deviceId) {
+        Log.d(TAG, String.format("Input device removed %d", deviceId));
+        forceUpdate();
+    }
+
+    @Override
+    public void onInputDeviceChanged(int deviceId) {
+        if (mInputManager.getInputDevice(deviceId).supportsSource(InputDevice.SOURCE_STYLUS)) {
+            forceUpdate();
+        }
+    }
+
+
+    @Override
+    public void onBatteryStateChanged(int deviceId, long eventTimeMillis,
+            @NonNull BatteryState batteryState) {
+        if (batteryState.isPresent()) {
+            mLastUsiSeenTime = eventTimeMillis;
+            mLastDetectedUsiId = deviceId;
+        } else {
+            mLastUsiSeenTime = -1;
+            mLastDetectedUsiId = null;
+        }
+        forceUpdate();
+    }
+
+    /**
+     * Set the context to generate the {@link Preference}, so it could get the correct theme.
+     */
+    public void setPreferenceContext(Context context) {
+        mContext = context;
+    }
+
+    /**
+     * Force update to add or remove stylus preference
+     */
+    public void forceUpdate() {
+        if (shouldShowUsiPreference()) {
+            addOrUpdateUsiPreference();
+        } else {
+            removeUsiPreference();
+        }
+    }
+
+    private synchronized void addOrUpdateUsiPreference() {
+        if (mUsiPreference == null) {
+            mUsiPreference = new Preference(mContext);
+            mDevicePreferenceCallback.onDeviceAdded(mUsiPreference);
+        }
+        mUsiPreference.setKey(PREF_KEY);
+        mUsiPreference.setTitle(R.string.stylus_connected_devices_title);
+        // TODO(b/250909304): pending actual icon visD
+        mUsiPreference.setIcon(R.drawable.circle);
+        mUsiPreference.setOnPreferenceClickListener((Preference p) -> {
+            mMetricsFeatureProvider.logClickedPreference(p, mFragment.getMetricsCategory());
+            launchDeviceDetails();
+            return true;
+        });
+    }
+
+    private synchronized void removeUsiPreference() {
+        if (mUsiPreference != null) {
+            mDevicePreferenceCallback.onDeviceRemoved(mUsiPreference);
+            mUsiPreference = null;
+        }
+    }
+
+    private boolean shouldShowUsiPreference() {
+        return isUsiConnectionValid() && !hasConnectedBluetoothStylusDevice();
+    }
+
+    @VisibleForTesting
+    public Preference getPreference() {
+        return mUsiPreference;
+    }
+
+    @VisibleForTesting
+    boolean hasConnectedBluetoothStylusDevice() {
+        for (int deviceId : mInputManager.getInputDeviceIds()) {
+            InputDevice device = mInputManager.getInputDevice(deviceId);
+            if (device.supportsSource(InputDevice.SOURCE_STYLUS)
+                    && mInputManager.getInputDeviceBluetoothAddress(deviceId) != null) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @VisibleForTesting
+    boolean isUsiConnectionValid() {
+        // battery listener uses uptimeMillis as its eventTime
+        long currentTime = SystemClock.uptimeMillis();
+        long usiValidityDuration = 60 * 60 * 1000; // 1 hour
+        return mLastUsiSeenTime > 0 && currentTime - usiValidityDuration <= mLastUsiSeenTime;
+    }
+
+    private void launchDeviceDetails() {
+        final Bundle args = new Bundle();
+        args.putInt(INPUT_ID_ARG, mLastDetectedUsiId);
+
+        new SubSettingLauncher(mFragment.getContext())
+                .setDestination(StylusUsiDetailsFragment.class.getName())
+                .setArguments(args)
+                .setSourceMetricsCategory(mFragment.getMetricsCategory()).launch();
+    }
+}
--- a/src/com/android/settings/connecteddevice/stylus/StylusUsiHeaderController.java
+++ b/src/com/android/settings/connecteddevice/stylus/StylusUsiHeaderController.java
@@ -66,7 +66,7 @@ public class StylusUsiHeaderController extends BasePreferenceController implemen
        mHeaderPreference = screen.findPreference(getPreferenceKey());
        View view = mHeaderPreference.findViewById(R.id.entity_header);
        TextView titleView = view.findViewById(R.id.entity_header_title);
-        titleView.setText(R.string.stylus_usi_header_title);
+        titleView.setText(R.string.stylus_connected_devices_title);

        ImageView iconView = mHeaderPreference.findViewById(R.id.entity_header_icon);
        if (iconView != null) {