From 46b13eb18490e37e2b01c36cce6e2f369eac4078 Mon Sep 17 00:00:00 2001 From: Sunny Goyal Date: Mon, 21 Apr 2025 14:04:18 -0700 Subject: [PATCH] Moving WorkspaceItemFactory to dagger as PredictedItemFactory so that it can be reused Bug: 390572144 Flag: EXEMPTY refactor Test: Presubmit Change-Id: I41c5fea73452d7f4c1fd9980a89bcb7199eb19d7 --- .../launcher3/model/PredictedItemFactory.kt | 187 ++++++++++ .../launcher3/model/PredictionUpdateTask.java | 1 - .../model/QuickstepModelDelegate.java | 345 +++--------------- .../model/WidgetsPredictionUpdateTask.java | 1 - .../model/QuickstepModelDelegateTest.kt | 20 +- .../WidgetsPredicationUpdateTaskTest.java | 1 - src/com/android/launcher3/LauncherModel.kt | 5 - .../android/launcher3/model/LoaderTask.java | 9 +- .../launcher3/model/ModelDelegate.java | 24 +- .../launcher3/model/ModelInitializer.kt | 4 +- .../model/ReloadStringCacheTask.java | 9 +- .../android/launcher3/model/LoaderTaskTest.kt | 4 +- 12 files changed, 270 insertions(+), 340 deletions(-) create mode 100644 quickstep/src/com/android/launcher3/model/PredictedItemFactory.kt diff --git a/quickstep/src/com/android/launcher3/model/PredictedItemFactory.kt b/quickstep/src/com/android/launcher3/model/PredictedItemFactory.kt new file mode 100644 index 0000000000..47959bf086 --- /dev/null +++ b/quickstep/src/com/android/launcher3/model/PredictedItemFactory.kt @@ -0,0 +1,187 @@ +/* + * Copyright (C) 2025 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.launcher3.model + +import android.app.prediction.AppPredictionContext +import android.app.prediction.AppPredictionManager +import android.app.prediction.AppPredictor +import android.app.prediction.AppTarget +import android.app.prediction.AppTargetEvent +import android.content.Context +import android.content.Intent +import android.content.pm.LauncherApps +import android.content.pm.ShortcutInfo +import android.os.UserHandle +import android.os.UserManager +import androidx.annotation.VisibleForTesting +import com.android.launcher3.LauncherModel +import com.android.launcher3.LauncherModel.ModelUpdateTask +import com.android.launcher3.LauncherSettings.Favorites +import com.android.launcher3.dagger.ApplicationContext +import com.android.launcher3.icons.IconCache +import com.android.launcher3.icons.cache.CacheLookupFlag +import com.android.launcher3.model.data.AppInfo +import com.android.launcher3.model.data.ItemInfo +import com.android.launcher3.model.data.WorkspaceItemInfo +import com.android.launcher3.pm.UserCache +import com.android.launcher3.shortcuts.ShortcutKey +import com.android.launcher3.shortcuts.ShortcutRequest +import com.android.launcher3.util.ApiWrapper +import com.android.launcher3.util.Executors.MODEL_EXECUTOR +import com.android.launcher3.util.PackageManagerHelper +import com.android.launcher3.util.PersistedItemArray +import com.android.launcher3.util.PersistedItemArray.ItemFactory +import dagger.assisted.Assisted +import dagger.assisted.AssistedFactory +import dagger.assisted.AssistedInject + +/** [PersistedItemArray.ItemFactory] to parse predicted items */ +class PredictedItemFactory +@AssistedInject +constructor( + @ApplicationContext private val context: Context, + private val pmHelper: PackageManagerHelper, + private val userCache: UserCache, + private val apiWrapper: ApiWrapper, + private val iconCache: IconCache, + @Assisted private val maxItemCount: Int, + @Assisted private val predictorState: PredictorState, +) : ItemFactory { + + private val quietModeCache = mutableMapOf() + // Number of items persisted can be different than what is needed if the grid changed between + // the two operations + private var readCount = 0 + + override fun createInfo(itemType: Int, user: UserHandle, intent: Intent): ItemInfo? { + if (readCount >= maxItemCount) { + return null + } + when (itemType) { + Favorites.ITEM_TYPE_APPLICATION -> { + val lai = + context + .getSystemService(LauncherApps::class.java) + ?.resolveActivity(intent, user) ?: return null + val info = + AppInfo( + lai, + userCache.getUserInfo(user), + apiWrapper, + pmHelper, + quietModeCache.getOrPut(user) { + context + .getSystemService(UserManager::class.java) + ?.isQuietModeEnabled(user) ?: true + }, + ) + info.container = predictorState.containerId + iconCache.getTitleAndIcon(info, lai, predictorState.lookupFlag) + readCount++ + return info.makeWorkspaceItem(context) + } + + Favorites.ITEM_TYPE_DEEP_SHORTCUT -> { + val key = ShortcutKey.fromIntent(intent, user) ?: return null + val si: ShortcutInfo = + key.buildRequest(context).query(ShortcutRequest.PINNED).getOrNull(0) + ?: return null + val wii = WorkspaceItemInfo(si, context) + wii.container = predictorState.containerId + iconCache.getShortcutIcon(wii, si) + readCount++ + return wii + } + } + return null + } + + @AssistedFactory + interface Factory { + fun newParser(maxItemCount: Int, predictorState: PredictorState): PredictedItemFactory + } +} + +/** Class to manage predicted items for a particular prediction type */ +class PredictorState( + @JvmField val containerId: Int, + storageName: String, + @JvmField val lookupFlag: CacheLookupFlag, +) { + + @JvmField val storage: PersistedItemArray = PersistedItemArray(storageName) + + @VisibleForTesting var predictor: AppPredictor? = null + + private var lastTargets: List = emptyList() + + /** Creates and registers a predictor, and destroys any previously created predictor */ + fun registerPredictor( + ctx: Context, + predictionContext: AppPredictionContext, + model: LauncherModel, + taskFactory: (PredictorState, List) -> ModelUpdateTask, + ) { + destroyPredictor() + + val apm = ctx.getSystemService(AppPredictionManager::class.java) ?: return + lastTargets = emptyList() + + predictor = + apm.createAppPredictionSession(predictionContext).apply { + registerPredictionUpdates(MODEL_EXECUTOR) { + val oldTargets = lastTargets + lastTargets = it + + // If no diff, skip + if ( + oldTargets.size != lastTargets.size || + oldTargets.zip(lastTargets).any { (a1, a2) -> + !areAppTargetsSame(a1, a2) + } + ) { + model.enqueueModelUpdateTask(taskFactory.invoke(this@PredictorState, it)) + } + } + requestPredictionUpdate() + } + } + + /** Destroys a previously created predictor */ + fun destroyPredictor() { + predictor?.destroy() + predictor = null + } + + /** see [AppPredictor.requestPredictionUpdate] */ + fun requestPredictionUpdate() = predictor?.requestPredictionUpdate() + + /** see [AppPredictor.notifyAppTargetEvent] */ + fun notifyAppTargetEvent(event: AppTargetEvent) = predictor?.notifyAppTargetEvent(event) + + /** Compares two targets for the properties which we care about */ + private fun areAppTargetsSame(t1: AppTarget, t2: AppTarget): Boolean { + if ( + (t1.packageName != t2.packageName) || + (t1.user != t2.user) || + (t1.className != t2.className) + ) { + return false + } + return t1.shortcutInfo?.id == t2.shortcutInfo?.id + } +} diff --git a/quickstep/src/com/android/launcher3/model/PredictionUpdateTask.java b/quickstep/src/com/android/launcher3/model/PredictionUpdateTask.java index a2c680a682..ce02bd7384 100644 --- a/quickstep/src/com/android/launcher3/model/PredictionUpdateTask.java +++ b/quickstep/src/com/android/launcher3/model/PredictionUpdateTask.java @@ -35,7 +35,6 @@ import com.android.launcher3.LauncherModel.ModelUpdateTask; import com.android.launcher3.LauncherPrefs; import com.android.launcher3.icons.IconCache; import com.android.launcher3.model.BgDataModel.FixedContainerItems; -import com.android.launcher3.model.QuickstepModelDelegate.PredictorState; import com.android.launcher3.model.data.AppInfo; import com.android.launcher3.model.data.ItemInfo; import com.android.launcher3.model.data.WorkspaceItemInfo; diff --git a/quickstep/src/com/android/launcher3/model/QuickstepModelDelegate.java b/quickstep/src/com/android/launcher3/model/QuickstepModelDelegate.java index ba04b7d7ee..3028f9bf35 100644 --- a/quickstep/src/com/android/launcher3/model/QuickstepModelDelegate.java +++ b/quickstep/src/com/android/launcher3/model/QuickstepModelDelegate.java @@ -24,8 +24,6 @@ import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_HOTSEAT import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_ALL_APPS_PREDICTION; import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_WIDGETS_PREDICTION; import static com.android.launcher3.LauncherSettings.Favorites.DESKTOP_ICON_FLAG; -import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_APPLICATION; -import static com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT; import static com.android.launcher3.hybridhotseat.HotseatPredictionModel.convertDataModelToAppTargetBundle; import static com.android.launcher3.icons.cache.CacheLookupFlag.DEFAULT_LOOKUP_FLAG; import static com.android.launcher3.model.PredictionHelper.getAppTargetFromItemInfo; @@ -36,22 +34,14 @@ import static java.util.stream.Collectors.toCollection; import android.app.StatsManager; import android.app.prediction.AppPredictionContext; -import android.app.prediction.AppPredictionManager; -import android.app.prediction.AppPredictor; import android.app.prediction.AppTarget; import android.app.prediction.AppTargetEvent; import android.content.Context; -import android.content.Intent; -import android.content.pm.LauncherActivityInfo; -import android.content.pm.LauncherApps; -import android.content.pm.ShortcutInfo; import android.os.Bundle; -import android.os.UserHandle; import android.text.TextUtils; import android.util.Log; import android.util.StatsEvent; -import androidx.annotation.AnyThread; import androidx.annotation.CallSuper; import androidx.annotation.NonNull; import androidx.annotation.Nullable; @@ -60,36 +50,23 @@ import androidx.annotation.WorkerThread; import com.android.launcher3.ConstantItem; import com.android.launcher3.InvariantDeviceProfile; -import com.android.launcher3.LauncherAppState; import com.android.launcher3.LauncherPrefs; import com.android.launcher3.dagger.ApplicationContext; -import com.android.launcher3.icons.cache.CacheLookupFlag; import com.android.launcher3.logger.LauncherAtom; import com.android.launcher3.logging.InstanceId; import com.android.launcher3.logging.InstanceIdSequence; import com.android.launcher3.model.BgDataModel.FixedContainerItems; -import com.android.launcher3.model.data.AppInfo; import com.android.launcher3.model.data.CollectionInfo; import com.android.launcher3.model.data.ItemInfo; -import com.android.launcher3.model.data.WorkspaceItemInfo; import com.android.launcher3.pm.UserCache; -import com.android.launcher3.shortcuts.ShortcutKey; -import com.android.launcher3.util.ApiWrapper; -import com.android.launcher3.util.Executors; import com.android.launcher3.util.IntSparseArrayMap; -import com.android.launcher3.util.PackageManagerHelper; -import com.android.launcher3.util.PersistedItemArray; import com.android.quickstep.logging.SettingsChangeLogger; import com.android.quickstep.logging.StatsLogCompatManager; import com.android.quickstep.util.ContextualSearchStateManager; import com.android.systemui.shared.system.SysUiStatsLog; import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Map; import java.util.Objects; -import java.util.stream.IntStream; import javax.inject.Inject; import javax.inject.Named; @@ -109,17 +86,18 @@ public class QuickstepModelDelegate extends ModelDelegate { nonRestorableItem("LAST_SNAPSHOT_TIME_MILLIS", 0L, ENCRYPTED); @VisibleForTesting - final PredictorState mAllAppsState = new PredictorState( + final PredictorState mAllPredictionAppsState = new PredictorState( CONTAINER_ALL_APPS_PREDICTION, "all_apps_predictions", DEFAULT_LOOKUP_FLAG); @VisibleForTesting - final PredictorState mHotseatState = new PredictorState( + final PredictorState mHotseatPredictionState = new PredictorState( CONTAINER_HOTSEAT_PREDICTION, "hotseat_predictions", DESKTOP_ICON_FLAG); @VisibleForTesting final PredictorState mWidgetsRecommendationState = new PredictorState( CONTAINER_WIDGETS_PREDICTION, "widgets_prediction", DESKTOP_ICON_FLAG); private final InvariantDeviceProfile mIDP; - private final PackageManagerHelper mPmHelper; + private final UserCache mUserCache; + private final PredictedItemFactory.Factory mItemParserFactory; private final AppEventProducer mAppEventProducer; private final StatsManager mStatsManager; @@ -129,11 +107,15 @@ public class QuickstepModelDelegate extends ModelDelegate { @Inject public QuickstepModelDelegate(@ApplicationContext Context context, InvariantDeviceProfile idp, - PackageManagerHelper pmHelper, + UserCache userCache, + PredictedItemFactory.Factory itemParserFactory, @Nullable @Named("ICONS_DB") String dbFileName) { super(context); + + mIDP = idp; - mPmHelper = pmHelper; + mUserCache = userCache; + mItemParserFactory = itemParserFactory; mAppEventProducer = new AppEventProducer(context, this::onAppTargetEvent); StatsLogCompatManager.LOGS_CONSUMER.add(mAppEventProducer); @@ -146,74 +128,32 @@ public class QuickstepModelDelegate extends ModelDelegate { @CallSuper @Override - public void loadAndBindWorkspaceItems(@NonNull UserManagerState ums, - @NonNull BgDataModel.Callbacks[] callbacks, - @NonNull Map pinnedShortcuts) { - loadAndBindItems(ums, pinnedShortcuts, callbacks, mIDP.numDatabaseHotseatIcons, - mHotseatState); + public void loadAndBindWorkspaceItems() { + loadAndBindPredictedItems(mIDP.numDatabaseHotseatIcons, mHotseatPredictionState); } @CallSuper @Override - public void loadAndBindAllAppsItems(@NonNull UserManagerState ums, - @NonNull BgDataModel.Callbacks[] callbacks, - @NonNull Map pinnedShortcuts) { - loadAndBindItems(ums, pinnedShortcuts, callbacks, mIDP.numDatabaseAllAppsColumns, - mAllAppsState); + public void loadAndBindAllAppsItems() { + loadAndBindPredictedItems(mIDP.numDatabaseAllAppsColumns, mAllPredictionAppsState); } @WorkerThread - private void loadAndBindItems(@NonNull UserManagerState ums, - @NonNull Map pinnedShortcuts, - @NonNull BgDataModel.Callbacks[] callbacks, + private void loadAndBindPredictedItems( int numColumns, @NonNull PredictorState state) { - // TODO: Implement caching and preloading - - WorkspaceItemFactory factory = - new WorkspaceItemFactory(mContext, ums, mPmHelper, pinnedShortcuts, numColumns, - state.containerId, state.lookupFlag); + PredictedItemFactory parser = mItemParserFactory.newParser(numColumns, state); FixedContainerItems fci = new FixedContainerItems(state.containerId, - state.storage.read(mContext, factory, ums.allUsers::get)); + state.storage.read(mContext, parser, mUserCache::getUserForSerialNumber)); mDataModel.extraItems.put(state.containerId, fci); } @CallSuper @Override - public void loadAndBindOtherItems(@NonNull BgDataModel.Callbacks[] callbacks) { + public void loadAndBindOtherItems() { FixedContainerItems widgetPredictionFCI = new FixedContainerItems( mWidgetsRecommendationState.containerId, new ArrayList<>()); - // Widgets prediction isn't used frequently. And thus, it is not persisted on disk. mDataModel.extraItems.put(mWidgetsRecommendationState.containerId, widgetPredictionFCI); - - bindPredictionItems(callbacks, widgetPredictionFCI); - loadStringCache(mDataModel.stringCache); - } - - @AnyThread - private void bindPredictionItems(@NonNull BgDataModel.Callbacks[] callbacks, - @NonNull FixedContainerItems fci) { - Executors.MAIN_EXECUTOR.execute(() -> { - for (BgDataModel.Callbacks c : callbacks) { - c.bindExtraContainerItems(fci); - } - }); - } - - @Override - @WorkerThread - public void bindAllModelExtras(@NonNull BgDataModel.Callbacks[] callbacks) { - Iterable containerItems; - synchronized (mDataModel.extraItems) { - containerItems = mDataModel.extraItems.clone(); - } - Executors.MAIN_EXECUTOR.execute(() -> { - for (BgDataModel.Callbacks c : callbacks) { - for (FixedContainerItems fci : containerItems) { - c.bindExtraContainerItems(fci); - } - } - }); } public void markActive() { @@ -330,12 +270,8 @@ public class QuickstepModelDelegate extends ModelDelegate { @Override public void validateData() { super.validateData(); - if (mAllAppsState.predictor != null) { - mAllAppsState.predictor.requestPredictionUpdate(); - } - if (mWidgetsRecommendationState.predictor != null) { - mWidgetsRecommendationState.predictor.requestPredictionUpdate(); - } + mAllPredictionAppsState.requestPredictionUpdate(); + mWidgetsRecommendationState.requestPredictionUpdate(); } @WorkerThread @@ -355,8 +291,8 @@ public class QuickstepModelDelegate extends ModelDelegate { } private void destroyPredictors() { - mAllAppsState.destroyPredictor(); - mHotseatState.destroyPredictor(); + mAllPredictionAppsState.destroyPredictor(); + mHotseatPredictionState.destroyPredictor(); mWidgetsRecommendationState.destroyPredictor(); } @@ -366,78 +302,45 @@ public class QuickstepModelDelegate extends ModelDelegate { if (!mActive) { return; } - AppPredictionManager apm = mContext.getSystemService(AppPredictionManager.class); - if (apm == null) { - return; - } - registerPredictor(mAllAppsState, apm.createAppPredictionSession( + mAllPredictionAppsState.registerPredictor(mContext, new AppPredictionContext.Builder(mContext) - .setUiSurface("home") - .setPredictedTargetCount(mIDP.numDatabaseAllAppsColumns) - .build())); + .setUiSurface("home") + .setPredictedTargetCount(mIDP.numDatabaseAllAppsColumns) + .build(), + mModel, + PredictionUpdateTask::new); + // TODO: get bundle - registerHotseatPredictor(apm, mContext); + registerHotseatPredictor(mContext); - registerWidgetsPredictor(apm.createAppPredictionSession( + mWidgetsRecommendationState.registerPredictor(mContext, new AppPredictionContext.Builder(mContext) - .setUiSurface("widgets") - .setExtras(getBundleForWidgetsOnWorkspace(mContext, mDataModel)) - .setPredictedTargetCount(NUM_OF_RECOMMENDED_WIDGETS_PREDICATION) - .build())); + .setUiSurface("widgets") + .setExtras(getBundleForWidgetsOnWorkspace(mContext, mDataModel)) + .setPredictedTargetCount(NUM_OF_RECOMMENDED_WIDGETS_PREDICATION) + .build(), + mModel, + WidgetsPredictionUpdateTask::new); } @WorkerThread private void recreateHotseatPredictor() { - mHotseatState.destroyPredictor(); - if (!mActive) { - return; + mHotseatPredictionState.destroyPredictor(); + if (mActive) { + registerHotseatPredictor(mContext); } - AppPredictionManager apm = mContext.getSystemService(AppPredictionManager.class); - if (apm == null) { - return; - } - registerHotseatPredictor(apm, mContext); } - private void registerHotseatPredictor(AppPredictionManager apm, Context context) { - registerPredictor(mHotseatState, apm.createAppPredictionSession( + private void registerHotseatPredictor(Context context) { + mHotseatPredictionState.registerPredictor(context, new AppPredictionContext.Builder(context) - .setUiSurface("hotseat") - .setPredictedTargetCount(mIDP.numDatabaseHotseatIcons) - .setExtras(convertDataModelToAppTargetBundle(context, mDataModel)) - .build())); - } - - private void registerPredictor(PredictorState state, AppPredictor predictor) { - state.setTargets(Collections.emptyList()); - state.predictor = predictor; - state.predictor.registerPredictionUpdates( - MODEL_EXECUTOR, t -> handleUpdate(state, t)); - state.predictor.requestPredictionUpdate(); - } - - private void handleUpdate(PredictorState state, List targets) { - if (state.setTargets(targets)) { - // No diff, skip - return; - } - mModel.enqueueModelUpdateTask(new PredictionUpdateTask(state, targets)); - } - - private void registerWidgetsPredictor(AppPredictor predictor) { - mWidgetsRecommendationState.predictor = predictor; - mWidgetsRecommendationState.predictor.registerPredictionUpdates( - MODEL_EXECUTOR, targets -> { - if (mWidgetsRecommendationState.setTargets(targets)) { - // No diff, skip - return; - } - mModel.enqueueModelUpdateTask( - new WidgetsPredictionUpdateTask(mWidgetsRecommendationState, targets)); - }); - mWidgetsRecommendationState.predictor.requestPredictionUpdate(); + .setUiSurface("hotseat") + .setPredictedTargetCount(mIDP.numDatabaseHotseatIcons) + .setExtras(convertDataModelToAppTargetBundle(context, mDataModel)) + .build(), + mModel, PredictionUpdateTask::new); } @VisibleForTesting @@ -445,27 +348,26 @@ public class QuickstepModelDelegate extends ModelDelegate { PredictorState state; switch(client) { case CONTAINER_ALL_APPS_PREDICTION: - state = mAllAppsState; + state = mAllPredictionAppsState; break; case CONTAINER_WIDGETS_PREDICTION: state = mWidgetsRecommendationState; break; case CONTAINER_HOTSEAT_PREDICTION: default: - state = mHotseatState; + state = mHotseatPredictionState; break; } - if (state.predictor != null) { - state.predictor.notifyAppTargetEvent(event); - Log.d(TAG, "notifyAppTargetEvent action=" + event.getAction() - + " launchLocation=" + event.getLaunchLocation()); - if (state == mHotseatState - && (event.getAction() == AppTargetEvent.ACTION_PIN - || event.getAction() == AppTargetEvent.ACTION_UNPIN)) { - // Recreate hot seat predictor when we need to query for hot seat due to pin or - // unpin app icons. - recreateHotseatPredictor(); - } + + state.notifyAppTargetEvent(event); + Log.d(TAG, "notifyAppTargetEvent action=" + event.getAction() + + " launchLocation=" + event.getLaunchLocation()); + if (state == mHotseatPredictionState + && (event.getAction() == AppTargetEvent.ACTION_PIN + || event.getAction() == AppTargetEvent.ACTION_UNPIN)) { + // Recreate hot seat predictor when we need to query for hot seat due to pin or + // unpin app icons. + recreateHotseatPredictor(); } } @@ -485,133 +387,4 @@ public class QuickstepModelDelegate extends ModelDelegate { bundle.putParcelableArrayList(BUNDLE_KEY_ADDED_APP_WIDGETS, widgetEvents); return bundle; } - - static class PredictorState { - - public final int containerId; - public final PersistedItemArray storage; - public AppPredictor predictor; - public CacheLookupFlag lookupFlag; - - private List mLastTargets; - - PredictorState(int containerId, String storageName, CacheLookupFlag lookupFlag) { - this.containerId = containerId; - storage = new PersistedItemArray<>(storageName); - mLastTargets = Collections.emptyList(); - this.lookupFlag = lookupFlag; - } - - public void destroyPredictor() { - if (predictor != null) { - predictor.destroy(); - predictor = null; - } - } - - /** - * Sets the new targets and returns true if it was the same as before. - */ - boolean setTargets(List newTargets) { - List oldTargets = mLastTargets; - mLastTargets = newTargets; - - int size = oldTargets.size(); - return size == newTargets.size() && IntStream.range(0, size) - .allMatch(i -> areAppTargetsSame(oldTargets.get(i), newTargets.get(i))); - } - } - - /** - * Compares two targets for the properties which we care about - */ - private static boolean areAppTargetsSame(AppTarget t1, AppTarget t2) { - if (!Objects.equals(t1.getPackageName(), t2.getPackageName()) - || !Objects.equals(t1.getUser(), t2.getUser()) - || !Objects.equals(t1.getClassName(), t2.getClassName())) { - return false; - } - - ShortcutInfo s1 = t1.getShortcutInfo(); - ShortcutInfo s2 = t2.getShortcutInfo(); - if (s1 != null) { - if (s2 == null || !Objects.equals(s1.getId(), s2.getId())) { - return false; - } - } else if (s2 != null) { - return false; - } - return true; - } - - private static class WorkspaceItemFactory implements PersistedItemArray.ItemFactory { - - private final Context mContext; - private final UserManagerState mUMS; - private final PackageManagerHelper mPmHelper; - private final Map mPinnedShortcuts; - private final int mMaxCount; - private final int mContainer; - private final CacheLookupFlag mLookupFlag; - - private int mReadCount = 0; - - protected WorkspaceItemFactory( - Context context, UserManagerState ums, - PackageManagerHelper pmHelper, Map pinnedShortcuts, - int maxCount, int container, CacheLookupFlag lookupFlag) { - mContext = context; - mUMS = ums; - mPmHelper = pmHelper; - mPinnedShortcuts = pinnedShortcuts; - mMaxCount = maxCount; - mContainer = container; - mLookupFlag = lookupFlag; - } - - @Nullable - @Override - public ItemInfo createInfo(int itemType, UserHandle user, Intent intent) { - if (mReadCount >= mMaxCount) { - return null; - } - switch (itemType) { - case ITEM_TYPE_APPLICATION: { - LauncherActivityInfo lai = mContext - .getSystemService(LauncherApps.class) - .resolveActivity(intent, user); - if (lai == null) { - return null; - } - AppInfo info = new AppInfo( - lai, - UserCache.INSTANCE.get(mContext).getUserInfo(user), - ApiWrapper.INSTANCE.get(mContext), - mPmHelper, - mUMS.isUserQuiet(user)); - info.container = mContainer; - LauncherAppState.getInstance(mContext).getIconCache() - .getTitleAndIcon(info, lai, mLookupFlag); - mReadCount++; - return info.makeWorkspaceItem(mContext); - } - case ITEM_TYPE_DEEP_SHORTCUT: { - ShortcutKey key = ShortcutKey.fromIntent(intent, user); - if (key == null) { - return null; - } - ShortcutInfo si = mPinnedShortcuts.get(key); - if (si == null) { - return null; - } - WorkspaceItemInfo wii = new WorkspaceItemInfo(si, mContext); - wii.container = mContainer; - LauncherAppState.getInstance(mContext).getIconCache().getShortcutIcon(wii, si); - mReadCount++; - return wii; - } - } - return null; - } - } } diff --git a/quickstep/src/com/android/launcher3/model/WidgetsPredictionUpdateTask.java b/quickstep/src/com/android/launcher3/model/WidgetsPredictionUpdateTask.java index da55b40b19..fb3e9d477f 100644 --- a/quickstep/src/com/android/launcher3/model/WidgetsPredictionUpdateTask.java +++ b/quickstep/src/com/android/launcher3/model/WidgetsPredictionUpdateTask.java @@ -32,7 +32,6 @@ import androidx.annotation.NonNull; import com.android.launcher3.LauncherModel.ModelUpdateTask; import com.android.launcher3.R; import com.android.launcher3.model.BgDataModel.FixedContainerItems; -import com.android.launcher3.model.QuickstepModelDelegate.PredictorState; import com.android.launcher3.model.data.ItemInfo; import com.android.launcher3.util.ComponentKey; import com.android.launcher3.widget.PendingAddWidgetInfo; diff --git a/quickstep/tests/multivalentTests/src/com/android/launcher3/model/QuickstepModelDelegateTest.kt b/quickstep/tests/multivalentTests/src/com/android/launcher3/model/QuickstepModelDelegateTest.kt index 574effa723..a2b0338ab4 100644 --- a/quickstep/tests/multivalentTests/src/com/android/launcher3/model/QuickstepModelDelegateTest.kt +++ b/quickstep/tests/multivalentTests/src/com/android/launcher3/model/QuickstepModelDelegateTest.kt @@ -51,6 +51,7 @@ class QuickstepModelDelegateTest { @Mock private lateinit var allAppsPredictor: AppPredictor @Mock private lateinit var hotseatPredictor: AppPredictor @Mock private lateinit var widgetRecommendationPredictor: AppPredictor + @Mock private lateinit var itemParserFactory: PredictedItemFactory.Factory @Before fun setUp() { @@ -59,11 +60,12 @@ class QuickstepModelDelegateTest { QuickstepModelDelegate( context, context.appComponent.idp, - context.appComponent.packageManagerHelper, + context.appComponent.userCache, + itemParserFactory, "", /* dbFileName */ ) - underTest.mAllAppsState.predictor = allAppsPredictor - underTest.mHotseatState.predictor = hotseatPredictor + underTest.mAllPredictionAppsState.predictor = allAppsPredictor + underTest.mHotseatPredictionState.predictor = hotseatPredictor underTest.mWidgetsRecommendationState.predictor = widgetRecommendationPredictor underTest.mModel = LauncherAppState.getInstance(context).model underTest.mDataModel = @@ -113,31 +115,31 @@ class QuickstepModelDelegateTest { @Test fun hotseatActionPin_recreateHotSeat() { - assertSame(underTest.mHotseatState.predictor, hotseatPredictor) + assertSame(underTest.mHotseatPredictionState.predictor, hotseatPredictor) val appTargetEvent = AppTargetEvent.Builder(target, AppTargetEvent.ACTION_PIN).build() underTest.markActive() underTest.onAppTargetEvent(appTargetEvent, CONTAINER_HOTSEAT_PREDICTION) verify(hotseatPredictor).destroy() - assertNotSame(underTest.mHotseatState.predictor, hotseatPredictor) + assertNotSame(underTest.mHotseatPredictionState.predictor, hotseatPredictor) } @Test fun hotseatActionUnpin_recreateHotSeat() { - assertSame(underTest.mHotseatState.predictor, hotseatPredictor) + assertSame(underTest.mHotseatPredictionState.predictor, hotseatPredictor) underTest.markActive() val appTargetEvent = AppTargetEvent.Builder(target, AppTargetEvent.ACTION_UNPIN).build() underTest.onAppTargetEvent(appTargetEvent, CONTAINER_HOTSEAT_PREDICTION) verify(hotseatPredictor).destroy() - assertNotSame(underTest.mHotseatState.predictor, hotseatPredictor) + assertNotSame(underTest.mHotseatPredictionState.predictor, hotseatPredictor) } @Test fun container_actionPin_notRecreateHotSeat() { - assertSame(underTest.mHotseatState.predictor, hotseatPredictor) + assertSame(underTest.mHotseatPredictionState.predictor, hotseatPredictor) val appTargetEvent = AppTargetEvent.Builder(target, AppTargetEvent.ACTION_UNPIN).build() underTest.markActive() @@ -145,6 +147,6 @@ class QuickstepModelDelegateTest { verify(allAppsPredictor, never()).destroy() verify(hotseatPredictor, never()).destroy() - assertSame(underTest.mHotseatState.predictor, hotseatPredictor) + assertSame(underTest.mHotseatPredictionState.predictor, hotseatPredictor) } } diff --git a/quickstep/tests/src/com/android/launcher3/model/WidgetsPredicationUpdateTaskTest.java b/quickstep/tests/src/com/android/launcher3/model/WidgetsPredicationUpdateTaskTest.java index 26e08f9f19..4efa4ea9b8 100644 --- a/quickstep/tests/src/com/android/launcher3/model/WidgetsPredicationUpdateTaskTest.java +++ b/quickstep/tests/src/com/android/launcher3/model/WidgetsPredicationUpdateTaskTest.java @@ -55,7 +55,6 @@ import com.android.launcher3.Flags; import com.android.launcher3.LauncherAppState; import com.android.launcher3.LauncherModel; import com.android.launcher3.model.BgDataModel.FixedContainerItems; -import com.android.launcher3.model.QuickstepModelDelegate.PredictorState; import com.android.launcher3.util.LauncherLayoutBuilder; import com.android.launcher3.util.ModelTestExtensions; import com.android.launcher3.util.SandboxApplication; diff --git a/src/com/android/launcher3/LauncherModel.kt b/src/com/android/launcher3/LauncherModel.kt index b3e99050c9..a3331b945a 100644 --- a/src/com/android/launcher3/LauncherModel.kt +++ b/src/com/android/launcher3/LauncherModel.kt @@ -40,7 +40,6 @@ import com.android.launcher3.model.ModelLauncherCallbacks import com.android.launcher3.model.ModelTaskController import com.android.launcher3.model.ModelWriter import com.android.launcher3.model.PackageUpdatedTask -import com.android.launcher3.model.ReloadStringCacheTask import com.android.launcher3.model.ShortcutsChangedTask import com.android.launcher3.model.UserLockStateChangedTask import com.android.launcher3.model.UserManagerState @@ -157,10 +156,6 @@ constructor( MODEL_EXECUTOR.execute { modelDelegate.destroy() } } - fun reloadStringCache() { - enqueueModelUpdateTask(ReloadStringCacheTask(this.modelDelegate)) - } - /** * Called then there use a user event * diff --git a/src/com/android/launcher3/model/LoaderTask.java b/src/com/android/launcher3/model/LoaderTask.java index 5067a8fbbe..d01d53e1d5 100644 --- a/src/com/android/launcher3/model/LoaderTask.java +++ b/src/com/android/launcher3/model/LoaderTask.java @@ -509,11 +509,10 @@ public class LoaderTask implements Runnable { IOUtils.closeSilently(c); } - mModelDelegate.loadAndBindWorkspaceItems(mUserManagerState, - mLauncherBinder.mCallbacksList, mShortcutKeyToPinnedShortcuts); - mModelDelegate.loadAndBindAllAppsItems(mUserManagerState, - mLauncherBinder.mCallbacksList, mShortcutKeyToPinnedShortcuts); - mModelDelegate.loadAndBindOtherItems(mLauncherBinder.mCallbacksList); + mModelDelegate.loadAndBindWorkspaceItems(); + mModelDelegate.loadAndBindAllAppsItems(); + mModelDelegate.loadAndBindOtherItems(); + mBgDataModel.stringCache.loadStrings(mContext); mModelDelegate.markActive(); // Break early if we've stopped loading diff --git a/src/com/android/launcher3/model/ModelDelegate.java b/src/com/android/launcher3/model/ModelDelegate.java index 0ad8c1ea8a..d845b3b836 100644 --- a/src/com/android/launcher3/model/ModelDelegate.java +++ b/src/com/android/launcher3/model/ModelDelegate.java @@ -18,16 +18,12 @@ package com.android.launcher3.model; import static com.android.launcher3.util.PackageManagerHelper.hasShortcutsPermission; import android.content.Context; -import android.content.pm.ShortcutInfo; import androidx.annotation.NonNull; import androidx.annotation.WorkerThread; import com.android.launcher3.LauncherModel; import com.android.launcher3.dagger.ApplicationContext; -import com.android.launcher3.shortcuts.ShortcutKey; - -import java.util.Map; import javax.inject.Inject; @@ -65,33 +61,19 @@ public class ModelDelegate { /** Load workspace items (for example, those in the hot seat) if any in the data model */ @WorkerThread - public void loadAndBindWorkspaceItems(@NonNull UserManagerState ums, - @NonNull BgDataModel.Callbacks[] callbacks, - @NonNull Map pinnedShortcuts) { } + public void loadAndBindWorkspaceItems() { } /** Load all apps items if any in the data model */ @WorkerThread - public void loadAndBindAllAppsItems(@NonNull UserManagerState ums, - @NonNull BgDataModel.Callbacks[] callbacks, - @NonNull Map pinnedShortcuts) { } + public void loadAndBindAllAppsItems() { } /** Load other items like widget recommendations if any in the data model */ @WorkerThread - public void loadAndBindOtherItems(@NonNull BgDataModel.Callbacks[] callbacks) { } - - /** binds everything not bound by launcherBinder */ - @WorkerThread - public void bindAllModelExtras(@NonNull BgDataModel.Callbacks[] callbacks) { } + public void loadAndBindOtherItems() { } /** Marks the ModelDelegate as active */ public void markActive() { } - /** Load String cache */ - @WorkerThread - public void loadStringCache(@NonNull StringCache cache) { - cache.loadStrings(mContext); - } - /** * Called during loader after workspace loading is complete */ diff --git a/src/com/android/launcher3/model/ModelInitializer.kt b/src/com/android/launcher3/model/ModelInitializer.kt index ebbcfeab74..4e4a6febd4 100644 --- a/src/com/android/launcher3/model/ModelInitializer.kt +++ b/src/com/android/launcher3/model/ModelInitializer.kt @@ -99,7 +99,9 @@ constructor( // Device profile policy changes val dpUpdateReceiver = - SimpleBroadcastReceiver(context, UI_HELPER_EXECUTOR) { model.reloadStringCache() } + SimpleBroadcastReceiver(context, UI_HELPER_EXECUTOR) { + model.enqueueModelUpdateTask(ReloadStringCacheTask()) + } dpUpdateReceiver.register(ACTION_DEVICE_POLICY_RESOURCE_UPDATED) lifeCycle.addCloseable { dpUpdateReceiver.unregisterReceiverSafely() } diff --git a/src/com/android/launcher3/model/ReloadStringCacheTask.java b/src/com/android/launcher3/model/ReloadStringCacheTask.java index 3d974d6569..0dd5bd86bf 100644 --- a/src/com/android/launcher3/model/ReloadStringCacheTask.java +++ b/src/com/android/launcher3/model/ReloadStringCacheTask.java @@ -25,18 +25,11 @@ import com.android.launcher3.LauncherModel.ModelUpdateTask; */ public class ReloadStringCacheTask implements ModelUpdateTask { - @NonNull - private ModelDelegate mModelDelegate; - - public ReloadStringCacheTask(@NonNull final ModelDelegate modelDelegate) { - mModelDelegate = modelDelegate; - } - @Override public void execute(@NonNull ModelTaskController taskController, @NonNull BgDataModel dataModel, @NonNull AllAppsList apps) { synchronized (dataModel) { - mModelDelegate.loadStringCache(dataModel.stringCache); + dataModel.stringCache.loadStrings(taskController.getContext()); StringCache cloneSC = dataModel.stringCache.clone(); taskController.scheduleCallbackTask(c -> c.bindStringCache(cloneSC)); } diff --git a/tests/src/com/android/launcher3/model/LoaderTaskTest.kt b/tests/src/com/android/launcher3/model/LoaderTaskTest.kt index f8516cc04b..8002305fd2 100644 --- a/tests/src/com/android/launcher3/model/LoaderTaskTest.kt +++ b/tests/src/com/android/launcher3/model/LoaderTaskTest.kt @@ -218,12 +218,12 @@ class LoaderTaskTest { verify(launcherBinder).bindWorkspace(true, false) verify(modelDelegate).workspaceLoadComplete() - verify(modelDelegate).loadAndBindAllAppsItems(any(), anyOrNull(), any()) + verify(modelDelegate).loadAndBindAllAppsItems() verify(launcherBinder).bindAllApps() verify(iconCacheUpdateHandler, times(4)).updateIcons(any(), any>(), any()) verify(launcherBinder).bindDeepShortcuts() verify(launcherBinder).bindWidgets() - verify(modelDelegate).loadAndBindOtherItems(anyOrNull()) + verify(modelDelegate).loadAndBindOtherItems() verify(iconCacheUpdateHandler).finish() verify(modelDelegate).modelLoadComplete() verify(transaction).commit()