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

Commit 7a49bfe6 authored by Roshan Pius's avatar Roshan Pius Committed by Android (Google) Code Review
Browse files

Merge changes I8a6f01ab,I1b8c06a0 into udc-dev 

* changes:
  settings(uwb): Show message when UWB is unavailable due to regulatory
  settings(uwb): Refactor UwbPreferenceController
parents eff901c1 6fc40046

res/values/strings.xml

+4 −1
Original line number Diff line number Diff line
@@ -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



+55
−41






























Original line number
Diff line number
Diff line







@@ -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 {









    @VisibleForTesting









    static final String KEY_UWB_SETTINGS = "uwb_settings";









    @VisibleForTesting









    UwbManager mUwbManager;









    @VisibleForTesting









    boolean mAirplaneModeOn;









    @VisibleForTesting









        LifecycleObserver {









    private final UwbManager mUwbManager;









    private final UwbUtils mUwbUtils;









    private boolean mAirplaneModeOn;









    private /* @AdapterStateCallback.State */ int mState;









    private /* @AdapterStateCallback.StateChangedReason */ int mStateReason;









    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);









        }









        mAirplaneModeOn = Settings.Global.getInt(mContext.getContentResolver(),









                Settings.Global.AIRPLANE_MODE_ON, 0) == 1;









            mAirplaneModeChangedReceiver = new BroadcastReceiver() {









                @Override









                public void onReceive(Context context, Intent intent) {









                mAirplaneModeOn = Settings.Global.getInt(mContext.getContentResolver(),









                        Settings.Global.AIRPLANE_MODE_ON, 0) == 1;









                    mAirplaneModeOn = mUwbUtils.isAirplaneModeOn(mContext);









                    updateState(mPreference);









                }









            };









            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 state == STATE_ENABLED_ACTIVE || state == STATE_ENABLED_INACTIVE;









        return mState == STATE_ENABLED_ACTIVE || mState == 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);









        }









        if (mAirplaneModeChangedReceiver != null) {









            mState = mUwbManager.getAdapterState();









            mStateReason = AdapterStateCallback.STATE_CHANGED_REASON_ERROR_UNKNOWN;









            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);









        }









    }



















    /** Called when activity stops being displayed to user. */









    @OnLifecycleEvent(ON_STOP)









    public void onStop() {









        if (isUwbSupportedOnDevice()) {









            mUwbManager.unregisterAdapterStateCallback(this);









        }









        if (mAirplaneModeChangedReceiver != null) {









            mUwbManager.unregisterAdapterStateCallback(mAdapterStateCallback);









            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 → 100644



+34
−0






























Original line number
Diff line number
Diff line









/*









 * 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



+1
−0






























Original line number
Diff line number
Diff line







@@ -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



+132
−34






























Original line number
Diff line number
Diff line







@@ -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() {









        mContext = spy(RuntimeEnvironment.application);









        mPackageManager = spy(mContext.getPackageManager());









        mController = new UwbPreferenceController(mContext, "uwb_settings");









        mController.mUwbManager = mUwbManager;









    }



















    @Test









    public void getAvailabilityStatus_uwbDisabled_shouldReturnDisabled() {









    public void setUp() throws Exception {









        mTestLooper = new TestLooper();









        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() {









        doReturn(mPackageManager).when(mContext).getPackageManager();









        doReturn(true).when(mPackageManager)









                .hasSystemFeature(PackageManager.FEATURE_UWB);









        mController.mAirplaneModeOn = false;



















    public void getAvailabilityStatus_uwbShown_shouldReturnAvailable() throws Exception {









        when(mUwbUtils.isAirplaneModeOn(any())).thenReturn(false);









        startControllerAndCaptureCallbacks();









        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(true).when(mPackageManager)









                .hasSystemFeature(PackageManager.FEATURE_UWB);









        doReturn(mController.STATE_ENABLED_ACTIVE).when(mUwbManager).getAdapterState();









        doReturn(STATE_ENABLED_ACTIVE).when(mUwbManager).getAdapterState();



















        startControllerAndCaptureCallbacks();









        assertThat(mController.isChecked()).isTrue();









    }



















    @Test









    public void isChecked_uwbDisabled_shouldReturnFalse() {









        doReturn(mPackageManager).when(mContext).getPackageManager();









        doReturn(true).when(mPackageManager)









                .hasSystemFeature(PackageManager.FEATURE_UWB);









        doReturn(mController.STATE_DISABLED).when(mUwbManager).getAdapterState();









        doReturn(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);









    }









}