Merge "USB firmware update for stylus in Stylus USI Device Details" into udc-qpr-dev am: bbf2dc4991

Original change: https://googleplex-android-review.googlesource.com/c/platform/packages/apps/Settings/+/23221022

Change-Id: Ied0222e7235e2643553e7401ac9b4c0ece442cee
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

src/com/android/settings/connecteddevice/stylus/StylusFeatureProvider.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2023 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.usb.UsbDevice;
+
+import androidx.preference.Preference;
+
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+/** FeatureProvider for USB settings */
+public interface StylusFeatureProvider {
+
+    /**
+     * Returns whether the current attached USB device allows firmware updates.
+     *
+     * @param usbDevice The USB device to check
+     */
+    boolean isUsbFirmwareUpdateEnabled(UsbDevice usbDevice);
+
+    /**
+     * Returns a list of preferences for the connected USB device if exists. If not, returns
+     * null. If an update is not available but firmware update feature is enabled for the device,
+     * the list will contain only the preference showing the current firmware version.
+     *
+     * @param context The context
+     */
+    @Nullable
+    List<Preference> getUsbFirmwareUpdatePreferences(Context context);
+}

src/com/android/settings/connecteddevice/stylus/StylusFeatureProviderImpl.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 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.usb.UsbDevice;
+
+import androidx.preference.Preference;
+
+import java.util.List;
+
+/** Default implementation for StylusFeatureProvider */
+public class StylusFeatureProviderImpl implements StylusFeatureProvider {
+    @Override
+    public boolean isUsbFirmwareUpdateEnabled(UsbDevice usbDevice) {
+        return false;
+    }
+
+    @Override
+    public List<Preference> getUsbFirmwareUpdatePreferences(Context context) {
+        return null;
+    }
+}

src/com/android/settings/connecteddevice/stylus/StylusUsbFirmwareController.java

@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2023 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.usb.UsbDevice;
+import android.hardware.usb.UsbManager;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceCategory;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.core.BasePreferenceController;
+import com.android.settings.overlay.FeatureFactory;
+import com.android.settingslib.core.lifecycle.LifecycleObserver;
+import com.android.settingslib.core.lifecycle.events.OnStart;
+import com.android.settingslib.core.lifecycle.events.OnStop;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/** Preference controller for stylus firmware updates via USB */
+public class StylusUsbFirmwareController extends BasePreferenceController
+        implements LifecycleObserver, OnStart, OnStop {
+    private static final String TAG = StylusUsbFirmwareController.class.getSimpleName();
+    @Nullable
+    private UsbDevice mStylusUsbDevice;
+    private final UsbStylusBroadcastReceiver mUsbStylusBroadcastReceiver;
+
+    private PreferenceScreen mPreferenceScreen;
+    private PreferenceCategory mPreference;
+
+    @VisibleForTesting
+    UsbStylusBroadcastReceiver.UsbStylusConnectionListener mUsbConnectionListener =
+            (stylusUsbDevice, attached) -> {
+                refresh();
+            };
+
+    public StylusUsbFirmwareController(Context context, String key) {
+        super(context, key);
+        mUsbStylusBroadcastReceiver = new UsbStylusBroadcastReceiver(context,
+                mUsbConnectionListener);
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        mPreferenceScreen = screen;
+        refresh();
+        super.displayPreference(screen);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        // always available, preferences will be added or
+        // removed according to the connected usb device
+        return AVAILABLE;
+    }
+
+    private void refresh() {
+        if (mPreferenceScreen == null) return;
+
+        UsbDevice device = getStylusUsbDevice();
+        if (device == mStylusUsbDevice) {
+            return;
+        }
+        mStylusUsbDevice = device;
+        mPreference = mPreferenceScreen.findPreference(getPreferenceKey());
+        if (mPreference != null) {
+            mPreferenceScreen.removePreference(mPreference);
+        }
+        if (hasUsbStylusFirmwareUpdateFeature(mStylusUsbDevice)) {
+            StylusFeatureProvider featureProvider = FeatureFactory.getFactory(
+                    mContext).getStylusFeatureProvider();
+            List<Preference> preferences =
+                    featureProvider.getUsbFirmwareUpdatePreferences(mContext);
+
+            if (preferences != null) {
+                mPreference = new PreferenceCategory(mContext);
+                mPreference.setKey(getPreferenceKey());
+                mPreferenceScreen.addPreference(mPreference);
+
+                for (Preference preference : preferences) {
+                    mPreference.addPreference(preference);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onStart() {
+        mUsbStylusBroadcastReceiver.register();
+    }
+
+    @Override
+    public void onStop() {
+        mUsbStylusBroadcastReceiver.unregister();
+    }
+
+    private UsbDevice getStylusUsbDevice() {
+        UsbManager usbManager = mContext.getSystemService(UsbManager.class);
+
+        if (usbManager == null) {
+            return null;
+        }
+
+        List<UsbDevice> devices = new ArrayList<>(usbManager.getDeviceList().values());
+        if (devices.isEmpty()) {
+            return null;
+        }
+
+        UsbDevice usbDevice = devices.get(0);
+        if (hasUsbStylusFirmwareUpdateFeature(usbDevice)) {
+            return usbDevice;
+        }
+        return null;
+    }
+
+    static boolean hasUsbStylusFirmwareUpdateFeature(UsbDevice usbDevice) {
+        if (usbDevice == null) return false;
+
+        StylusFeatureProvider featureProvider = FeatureFactory.getFactory(
+                FeatureFactory.getAppContext()).getStylusFeatureProvider();
+
+        return featureProvider.isUsbFirmwareUpdateEnabled(usbDevice);
+    }
+}

src/com/android/settings/connecteddevice/stylus/StylusUsiDetailsFragment.java

@@ -54,7 +54,6 @@ public class StylusUsiDetailsFragment extends DashboardFragment {
         }
     }
 
-
     @Override
     public int getMetricsCategory() {
         return SettingsEnums.USI_DEVICE_DETAILS;

src/com/android/settings/connecteddevice/stylus/UsbStylusBroadcastReceiver.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2023 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.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbManager;
+
+/** Broadcast receiver for styluses connected via USB */
+public class UsbStylusBroadcastReceiver extends BroadcastReceiver {
+    private Context mContext;
+    private UsbStylusConnectionListener mUsbConnectionListener;
+    private boolean mListeningToUsbEvents;
+
+    public UsbStylusBroadcastReceiver(Context context,
+            UsbStylusConnectionListener usbConnectionListener) {
+        mContext = context;
+        mUsbConnectionListener = usbConnectionListener;
+    }
+
+    /** Registers the receiver. */
+    public void register() {
+        if (!mListeningToUsbEvents) {
+            final IntentFilter intentFilter = new IntentFilter();
+            intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
+            intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
+            final Intent intent = mContext.registerReceiver(this, intentFilter);
+            if (intent != null) {
+                onReceive(mContext, intent);
+            }
+            mListeningToUsbEvents = true;
+        }
+    }
+
+    /** Unregisters the receiver. */
+    public void unregister() {
+        if (mListeningToUsbEvents) {
+            mContext.unregisterReceiver(this);
+            mListeningToUsbEvents = false;
+        }
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE, UsbDevice.class);
+        if (StylusUsbFirmwareController.hasUsbStylusFirmwareUpdateFeature(usbDevice)) {
+            mUsbConnectionListener.onUsbStylusConnectionChanged(usbDevice,
+                    intent.getAction().equals(UsbManager.ACTION_USB_DEVICE_ATTACHED));
+        }
+    }
+
+    /**
+     * Interface definition for a callback to be invoked when stylus usb connection is changed.
+     */
+    interface UsbStylusConnectionListener {
+        void onUsbStylusConnectionChanged(UsbDevice device, boolean connected);
+    }
+}

src/com/android/settings/overlay/FeatureFactory.java

@@ -31,6 +31,7 @@ import com.android.settings.aware.AwareFeatureProvider;
 import com.android.settings.biometrics.face.FaceFeatureProvider;
 import com.android.settings.biometrics2.factory.BiometricsRepositoryProvider;
 import com.android.settings.bluetooth.BluetoothFeatureProvider;
+import com.android.settings.connecteddevice.stylus.StylusFeatureProvider;
 import com.android.settings.dashboard.DashboardFeatureProvider;
 import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider;
 import com.android.settings.deviceinfo.hardwareinfo.HardwareInfoFeatureProvider;
@@ -209,6 +210,11 @@ public abstract class FeatureFactory {
      */
     public abstract KeyboardSettingsFeatureProvider getKeyboardSettingsFeatureProvider();
 
+    /**
+     * Retrieves implementation for stylus settings feature.
+     */
+    public abstract StylusFeatureProvider getStylusFeatureProvider();
+
     public static final class FactoryNotFoundException extends RuntimeException {
         public FactoryNotFoundException(Throwable throwable) {
             super("Unable to create factory. Did you misconfigure Proguard?", throwable);

src/com/android/settings/overlay/FeatureFactoryImpl.java

@@ -42,6 +42,8 @@ import com.android.settings.biometrics2.factory.BiometricsRepositoryProviderImpl
 import com.android.settings.bluetooth.BluetoothFeatureProvider;
 import com.android.settings.bluetooth.BluetoothFeatureProviderImpl;
 import com.android.settings.connecteddevice.dock.DockUpdaterFeatureProviderImpl;
+import com.android.settings.connecteddevice.stylus.StylusFeatureProvider;
+import com.android.settings.connecteddevice.stylus.StylusFeatureProviderImpl;
 import com.android.settings.core.instrumentation.SettingsMetricsFeatureProvider;
 import com.android.settings.dashboard.DashboardFeatureProvider;
 import com.android.settings.dashboard.DashboardFeatureProviderImpl;
@@ -119,6 +121,7 @@ public class FeatureFactoryImpl extends FeatureFactory {
     private AdvancedVpnFeatureProvider mAdvancedVpnFeatureProvider;
     private WifiFeatureProvider mWifiFeatureProvider;
     private KeyboardSettingsFeatureProvider mKeyboardSettingsFeatureProvider;
+    private StylusFeatureProvider mStylusFeatureProvider;
 
     @Override
     public HardwareInfoFeatureProvider getHardwareInfoFeatureProvider() {
@@ -383,4 +386,12 @@ public class FeatureFactoryImpl extends FeatureFactory {
         }
         return mKeyboardSettingsFeatureProvider;
     }
+
+    @Override
+    public StylusFeatureProvider getStylusFeatureProvider() {
+        if (mStylusFeatureProvider == null) {
+            mStylusFeatureProvider = new StylusFeatureProviderImpl();
+        }
+        return mStylusFeatureProvider;
+    }
 }