diff --git a/src/com/android/settings/dashboard/ControllerFutureTask.java b/src/com/android/settings/dashboard/ControllerFutureTask.java new file mode 100644 index 00000000000..84d11fde16b --- /dev/null +++ b/src/com/android/settings/dashboard/ControllerFutureTask.java @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2019 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.dashboard; + +import com.android.settingslib.core.AbstractPreferenceController; + +import java.util.concurrent.FutureTask; + +/** + * {@link FutureTask} of the Controller. + */ +public class ControllerFutureTask extends FutureTask { + private final AbstractPreferenceController mController; + + public ControllerFutureTask(ControllerTask task, Void result) { + super(task, result); + mController = task.getController(); + } + + AbstractPreferenceController getController() { + return mController; + } +} diff --git a/src/com/android/settings/dashboard/ControllerTask.java b/src/com/android/settings/dashboard/ControllerTask.java new file mode 100644 index 00000000000..c62e738e8dc --- /dev/null +++ b/src/com/android/settings/dashboard/ControllerTask.java @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2019 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.dashboard; + +import android.app.settings.SettingsEnums; +import android.os.SystemClock; +import android.text.TextUtils; +import android.util.Log; + +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + +import com.android.settingslib.core.AbstractPreferenceController; +import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; +import com.android.settingslib.utils.ThreadUtils; + +/** + * A {@link Runnable} controller task. This task handle the visibility of the controller in the + * background. Also handle the state updating in the main thread. + */ +public class ControllerTask implements Runnable { + private static final String TAG = "ControllerTask"; + private static final int CONTROLLER_UPDATESTATE_TIME_THRESHOLD = 50; + + private final AbstractPreferenceController mController; + private final PreferenceScreen mScreen; + private final int mMetricsCategory; + private final MetricsFeatureProvider mMetricsFeature; + + public ControllerTask(AbstractPreferenceController controller, PreferenceScreen screen, + MetricsFeatureProvider metricsFeature, int metricsCategory) { + mController = controller; + mScreen = screen; + mMetricsFeature = metricsFeature; + mMetricsCategory = metricsCategory; + } + + @Override + public void run() { + if (!mController.isAvailable()) { + return; + } + + final String key = mController.getPreferenceKey(); + if (TextUtils.isEmpty(key)) { + Log.d(TAG, String.format("Preference key is %s in Controller %s", + key, mController.getClass().getSimpleName())); + return; + } + + final Preference preference = mScreen.findPreference(key); + if (preference == null) { + Log.d(TAG, String.format("Cannot find preference with key %s in Controller %s", + key, mController.getClass().getSimpleName())); + return; + } + ThreadUtils.postOnMainThread(() -> { + final long t = SystemClock.elapsedRealtime(); + mController.updateState(preference); + final int elapsedTime = (int) (SystemClock.elapsedRealtime() - t); + if (elapsedTime > CONTROLLER_UPDATESTATE_TIME_THRESHOLD) { + Log.w(TAG, "The updateState took " + elapsedTime + " ms in Controller " + + mController.getClass().getSimpleName()); + if (mMetricsFeature != null) { + mMetricsFeature.action(SettingsEnums.PAGE_UNKNOWN, + SettingsEnums.ACTION_CONTROLLER_UPDATE_STATE, mMetricsCategory, + mController.getClass().getSimpleName(), elapsedTime); + } + } + }); + } + + AbstractPreferenceController getController() { + return mController; + } +} diff --git a/src/com/android/settings/dashboard/DashboardFragment.java b/src/com/android/settings/dashboard/DashboardFragment.java index 50630fe4c41..f51b5cfab82 100644 --- a/src/com/android/settings/dashboard/DashboardFragment.java +++ b/src/com/android/settings/dashboard/DashboardFragment.java @@ -22,6 +22,7 @@ import android.content.Context; import android.os.Bundle; import android.text.TextUtils; import android.util.ArrayMap; +import android.util.FeatureFlagUtils; import android.util.Log; import androidx.annotation.CallSuper; @@ -35,6 +36,7 @@ import androidx.preference.SwitchPreference; import com.android.settings.R; import com.android.settings.SettingsPreferenceFragment; import com.android.settings.core.BasePreferenceController; +import com.android.settings.core.FeatureFlags; import com.android.settings.core.PreferenceControllerListHelper; import com.android.settings.core.SettingsBaseActivity; import com.android.settings.overlay.FeatureFactory; @@ -46,6 +48,7 @@ import com.android.settingslib.drawer.DashboardCategory; import com.android.settingslib.drawer.ProviderTile; import com.android.settingslib.drawer.Tile; import com.android.settingslib.search.Indexable; +import com.android.settingslib.utils.ThreadUtils; import java.util.ArrayList; import java.util.Arrays; @@ -53,6 +56,7 @@ import java.util.Collection; import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.concurrent.ExecutionException; /** * Base fragment for dashboard style UI containing a list of static and dynamic setting items. @@ -305,10 +309,23 @@ public abstract class DashboardFragment extends SettingsPreferenceFragment controller -> controller.displayPreference(screen)); } + /** + * @return {@code true} if the underlying controllers should be executed in parallel. + * Override this function to enable/disable the behavior. + */ + protected boolean isParalleledControllers() { + return false; + } + /** * Update state of each preference managed by PreferenceController. */ protected void updatePreferenceStates() { + if (isParalleledControllers() && FeatureFlagUtils.isEnabled(getContext(), + FeatureFlags.CONTROLLER_ENHANCEMENT)) { + updatePreferenceStatesInParallel(); + return; + } final PreferenceScreen screen = getPreferenceScreen(); Collection> controllerLists = mPreferenceControllers.values(); @@ -336,6 +353,34 @@ public abstract class DashboardFragment extends SettingsPreferenceFragment } } + /** + * Use parallel method to update state of each preference managed by PreferenceController. + */ + @VisibleForTesting + void updatePreferenceStatesInParallel() { + final PreferenceScreen screen = getPreferenceScreen(); + final Collection> controllerLists = + mPreferenceControllers.values(); + final List taskList = new ArrayList<>(); + for (List controllerList : controllerLists) { + for (AbstractPreferenceController controller : controllerList) { + final ControllerFutureTask task = new ControllerFutureTask( + new ControllerTask(controller, screen, mMetricsFeatureProvider, + getMetricsCategory()), null /* result */); + taskList.add(task); + ThreadUtils.postOnBackgroundThread(task); + } + } + + for (ControllerFutureTask task : taskList) { + try { + task.get(); + } catch (InterruptedException | ExecutionException e) { + Log.w(TAG, task.getController().getPreferenceKey() + " " + e.getMessage()); + } + } + } + /** * Refresh all preference items, including both static prefs from xml, and dynamic items from * DashboardCategory. diff --git a/tests/robotests/src/com/android/settings/dashboard/ControllerFutureTaskTest.java b/tests/robotests/src/com/android/settings/dashboard/ControllerFutureTaskTest.java new file mode 100644 index 00000000000..c66f2b557a8 --- /dev/null +++ b/tests/robotests/src/com/android/settings/dashboard/ControllerFutureTaskTest.java @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2019 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.dashboard; + +import static com.android.settingslib.core.instrumentation.Instrumentable.METRICS_CATEGORY_UNKNOWN; + +import static com.google.common.truth.Truth.assertThat; + +import android.content.Context; + +import androidx.preference.PreferenceManager; +import androidx.preference.PreferenceScreen; + +import com.android.settings.core.BasePreferenceController; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class ControllerFutureTaskTest { + private static final String KEY = "my_key"; + + private Context mContext; + private TestPreferenceController mTestController; + private PreferenceScreen mScreen; + + @Before + public void setUp() { + mContext = RuntimeEnvironment.application; + mTestController = new TestPreferenceController(mContext, KEY); + final PreferenceManager preferenceManager = new PreferenceManager(mContext); + mScreen = preferenceManager.createPreferenceScreen(mContext); + } + + @Test + public void getController_addTask_checkControllerKey() { + final ControllerFutureTask futureTask = new ControllerFutureTask( + new ControllerTask(mTestController, mScreen, null /* metricsFeature */, + METRICS_CATEGORY_UNKNOWN), null /* result */); + + assertThat(futureTask.getController().getPreferenceKey()).isEqualTo(KEY); + } + + + static class TestPreferenceController extends BasePreferenceController { + TestPreferenceController(Context context, String preferenceKey) { + super(context, preferenceKey); + } + + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + } +} diff --git a/tests/robotests/src/com/android/settings/dashboard/ControllerTaskTest.java b/tests/robotests/src/com/android/settings/dashboard/ControllerTaskTest.java new file mode 100644 index 00000000000..17ab79cb04d --- /dev/null +++ b/tests/robotests/src/com/android/settings/dashboard/ControllerTaskTest.java @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2019 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.dashboard; + +import static com.android.settingslib.core.instrumentation.Instrumentable.METRICS_CATEGORY_UNKNOWN; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + +import android.content.Context; + +import androidx.preference.Preference; +import androidx.preference.PreferenceManager; +import androidx.preference.PreferenceScreen; + +import com.android.settingslib.core.AbstractPreferenceController; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class ControllerTaskTest { + private static final String KEY = "my_key"; + + private Context mContext; + private PreferenceScreen mScreen; + private TestPreferenceController mTestController; + private ControllerTask mControllerTask; + + @Before + public void setUp() { + mContext = RuntimeEnvironment.application; + final PreferenceManager preferenceManager = new PreferenceManager(mContext); + mScreen = preferenceManager.createPreferenceScreen(mContext); + mTestController = spy(new TestPreferenceController(mContext)); + mControllerTask = new ControllerTask(mTestController, mScreen, null /* metricsFeature */, + METRICS_CATEGORY_UNKNOWN); + } + + @Test + public void doRun_controlNotAvailable_noRunUpdateState() { + mTestController.setAvailable(false); + + mControllerTask.run(); + + verify(mTestController, never()).updateState(any(Preference.class)); + } + + @Test + public void doRun_emptyKey_noRunUpdateState() { + mTestController.setKey(""); + + mControllerTask.run(); + + verify(mTestController, never()).updateState(any(Preference.class)); + } + + @Test + public void doRun_preferenceNotExist_noRunUpdateState() { + mTestController.setKey(KEY); + + mControllerTask.run(); + + verify(mTestController, never()).updateState(any(Preference.class)); + } + + @Test + public void doRun_executeUpdateState() { + mTestController.setKey(KEY); + final Preference preference = new Preference(mContext); + preference.setKey(KEY); + mScreen.addPreference(preference); + + mControllerTask.run(); + + verify(mTestController).updateState(any(Preference.class)); + } + + static class TestPreferenceController extends AbstractPreferenceController { + private boolean mAvailable; + private String mKey; + + TestPreferenceController(Context context) { + super(context); + mAvailable = true; + } + + @Override + public boolean isAvailable() { + return mAvailable; + } + + @Override + public String getPreferenceKey() { + return mKey; + } + + void setAvailable(boolean available) { + mAvailable = available; + } + + void setKey(String key) { + mKey = key; + } + } +} diff --git a/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentTest.java b/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentTest.java index 42b600aaf26..e70578e60db 100644 --- a/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentTest.java +++ b/tests/robotests/src/com/android/settings/dashboard/DashboardFragmentTest.java @@ -37,6 +37,7 @@ import android.content.pm.ActivityInfo; import android.content.pm.ProviderInfo; import android.net.Uri; import android.os.Bundle; +import android.util.FeatureFlagUtils; import androidx.preference.Preference; import androidx.preference.PreferenceFragmentCompat; @@ -45,6 +46,7 @@ import androidx.preference.PreferenceScreen; import androidx.preference.SwitchPreference; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; +import com.android.settings.core.FeatureFlags; import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.slices.BlockingSlicePrefController; import com.android.settings.testutils.FakeFeatureFactory; @@ -333,7 +335,38 @@ public class DashboardFragmentTest { assertThat(pref).isInstanceOf(MasterSwitchPreference.class); } - private static class TestPreferenceController extends AbstractPreferenceController + @Test + public void isFeatureFlagAndIsParalleled_runParalleledUpdatePreferenceStates() { + FeatureFlagUtils.setEnabled(mContext, FeatureFlags.CONTROLLER_ENHANCEMENT, true); + final TestFragment testFragment = spy(new TestFragment(RuntimeEnvironment.application)); + + testFragment.updatePreferenceStates(); + + verify(testFragment).updatePreferenceStatesInParallel(); + } + + @Test + public void notFeatureFlagAndIsParalleled_notRunParalleledUpdatePreferenceStates() { + FeatureFlagUtils.setEnabled(mContext, FeatureFlags.CONTROLLER_ENHANCEMENT, false); + final TestFragment testFragment = spy(new TestFragment(RuntimeEnvironment.application)); + + testFragment.updatePreferenceStates(); + + verify(testFragment, never()).updatePreferenceStatesInParallel(); + } + + @Test + public void isFeatureFlagAndNotParalleled_notRunParalleledUpdatePreferenceStates() { + FeatureFlagUtils.setEnabled(mContext, FeatureFlags.CONTROLLER_ENHANCEMENT, true); + final TestFragment testFragment = spy(new TestFragment(RuntimeEnvironment.application)); + testFragment.setUsingControllerEnhancement(false); + + testFragment.updatePreferenceStates(); + + verify(testFragment, never()).updatePreferenceStatesInParallel(); + } + + public static class TestPreferenceController extends AbstractPreferenceController implements PreferenceControllerMixin { private TestPreferenceController(Context context) { @@ -362,19 +395,21 @@ public class DashboardFragmentTest { private static class TestFragment extends DashboardFragment { - public final PreferenceScreen mScreen; - private final PreferenceManager mPreferenceManager; private final Context mContext; private final List mControllers; private final ContentResolver mContentResolver; + public final PreferenceScreen mScreen; + private boolean mIsParalleled; + public TestFragment(Context context) { mContext = context; mPreferenceManager = mock(PreferenceManager.class); mScreen = mock(PreferenceScreen.class); mContentResolver = mock(ContentResolver.class); mControllers = new ArrayList<>(); + mIsParalleled = true; when(mPreferenceManager.getContext()).thenReturn(mContext); ReflectionHelpers.setField( @@ -420,6 +455,14 @@ public class DashboardFragmentTest { protected ContentResolver getContentResolver() { return mContentResolver; } + + protected boolean isParalleledControllers() { + return mIsParalleled; + } + + public void setUsingControllerEnhancement(boolean isParalleled) { + mIsParalleled = isParalleled; + } } private static class TestDynamicDataObserver extends DynamicDataObserver {