quickstep/src/com/android/quickstep/RecentsModel.java - platform/packages/apps/Launcher3 - Git at Google

 /*
  * Copyright (C) 2018 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.quickstep;

 import static com.android.quickstep.TaskUtils.checkCurrentOrManagedUserId;

 import android.annotation.TargetApi;
 import android.app.ActivityManager;
 import android.content.ComponentCallbacks2;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.pm.ActivityInfo;
 import android.content.res.Resources;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Looper;
 import android.os.RemoteException;
 import android.os.UserHandle;
 import android.support.annotation.WorkerThread;
 import android.util.Log;
 import android.util.LruCache;
 import android.util.SparseArray;
 import android.view.accessibility.AccessibilityManager;

 import com.android.launcher3.MainThreadExecutor;
 import com.android.launcher3.R;
 import com.android.launcher3.util.Preconditions;
 import com.android.systemui.shared.recents.ISystemUiProxy;
 import com.android.systemui.shared.recents.model.IconLoader;
 import com.android.systemui.shared.recents.model.RecentsTaskLoadPlan;
 import com.android.systemui.shared.recents.model.RecentsTaskLoadPlan.PreloadOptions;
 import com.android.systemui.shared.recents.model.RecentsTaskLoader;
 import com.android.systemui.shared.recents.model.TaskKeyLruCache;
 import com.android.systemui.shared.system.ActivityManagerWrapper;
 import com.android.systemui.shared.system.BackgroundExecutor;
 import com.android.systemui.shared.system.TaskStackChangeListener;

 import java.util.ArrayList;
 import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;

 /**
  * Singleton class to load and manage recents model.
  */
 @TargetApi(Build.VERSION_CODES.O)
 public class RecentsModel extends TaskStackChangeListener {
     // We do not need any synchronization for this variable as its only written on UI thread.
     private static RecentsModel INSTANCE;

     public static RecentsModel getInstance(final Context context) {
         if (INSTANCE == null) {
             if (Looper.myLooper() == Looper.getMainLooper()) {
                 INSTANCE = new RecentsModel(context.getApplicationContext());
             } else {
                 try {
                     return new MainThreadExecutor().submit(
                             () -> RecentsModel.getInstance(context)).get();
                 } catch (InterruptedException|ExecutionException e) {
                     throw new RuntimeException(e);
                 }
             }
         }
         return INSTANCE;
     }

     private final SparseArray<Bundle> mCachedAssistData = new SparseArray<>(1);
     private final ArrayList<AssistDataListener> mAssistDataListeners = new ArrayList<>();

     private final Context mContext;
     private final RecentsTaskLoader mRecentsTaskLoader;
     private final MainThreadExecutor mMainThreadExecutor;

     private RecentsTaskLoadPlan mLastLoadPlan;
     private int mLastLoadPlanId;
     private int mTaskChangeId;
     private ISystemUiProxy mSystemUiProxy;
     private boolean mClearAssistCacheOnStackChange = true;
     private final boolean mIsLowRamDevice;
     private boolean mPreloadTasksInBackground;
     private final AccessibilityManager mAccessibilityManager;

     private RecentsModel(Context context) {
         mContext = context;

         ActivityManager activityManager =
                 (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
         mIsLowRamDevice = activityManager.isLowRamDevice();
         mMainThreadExecutor = new MainThreadExecutor();

         Resources res = context.getResources();
         mRecentsTaskLoader = new RecentsTaskLoader(mContext,
                 res.getInteger(R.integer.config_recentsMaxThumbnailCacheSize),
                 res.getInteger(R.integer.config_recentsMaxIconCacheSize), 0) {

             @Override
             protected IconLoader createNewIconLoader(Context context,
                     TaskKeyLruCache<Drawable> iconCache,
                     LruCache<ComponentName, ActivityInfo> activityInfoCache) {
                 return new NormalizedIconLoader(context, iconCache, activityInfoCache);
             }
         };
         mRecentsTaskLoader.startLoader(mContext);
         ActivityManagerWrapper.getInstance().registerTaskStackListener(this);

         mTaskChangeId = 1;
         loadTasks(-1, null);
         mAccessibilityManager = context.getSystemService(AccessibilityManager.class);
     }

     public RecentsTaskLoader getRecentsTaskLoader() {
         return mRecentsTaskLoader;
     }

     /**
      * Preloads the task plan
      * @param taskId The running task id or -1
      * @param callback The callback to receive the task plan once its complete or null. This is
      *                always called on the UI thread.
      * @return the request id associated with this call.
      */
     public int loadTasks(int taskId, Consumer<RecentsTaskLoadPlan> callback) {
         final int requestId = mTaskChangeId;

         // Fail fast if nothing has changed.
         if (mLastLoadPlanId == mTaskChangeId) {
             if (callback != null) {
                 final RecentsTaskLoadPlan plan = mLastLoadPlan;
                 mMainThreadExecutor.execute(() -> callback.accept(plan));
             }
             return requestId;
         }

         BackgroundExecutor.get().submit(() -> {
             // Preload the plan
             RecentsTaskLoadPlan loadPlan = new RecentsTaskLoadPlan(mContext);
             PreloadOptions opts = new PreloadOptions();
             opts.loadTitles = mAccessibilityManager.isEnabled();
             loadPlan.preloadPlan(opts, mRecentsTaskLoader, taskId, UserHandle.myUserId());
             // Set the load plan on UI thread
             mMainThreadExecutor.execute(() -> {
                 mLastLoadPlan = loadPlan;
                 mLastLoadPlanId = requestId;

                 if (callback != null) {
                     callback.accept(loadPlan);
                 }
             });
         });
         return requestId;
     }

     public void setPreloadTasksInBackground(boolean preloadTasksInBackground) {
         mPreloadTasksInBackground = preloadTasksInBackground && !mIsLowRamDevice;
     }

     @Override
     public void onActivityPinned(String packageName, int userId, int taskId, int stackId) {
         mTaskChangeId++;
     }

     @Override
     public void onActivityUnpinned() {
         mTaskChangeId++;
     }

     @Override
     public void onTaskStackChanged() {
         mTaskChangeId++;

         Preconditions.assertUIThread();
         if (mClearAssistCacheOnStackChange) {
             mCachedAssistData.clear();
         } else {
             mClearAssistCacheOnStackChange = true;
         }
     }

     @Override
     public void onTaskStackChangedBackground() {
         int userId = UserHandle.myUserId();
         if (!mPreloadTasksInBackground || !checkCurrentOrManagedUserId(userId, mContext)) {
             // TODO: Only register this for the current user
             return;
         }

         // Preload a fixed number of task icons/thumbnails in the background
         ActivityManager.RunningTaskInfo runningTaskInfo =
                 ActivityManagerWrapper.getInstance().getRunningTask();
         RecentsTaskLoadPlan plan = new RecentsTaskLoadPlan(mContext);
         RecentsTaskLoadPlan.Options launchOpts = new RecentsTaskLoadPlan.Options();
         launchOpts.runningTaskId = runningTaskInfo != null ? runningTaskInfo.id : -1;
         launchOpts.numVisibleTasks = 2;
         launchOpts.numVisibleTaskThumbnails = 2;
         launchOpts.onlyLoadForCache = true;
         launchOpts.onlyLoadPausedActivities = true;
         launchOpts.loadThumbnails = true;
         PreloadOptions preloadOpts = new PreloadOptions();
         preloadOpts.loadTitles = mAccessibilityManager.isEnabled();
         plan.preloadPlan(preloadOpts, mRecentsTaskLoader, -1, userId);
         mRecentsTaskLoader.loadTasks(plan, launchOpts);
     }

     public boolean isLoadPlanValid(int resultId) {
         return mTaskChangeId == resultId;
     }

     public RecentsTaskLoadPlan getLastLoadPlan() {
         return mLastLoadPlan;
     }

     public void setSystemUiProxy(ISystemUiProxy systemUiProxy) {
         mSystemUiProxy = systemUiProxy;
     }

     public ISystemUiProxy getSystemUiProxy() {
         return mSystemUiProxy;
     }

     public void onStart() {
         mRecentsTaskLoader.startLoader(mContext);
         mRecentsTaskLoader.getHighResThumbnailLoader().setVisible(true);
     }

     public void onTrimMemory(int level) {
         if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
             // We already stop the loader in UI_HIDDEN, so stop the high res loader as well
             mRecentsTaskLoader.getHighResThumbnailLoader().setVisible(false);
         }
         mRecentsTaskLoader.onTrimMemory(level);
     }

     public void onOverviewShown(boolean fromHome, String tag) {
         if (mSystemUiProxy == null) {
             return;
         }
         try {
             mSystemUiProxy.onOverviewShown(fromHome);
         } catch (RemoteException e) {
             Log.w(tag,
                     "Failed to notify SysUI of overview shown from " + (fromHome ? "home" : "app")
                             + ": ", e);
         }
     }

     @WorkerThread
     public void preloadAssistData(int taskId, Bundle data) {
         mMainThreadExecutor.execute(() -> {
             mCachedAssistData.put(taskId, data);
             // We expect a stack change callback after the assist data is set. So ignore the
             // very next stack change callback.
             mClearAssistCacheOnStackChange = false;

             int count = mAssistDataListeners.size();
             for (int i = 0; i < count; i++) {
                 mAssistDataListeners.get(i).onAssistDataReceived(taskId);
             }
         });
     }

     public Bundle getAssistData(int taskId) {
         Preconditions.assertUIThread();
         return mCachedAssistData.get(taskId);
     }

     public void addAssistDataListener(AssistDataListener listener) {
         mAssistDataListeners.add(listener);
     }

     public void removeAssistDataListener(AssistDataListener listener) {
         mAssistDataListeners.remove(listener);
     }

     /**
      * Callback for receiving assist data
      */
     public interface AssistDataListener {

         void onAssistDataReceived(int taskId);
     }
 }
	/*
	* Copyright (C) 2018 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.quickstep;

	import static com.android.quickstep.TaskUtils.checkCurrentOrManagedUserId;

	import android.annotation.TargetApi;
	import android.app.ActivityManager;
	import android.content.ComponentCallbacks2;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.pm.ActivityInfo;
	import android.content.res.Resources;
	import android.graphics.drawable.Drawable;
	import android.os.Build;
	import android.os.Bundle;
	import android.os.Looper;
	import android.os.RemoteException;
	import android.os.UserHandle;
	import android.support.annotation.WorkerThread;
	import android.util.Log;
	import android.util.LruCache;
	import android.util.SparseArray;
	import android.view.accessibility.AccessibilityManager;

	import com.android.launcher3.MainThreadExecutor;
	import com.android.launcher3.R;
	import com.android.launcher3.util.Preconditions;
	import com.android.systemui.shared.recents.ISystemUiProxy;
	import com.android.systemui.shared.recents.model.IconLoader;
	import com.android.systemui.shared.recents.model.RecentsTaskLoadPlan;
	import com.android.systemui.shared.recents.model.RecentsTaskLoadPlan.PreloadOptions;
	import com.android.systemui.shared.recents.model.RecentsTaskLoader;
	import com.android.systemui.shared.recents.model.TaskKeyLruCache;
	import com.android.systemui.shared.system.ActivityManagerWrapper;
	import com.android.systemui.shared.system.BackgroundExecutor;
	import com.android.systemui.shared.system.TaskStackChangeListener;

	import java.util.ArrayList;
	import java.util.concurrent.ExecutionException;
	import java.util.function.Consumer;

	/**
	* Singleton class to load and manage recents model.
	*/
	@TargetApi(Build.VERSION_CODES.O)
	public class RecentsModel extends TaskStackChangeListener {
	// We do not need any synchronization for this variable as its only written on UI thread.
	private static RecentsModel INSTANCE;

	public static RecentsModel getInstance(final Context context) {
	if (INSTANCE == null) {
	if (Looper.myLooper() == Looper.getMainLooper()) {
	INSTANCE = new RecentsModel(context.getApplicationContext());
	} else {
	try {
	return new MainThreadExecutor().submit(
	() -> RecentsModel.getInstance(context)).get();
	} catch (InterruptedException\|ExecutionException e) {
	throw new RuntimeException(e);
	}
	}
	}
	return INSTANCE;
	}

	private final SparseArray<Bundle> mCachedAssistData = new SparseArray<>(1);
	private final ArrayList<AssistDataListener> mAssistDataListeners = new ArrayList<>();

	private final Context mContext;
	private final RecentsTaskLoader mRecentsTaskLoader;
	private final MainThreadExecutor mMainThreadExecutor;

	private RecentsTaskLoadPlan mLastLoadPlan;
	private int mLastLoadPlanId;
	private int mTaskChangeId;
	private ISystemUiProxy mSystemUiProxy;
	private boolean mClearAssistCacheOnStackChange = true;
	private final boolean mIsLowRamDevice;
	private boolean mPreloadTasksInBackground;
	private final AccessibilityManager mAccessibilityManager;

	private RecentsModel(Context context) {
	mContext = context;

	ActivityManager activityManager =
	(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
	mIsLowRamDevice = activityManager.isLowRamDevice();
	mMainThreadExecutor = new MainThreadExecutor();

	Resources res = context.getResources();
	mRecentsTaskLoader = new RecentsTaskLoader(mContext,
	res.getInteger(R.integer.config_recentsMaxThumbnailCacheSize),
	res.getInteger(R.integer.config_recentsMaxIconCacheSize), 0) {

	@Override
	protected IconLoader createNewIconLoader(Context context,
	TaskKeyLruCache<Drawable> iconCache,
	LruCache<ComponentName, ActivityInfo> activityInfoCache) {
	return new NormalizedIconLoader(context, iconCache, activityInfoCache);
	}
	};
	mRecentsTaskLoader.startLoader(mContext);
	ActivityManagerWrapper.getInstance().registerTaskStackListener(this);

	mTaskChangeId = 1;
	loadTasks(-1, null);
	mAccessibilityManager = context.getSystemService(AccessibilityManager.class);
	}

	public RecentsTaskLoader getRecentsTaskLoader() {
	return mRecentsTaskLoader;
	}

	/**
	* Preloads the task plan
	* @param taskId The running task id or -1
	* @param callback The callback to receive the task plan once its complete or null. This is
	* always called on the UI thread.
	* @return the request id associated with this call.
	*/
	public int loadTasks(int taskId, Consumer<RecentsTaskLoadPlan> callback) {
	final int requestId = mTaskChangeId;

	// Fail fast if nothing has changed.
	if (mLastLoadPlanId == mTaskChangeId) {
	if (callback != null) {
	final RecentsTaskLoadPlan plan = mLastLoadPlan;
	mMainThreadExecutor.execute(() -> callback.accept(plan));
	}
	return requestId;
	}

	BackgroundExecutor.get().submit(() -> {
	// Preload the plan
	RecentsTaskLoadPlan loadPlan = new RecentsTaskLoadPlan(mContext);
	PreloadOptions opts = new PreloadOptions();
	opts.loadTitles = mAccessibilityManager.isEnabled();
	loadPlan.preloadPlan(opts, mRecentsTaskLoader, taskId, UserHandle.myUserId());
	// Set the load plan on UI thread
	mMainThreadExecutor.execute(() -> {
	mLastLoadPlan = loadPlan;
	mLastLoadPlanId = requestId;

	if (callback != null) {
	callback.accept(loadPlan);
	}
	});
	});
	return requestId;
	}

	public void setPreloadTasksInBackground(boolean preloadTasksInBackground) {
	mPreloadTasksInBackground = preloadTasksInBackground && !mIsLowRamDevice;
	}

	@Override
	public void onActivityPinned(String packageName, int userId, int taskId, int stackId) {
	mTaskChangeId++;
	}

	@Override
	public void onActivityUnpinned() {
	mTaskChangeId++;
	}

	@Override
	public void onTaskStackChanged() {
	mTaskChangeId++;

	Preconditions.assertUIThread();
	if (mClearAssistCacheOnStackChange) {
	mCachedAssistData.clear();
	} else {
	mClearAssistCacheOnStackChange = true;
	}
	}

	@Override
	public void onTaskStackChangedBackground() {
	int userId = UserHandle.myUserId();
	if (!mPreloadTasksInBackground \|\| !checkCurrentOrManagedUserId(userId, mContext)) {
	// TODO: Only register this for the current user
	return;
	}

	// Preload a fixed number of task icons/thumbnails in the background
	ActivityManager.RunningTaskInfo runningTaskInfo =
	ActivityManagerWrapper.getInstance().getRunningTask();
	RecentsTaskLoadPlan plan = new RecentsTaskLoadPlan(mContext);
	RecentsTaskLoadPlan.Options launchOpts = new RecentsTaskLoadPlan.Options();
	launchOpts.runningTaskId = runningTaskInfo != null ? runningTaskInfo.id : -1;
	launchOpts.numVisibleTasks = 2;
	launchOpts.numVisibleTaskThumbnails = 2;
	launchOpts.onlyLoadForCache = true;
	launchOpts.onlyLoadPausedActivities = true;
	launchOpts.loadThumbnails = true;
	PreloadOptions preloadOpts = new PreloadOptions();
	preloadOpts.loadTitles = mAccessibilityManager.isEnabled();
	plan.preloadPlan(preloadOpts, mRecentsTaskLoader, -1, userId);
	mRecentsTaskLoader.loadTasks(plan, launchOpts);
	}

	public boolean isLoadPlanValid(int resultId) {
	return mTaskChangeId == resultId;
	}

	public RecentsTaskLoadPlan getLastLoadPlan() {
	return mLastLoadPlan;
	}

	public void setSystemUiProxy(ISystemUiProxy systemUiProxy) {
	mSystemUiProxy = systemUiProxy;
	}

	public ISystemUiProxy getSystemUiProxy() {
	return mSystemUiProxy;
	}

	public void onStart() {
	mRecentsTaskLoader.startLoader(mContext);
	mRecentsTaskLoader.getHighResThumbnailLoader().setVisible(true);
	}

	public void onTrimMemory(int level) {
	if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
	// We already stop the loader in UI_HIDDEN, so stop the high res loader as well
	mRecentsTaskLoader.getHighResThumbnailLoader().setVisible(false);
	}
	mRecentsTaskLoader.onTrimMemory(level);
	}

	public void onOverviewShown(boolean fromHome, String tag) {
	if (mSystemUiProxy == null) {
	return;
	}
	try {
	mSystemUiProxy.onOverviewShown(fromHome);
	} catch (RemoteException e) {
	Log.w(tag,
	"Failed to notify SysUI of overview shown from " + (fromHome ? "home" : "app")
	+ ": ", e);
	}
	}

	@WorkerThread
	public void preloadAssistData(int taskId, Bundle data) {
	mMainThreadExecutor.execute(() -> {
	mCachedAssistData.put(taskId, data);
	// We expect a stack change callback after the assist data is set. So ignore the
	// very next stack change callback.
	mClearAssistCacheOnStackChange = false;

	int count = mAssistDataListeners.size();
	for (int i = 0; i < count; i++) {
	mAssistDataListeners.get(i).onAssistDataReceived(taskId);
	}
	});
	}

	public Bundle getAssistData(int taskId) {
	Preconditions.assertUIThread();
	return mCachedAssistData.get(taskId);
	}

	public void addAssistDataListener(AssistDataListener listener) {
	mAssistDataListeners.add(listener);
	}

	public void removeAssistDataListener(AssistDataListener listener) {
	mAssistDataListeners.remove(listener);
	}

	/**
	* Callback for receiving assist data
	*/
	public interface AssistDataListener {

	void onAssistDataReceived(int taskId);
	}
	}