Merge changes I8a6f01ab,I1b8c06a0 into udc-dev am: 7a49bfe6b0

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

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

res/values/strings.xml

@@ -11524,9 +11524,12 @@
     <!-- Summary for UWB preference. [CHAR_LIMIT=NONE]-->
     <string name="uwb_settings_summary">Helps identify the relative position of nearby devices that have UWB</string>
 
-    <!-- Summary for UWB preference when airplane mode is disabled. [CHAR_LIMIT=NONE]-->
+    <!-- Summary for UWB preference when airplane mode is enabled. [CHAR_LIMIT=NONE]-->
     <string name="uwb_settings_summary_airplane_mode">Turn off airplane mode to use UWB </string>
 
+    <!-- Summary for UWB preference when UWB is unavailable due to regulatory requirements. [CHAR_LIMIT=NONE]-->
+    <string name="uwb_settings_summary_no_uwb_regulatory">UWB is unavailable in the current location</string>
+
     <!-- Label for the camera use toggle [CHAR LIMIT=40] -->
     <string name="camera_toggle_title">Camera access</string>
     <!-- Label for the camera use toggle [CHAR LIMIT=40] -->

src/com/android/settings/uwb/UwbPreferenceController.java

@@ -16,6 +16,11 @@
 
 package com.android.settings.uwb;
 
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_CHANGED_REASON_SYSTEM_REGULATION;
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_DISABLED;
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_ENABLED_ACTIVE;
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_ENABLED_INACTIVE;
+
 import static androidx.lifecycle.Lifecycle.Event.ON_START;
 import static androidx.lifecycle.Lifecycle.Event.ON_STOP;
 
@@ -25,7 +30,7 @@ import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.os.Handler;
-import android.provider.Settings;
+import android.os.HandlerExecutor;
 import android.uwb.UwbManager;
 import android.uwb.UwbManager.AdapterStateCallback;
 
@@ -39,52 +44,68 @@ import com.android.settings.R;
 import com.android.settings.core.TogglePreferenceController;
 
 import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
 
 /** Controller for "UWB" toggle. */
 public class UwbPreferenceController extends TogglePreferenceController implements
-        AdapterStateCallback, LifecycleObserver {
+        LifecycleObserver {
-    @VisibleForTesting
+    private final UwbManager mUwbManager;
-    static final String KEY_UWB_SETTINGS = "uwb_settings";
+    private final UwbUtils mUwbUtils;
-    @VisibleForTesting
+    private boolean mAirplaneModeOn;
-    UwbManager mUwbManager;
+    private /* @AdapterStateCallback.State */ int mState;
-    @VisibleForTesting
+    private /* @AdapterStateCallback.StateChangedReason */ int mStateReason;
-    boolean mAirplaneModeOn;
-    @VisibleForTesting
     private final BroadcastReceiver mAirplaneModeChangedReceiver;
+    private final AdapterStateCallback mAdapterStateCallback;
     private final Executor mExecutor;
     private final Handler mHandler;
     private Preference mPreference;
 
-    public UwbPreferenceController(Context context, String key) {
+    @VisibleForTesting
+    public UwbPreferenceController(Context context, String key, UwbUtils uwbUtils) {
         super(context, key);
-        mExecutor = Executors.newSingleThreadExecutor();
         mHandler = new Handler(context.getMainLooper());
+        mExecutor = new HandlerExecutor(mHandler);
+        mUwbUtils = uwbUtils;
         if (isUwbSupportedOnDevice()) {
             mUwbManager = context.getSystemService(UwbManager.class);
-        }
+            mAirplaneModeChangedReceiver = new BroadcastReceiver() {
-        mAirplaneModeOn = Settings.Global.getInt(mContext.getContentResolver(),
+                @Override
-                Settings.Global.AIRPLANE_MODE_ON, 0) == 1;
+                public void onReceive(Context context, Intent intent) {
-        mAirplaneModeChangedReceiver = new BroadcastReceiver() {
+                    mAirplaneModeOn = mUwbUtils.isAirplaneModeOn(mContext);
-            @Override
+                    updateState(mPreference);
-            public void onReceive(Context context, Intent intent) {
+                }
-                mAirplaneModeOn = Settings.Global.getInt(mContext.getContentResolver(),
+            };
-                        Settings.Global.AIRPLANE_MODE_ON, 0) == 1;
+            mAdapterStateCallback = (state, reason) -> {
+                mState = state;
+                mStateReason = reason;
                 updateState(mPreference);
-            }
+            };
-        };
+        } else {
+            mUwbManager = null;
+            mAirplaneModeChangedReceiver = null;
+            mAdapterStateCallback = null;
+        }
+    }
+
+    public UwbPreferenceController(Context context, String key) {
+        this(context, key, new UwbUtils());
     }
 
     public boolean isUwbSupportedOnDevice() {
         return mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_UWB);
     }
 
+    private boolean isUwbDisabledDueToRegulatory() {
+        return mState == STATE_DISABLED && mStateReason == STATE_CHANGED_REASON_SYSTEM_REGULATION;
+    }
+
     @Override
     public int getAvailabilityStatus() {
         if (!isUwbSupportedOnDevice()) {
             return UNSUPPORTED_ON_DEVICE;
         } else if (mAirplaneModeOn) {
             return DISABLED_DEPENDENT_SETTING;
+        } else if (isUwbDisabledDueToRegulatory()) {
+            return CONDITIONALLY_UNAVAILABLE;
         } else {
             return AVAILABLE;
         }
@@ -101,14 +122,11 @@ public class UwbPreferenceController extends TogglePreferenceController implemen
         if (!isUwbSupportedOnDevice()) {
             return false;
         }
-        int state = mUwbManager.getAdapterState();
+        return mState == STATE_ENABLED_ACTIVE || mState == STATE_ENABLED_INACTIVE;
-        return state == STATE_ENABLED_ACTIVE || state == STATE_ENABLED_INACTIVE;
     }
 
     @Override
     public boolean setChecked(boolean isChecked) {
-        mAirplaneModeOn = Settings.Global.getInt(mContext.getContentResolver(),
-                Settings.Global.AIRPLANE_MODE_ON, 0) == 1;
         if (isUwbSupportedOnDevice()) {
             if (mAirplaneModeOn) {
                 mUwbManager.setUwbEnabled(false);
@@ -119,32 +137,25 @@ public class UwbPreferenceController extends TogglePreferenceController implemen
         return true;
     }
 
-    @Override
-    public void onStateChanged(int state, int reason) {
-        Runnable runnable = () -> updateState(mPreference);
-        mHandler.post(runnable);
-    }
-
     /** Called when activity starts being displayed to user. */
     @OnLifecycleEvent(ON_START)
     public void onStart() {
         if (isUwbSupportedOnDevice()) {
-            mUwbManager.registerAdapterStateCallback(mExecutor, this);
+            mState = mUwbManager.getAdapterState();
-        }
+            mStateReason = AdapterStateCallback.STATE_CHANGED_REASON_ERROR_UNKNOWN;
-        if (mAirplaneModeChangedReceiver != null) {
+            mAirplaneModeOn = mUwbUtils.isAirplaneModeOn(mContext);
+            mUwbManager.registerAdapterStateCallback(mExecutor, mAdapterStateCallback);
             mContext.registerReceiver(mAirplaneModeChangedReceiver,
-                    new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED));
+                    new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED), null, mHandler);
+            refreshSummary(mPreference);
         }
-        refreshSummary(mPreference);
     }
 
     /** Called when activity stops being displayed to user. */
     @OnLifecycleEvent(ON_STOP)
     public void onStop() {
         if (isUwbSupportedOnDevice()) {
-            mUwbManager.unregisterAdapterStateCallback(this);
+            mUwbManager.unregisterAdapterStateCallback(mAdapterStateCallback);
-        }
-        if (mAirplaneModeChangedReceiver != null) {
             mContext.unregisterReceiver(mAirplaneModeChangedReceiver);
         }
     }
@@ -153,13 +164,16 @@ public class UwbPreferenceController extends TogglePreferenceController implemen
     public void updateState(Preference preference) {
         super.updateState(preference);
         preference.setEnabled(!mAirplaneModeOn);
-        refreshSummary(preference);
+        refreshSummary(mPreference);
     }
 
     @Override
     public CharSequence getSummary() {
         if (mAirplaneModeOn) {
             return mContext.getResources().getString(R.string.uwb_settings_summary_airplane_mode);
+        } else if (isUwbDisabledDueToRegulatory()) {
+            return mContext.getResources().getString(
+                    R.string.uwb_settings_summary_no_uwb_regulatory);
         } else {
             return mContext.getResources().getString(R.string.uwb_settings_summary);
         }

src/com/android/settings/uwb/UwbUtils.java

@@ -0,0 +1,34 @@
+/*
+ * 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.uwb;
+
+import android.content.Context;
+import android.provider.Settings;
+
+/**
+ * Utils to help mock static methods in {@link UwbPreferenceController}.
+ */
+public class UwbUtils {
+    /**
+     * Returns whether airplane mode is on or off.
+     */
+    public boolean isAirplaneModeOn(Context context) {
+        return Settings.Global.getInt(context.getContentResolver(),
+                Settings.Global.AIRPLANE_MODE_ON, 0) == 1;
+    }
+}
+

tests/robotests/Android.bp

@@ -42,6 +42,7 @@ android_app {
         "androidx.test.core",
         "androidx.test.runner",
         "androidx.test.ext.junit",
+        "frameworks-base-testutils",
         "guava",
         "jsr305",
         "settings-contextual-card-protos-lite",

tests/robotests/src/com/android/settings/uwb/UwbPreferenceControllerTest.java

@@ -16,110 +16,157 @@
 
 package com.android.settings.uwb;
 
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_CHANGED_REASON_SYSTEM_POLICY;
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_CHANGED_REASON_SYSTEM_REGULATION;
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_DISABLED;
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_ENABLED_ACTIVE;
+import static android.uwb.UwbManager.AdapterStateCallback.STATE_ENABLED_INACTIVE;
+
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyString;
 import static org.mockito.Mockito.clearInvocations;
 import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
+import android.content.BroadcastReceiver;
 import android.content.Context;
+import android.content.Intent;
 import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.os.test.TestLooper;
 import android.uwb.UwbManager;
 
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.R;
 import com.android.settings.core.BasePreferenceController;
 
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
 import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
 
 /** Unit tests for UWB preference toggle. */
 @RunWith(RobolectricTestRunner.class)
 public class UwbPreferenceControllerTest {
+    private static final String TEST_SUMMARY = "uwb";
+    private static final String TEST_AIRPLANE_SUMMARY = "apm_uwb";
+    private static final String TEST_NO_UWB_REGULATORY_SUMMARY = "regulatory_uwb";
     @Rule
     public MockitoRule rule = MockitoJUnit.rule();
 
+    @Mock
     private Context mContext;
+    @Mock
     private PackageManager mPackageManager;
     private UwbPreferenceController mController;
-
+    private ArgumentCaptor<UwbManager.AdapterStateCallback> mAdapterStateCallbackArgumentCaptor =
+            ArgumentCaptor.forClass(UwbManager.AdapterStateCallback.class);
+    private ArgumentCaptor<BroadcastReceiver> mBroadcastReceiverArgumentCaptor =
+            ArgumentCaptor.forClass(BroadcastReceiver.class);
+    private TestLooper mTestLooper;
     @Mock
     private UwbManager mUwbManager;
+    @Mock
+    private UwbUtils mUwbUtils;
+    @Mock
+    private Preference mPreference;
+    @Mock
+    private PreferenceScreen mPreferenceScreen;
+    @Mock
+    private Resources mResources;
 
     @Before
-    public void setUp() {
+    public void setUp() throws Exception {
-        mContext = spy(RuntimeEnvironment.application);
+        mTestLooper = new TestLooper();
-        mPackageManager = spy(mContext.getPackageManager());
-        mController = new UwbPreferenceController(mContext, "uwb_settings");
-        mController.mUwbManager = mUwbManager;
-    }
-
-    @Test
-    public void getAvailabilityStatus_uwbDisabled_shouldReturnDisabled() {
         doReturn(mPackageManager).when(mContext).getPackageManager();
         doReturn(true).when(mPackageManager)
                 .hasSystemFeature(PackageManager.FEATURE_UWB);
-        mController.mAirplaneModeOn = true;
+        when(mResources.getString(R.string.uwb_settings_summary))
+                .thenReturn(TEST_SUMMARY);
+        when(mResources.getString(R.string.uwb_settings_summary_airplane_mode))
+                .thenReturn(TEST_AIRPLANE_SUMMARY);
+        when(mResources.getString(R.string.uwb_settings_summary_no_uwb_regulatory))
+                .thenReturn(TEST_NO_UWB_REGULATORY_SUMMARY);
+        when(mContext.getMainLooper()).thenReturn(mTestLooper.getLooper());
+        when(mContext.getSystemService(UwbManager.class)).thenReturn(mUwbManager);
+        when(mContext.getResources()).thenReturn(mResources);
+        when(mUwbUtils.isAirplaneModeOn(any())).thenReturn(false);
+        doReturn(STATE_ENABLED_ACTIVE).when(mUwbManager).getAdapterState();
+        mController = new UwbPreferenceController(mContext, "uwb_settings", mUwbUtils);
+        when(mPreferenceScreen.findPreference(anyString())).thenReturn(mPreference);
+        mController.displayPreference(mPreferenceScreen);
+    }
 
+    private void startControllerAndCaptureCallbacks() {
+        mController.onStart();
+        verify(mContext).registerReceiver(
+                mBroadcastReceiverArgumentCaptor.capture(), any(), any(), any());
+        verify(mUwbManager).registerAdapterStateCallback(
+                any(), mAdapterStateCallbackArgumentCaptor.capture());
+    }
+
+    @Test
+    public void getAvailabilityStatus_uwbDisabled_shouldReturnDisabled() throws Exception {
+        when(mUwbUtils.isAirplaneModeOn(any())).thenReturn(true);
+        startControllerAndCaptureCallbacks();
         assertThat(mController.getAvailabilityStatus())
                 .isEqualTo(BasePreferenceController.DISABLED_DEPENDENT_SETTING);
     }
 
     @Test
-    public void getAvailabilityStatus_uwbShown_shouldReturnAvailable() {
+    public void getAvailabilityStatus_uwbShown_shouldReturnAvailable() throws Exception {
-        doReturn(mPackageManager).when(mContext).getPackageManager();
+        when(mUwbUtils.isAirplaneModeOn(any())).thenReturn(false);
-        doReturn(true).when(mPackageManager)
+        startControllerAndCaptureCallbacks();
-                .hasSystemFeature(PackageManager.FEATURE_UWB);
-        mController.mAirplaneModeOn = false;
-
         assertThat(mController.getAvailabilityStatus())
                 .isEqualTo(BasePreferenceController.AVAILABLE);
     }
 
     @Test
     public void getAvailabilityStatus_uwbNotShown_shouldReturnUnsupported() {
-        doReturn(mPackageManager).when(mContext).getPackageManager();
         doReturn(false).when(mPackageManager)
                 .hasSystemFeature(PackageManager.FEATURE_UWB);
 
+        mController.onStart();
+        verify(mContext, never()).registerReceiver(any(), any(), any(), any());
+        verify(mUwbManager, never()).registerAdapterStateCallback(any(), any());
         assertThat(mController.getAvailabilityStatus())
                 .isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
     }
 
     @Test
     public void isChecked_uwbEnabled_shouldReturnTrue() {
-        doReturn(mPackageManager).when(mContext).getPackageManager();
+        doReturn(STATE_ENABLED_ACTIVE).when(mUwbManager).getAdapterState();
-        doReturn(true).when(mPackageManager)
-                .hasSystemFeature(PackageManager.FEATURE_UWB);
-        doReturn(mController.STATE_ENABLED_ACTIVE).when(mUwbManager).getAdapterState();
 
+        startControllerAndCaptureCallbacks();
         assertThat(mController.isChecked()).isTrue();
     }
 
     @Test
     public void isChecked_uwbDisabled_shouldReturnFalse() {
-        doReturn(mPackageManager).when(mContext).getPackageManager();
+        doReturn(STATE_DISABLED).when(mUwbManager).getAdapterState();
-        doReturn(true).when(mPackageManager)
-                .hasSystemFeature(PackageManager.FEATURE_UWB);
-        doReturn(mController.STATE_DISABLED).when(mUwbManager).getAdapterState();
 
+        startControllerAndCaptureCallbacks();
         assertThat(mController.isChecked()).isFalse();
     }
 
     @Test
     public void setChecked_uwbDisabled_shouldEnableUwb() {
         clearInvocations(mUwbManager);
-        doReturn(mPackageManager).when(mContext).getPackageManager();
-        doReturn(true).when(mPackageManager)
-                .hasSystemFeature(PackageManager.FEATURE_UWB);
 
+        startControllerAndCaptureCallbacks();
         mController.setChecked(true);
 
         verify(mUwbManager).setUwbEnabled(true);
@@ -129,14 +176,65 @@ public class UwbPreferenceControllerTest {
     @Test
     public void setChecked_uwbEnabled_shouldDisableUwb() {
         clearInvocations(mUwbManager);
-        doReturn(mPackageManager).when(mContext).getPackageManager();
-        doReturn(true).when(mPackageManager)
-                .hasSystemFeature(PackageManager.FEATURE_UWB);
 
+        startControllerAndCaptureCallbacks();
         mController.setChecked(false);
 
         verify(mUwbManager).setUwbEnabled(false);
         verify(mUwbManager, never()).setUwbEnabled(true);
     }
+
+    @Test
+    public void updateStateAndSummary_uwbDisabledAndEnabled() {
+        startControllerAndCaptureCallbacks();
+        clearInvocations(mUwbManager, mPreference);
+
+        mAdapterStateCallbackArgumentCaptor.getValue().onStateChanged(
+                STATE_DISABLED, STATE_CHANGED_REASON_SYSTEM_POLICY);
+
+        verify(mPreference).setEnabled(true);
+        assertThat(mController.isChecked()).isFalse();
+        verify(mPreference, times(2)).setSummary(TEST_SUMMARY);
+
+        mAdapterStateCallbackArgumentCaptor.getValue().onStateChanged(
+                STATE_ENABLED_INACTIVE, STATE_CHANGED_REASON_SYSTEM_POLICY);
+
+        verify(mPreference, times(2)).setEnabled(true);
+        assertThat(mController.isChecked()).isTrue();
+        verify(mPreference, times(4)).setSummary(TEST_SUMMARY);
+    }
+
+    @Test
+    public void updateStateAndSummary_apmEnabledAndDisabled() {
+        startControllerAndCaptureCallbacks();
+        clearInvocations(mUwbManager, mPreference);
+
+        when(mUwbUtils.isAirplaneModeOn(any())).thenReturn(true);
+        mBroadcastReceiverArgumentCaptor.getValue().onReceive(
+                mock(Context.class), mock(Intent.class));
+
+        verify(mPreference).setEnabled(false);
+        verify(mPreference, times(2)).setSummary(TEST_AIRPLANE_SUMMARY);
+
+        when(mUwbUtils.isAirplaneModeOn(any())).thenReturn(false);
+        mBroadcastReceiverArgumentCaptor.getValue().onReceive(
+                mock(Context.class), mock(Intent.class));
+
+        verify(mPreference).setEnabled(true);
+        verify(mPreference, times(2)).setSummary(TEST_SUMMARY);
+    }
+
+    @Test
+    public void updateStateAndSummary_uwbDisabledDueToRegulatory() {
+        startControllerAndCaptureCallbacks();
+        clearInvocations(mUwbManager, mPreference);
+
+        mAdapterStateCallbackArgumentCaptor.getValue().onStateChanged(
+                STATE_DISABLED, STATE_CHANGED_REASON_SYSTEM_REGULATION);
+
+        assertThat(mController.getAvailabilityStatus())
+                .isEqualTo(BasePreferenceController.CONDITIONALLY_UNAVAILABLE);
+        verify(mPreference, times(2)).setSummary(TEST_NO_UWB_REGULATORY_SUMMARY);
+    }
 }