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

Commit 95892f33 authored by Roshan Pius's avatar Roshan Pius
Browse files

settings(uwb): Refactor UwbPreferenceController 

1. Use handler executor to directly handle state changed callbacks in
the same thread as APM handling.
2. Use the same flow to fetch the initial APM mode & UWB state from
onStart()
3. Store the state and reason code (to be used for showing regulatory
message in follow up CL).
4. Refactor the class for better unit testing (use mocks, avoid reaching
into class members being tested by using argument captor).

Bug: 270515435
Test: Manual tests
Test: atest UwbPreferenceControllerTest
Change-Id: I1b8c06a05691d9512de65ca2d61f3963dab230ab
parent cd7123e0

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

+44 −41
Original line number Diff line number Diff line
@@ -16,6 +16,9 @@ 


package com.android.settings.uwb;



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 +28,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,40 +42,50 @@ 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 mReason;

    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;

                mReason = reason;

                updateState(mPreference);

            };

        } else {

            mUwbManager = null;

            mAirplaneModeChangedReceiver = null;

            mAdapterStateCallback = null;

        }

    }



    public UwbPreferenceController(Context context, String key) {

        this(context, key, new UwbUtils());

    }



    public boolean isUwbSupportedOnDevice() {
@@ -101,14 +114,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 +129,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();

            mReason = 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,7 +156,7 @@ public class UwbPreferenceController extends TogglePreferenceController implemen 
    public void updateState(Preference preference) {

        super.updateState(preference);

        preference.setEnabled(!mAirplaneModeOn);

        refreshSummary(preference);

        refreshSummary(mPreference);

    }



    @Override

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

+115 −34
Original line number Diff line number Diff line
@@ -16,110 +16,153 @@ 


package com.android.settings.uwb;



import static android.uwb.UwbManager.AdapterStateCallback.STATE_CHANGED_REASON_SYSTEM_POLICY;

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

    @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(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 +172,52 @@ 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);

    }

}