packages/SystemUI/src/com/android/systemui/recents/misc/SystemServicesProxy.java

   1 /*
   2  * Copyright (C) 2014 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.systemui.recents.misc;
  18
  19 import static android.app.ActivityManager.StackId.DOCKED_STACK_ID;
  20 import static android.app.ActivityManager.StackId.FREEFORM_WORKSPACE_STACK_ID;
  21 import static android.app.ActivityManager.StackId.FULLSCREEN_WORKSPACE_STACK_ID;
  22 import static android.app.ActivityManager.StackId.HOME_STACK_ID;
  23 import static android.app.ActivityManager.StackId.PINNED_STACK_ID;
  24 import static android.provider.Settings.Global.DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT;
  25
  26 import android.app.ActivityManager;
  27 import android.app.ActivityManagerNative;
  28 import android.app.ActivityOptions;
  29 import android.app.AppGlobals;
  30 import android.app.IActivityManager;
  31 import android.app.ITaskStackListener;
  32 import android.app.UiModeManager;
  33 import android.content.ComponentName;
  34 import android.content.ContentResolver;
  35 import android.content.Context;
  36 import android.content.Intent;
  37 import android.content.pm.ActivityInfo;
  38 import android.content.pm.ApplicationInfo;
  39 import android.content.pm.IPackageManager;
  40 import android.content.pm.PackageManager;
  41 import android.content.pm.ResolveInfo;
  42 import android.content.res.Configuration;
  43 import android.content.res.Resources;
  44 import android.graphics.Bitmap;
  45 import android.graphics.BitmapFactory;
  46 import android.graphics.Canvas;
  47 import android.graphics.Color;
  48 import android.graphics.Paint;
  49 import android.graphics.Point;
  50 import android.graphics.PorterDuff;
  51 import android.graphics.PorterDuffXfermode;
  52 import android.graphics.Rect;
  53 import android.graphics.drawable.BitmapDrawable;
  54 import android.graphics.drawable.ColorDrawable;
  55 import android.graphics.drawable.Drawable;
  56 import android.os.Handler;
  57 import android.os.IRemoteCallback;
  58 import android.os.Looper;
  59 import android.os.Message;
  60 import android.os.ParcelFileDescriptor;
  61 import android.os.RemoteException;
  62 import android.os.SystemProperties;
  63 import android.os.UserHandle;
  64 import android.os.UserManager;
  65 import android.provider.Settings;
  66 import android.util.ArraySet;
  67 import android.util.Log;
  68 import android.util.MutableBoolean;
  69 import android.view.Display;
  70 import android.view.IAppTransitionAnimationSpecsFuture;
  71 import android.view.IDockedStackListener;
  72 import android.view.WindowManager;
  73 import android.view.WindowManager.KeyboardShortcutsReceiver;
  74 import android.view.WindowManagerGlobal;
  75 import android.view.accessibility.AccessibilityManager;
  76
  77 import com.android.internal.app.AssistUtils;
  78 import com.android.internal.os.BackgroundThread;
  79 import com.android.systemui.R;
  80 import com.android.systemui.recents.RecentsDebugFlags;
  81 import com.android.systemui.recents.RecentsImpl;
  82 import com.android.systemui.recents.model.Task;
  83 import com.android.systemui.recents.tv.RecentsTvImpl;
  84 import com.android.systemui.recents.model.ThumbnailData;
  85
  86 import java.io.IOException;
  87 import java.util.ArrayList;
  88 import java.util.Collections;
  89 import java.util.Iterator;
  90 import java.util.List;
  91 import java.util.Random;
  92
  93 /**
  94  * Acts as a shim around the real system services that we need to access data from, and provides
  95  * a point of injection when testing UI.
  96  */
  97 public class SystemServicesProxy {
  98     final static String TAG = "SystemServicesProxy";
  99
 100     final static BitmapFactory.Options sBitmapOptions;
 101     static {
 102         sBitmapOptions = new BitmapFactory.Options();
 103         sBitmapOptions.inMutable = true;
 104         sBitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;
 105     }
 106
 107     final static List<String> sRecentsBlacklist;
 108     static {
 109         sRecentsBlacklist = new ArrayList<>();
 110         sRecentsBlacklist.add("com.android.systemui.tv.pip.PipOnboardingActivity");
 111         sRecentsBlacklist.add("com.android.systemui.tv.pip.PipMenuActivity");
 112     }
 113
 114     private static SystemServicesProxy sSystemServicesProxy;
 115
 116     AccessibilityManager mAccm;
 117     ActivityManager mAm;
 118     IActivityManager mIam;
 119     PackageManager mPm;
 120     IPackageManager mIpm;
 121     AssistUtils mAssistUtils;
 122     WindowManager mWm;
 123     UserManager mUm;
 124     Display mDisplay;
 125     String mRecentsPackage;
 126     ComponentName mAssistComponent;
 127
 128     boolean mIsSafeMode;
 129     boolean mHasFreeformWorkspaceSupport;
 130
 131     Bitmap mDummyIcon;
 132     int mDummyThumbnailWidth;
 133     int mDummyThumbnailHeight;
 134     Paint mBgProtectionPaint;
 135     Canvas mBgProtectionCanvas;
 136
 137     private final Handler mHandler = new H();
 138
 139     /**
 140      * An abstract class to track task stack changes.
 141      * Classes should implement this instead of {@link android.app.ITaskStackListener}
 142      * to reduce IPC calls from system services. These callbacks will be called on the main thread.
 143      */
 144     public abstract static class TaskStackListener {
 145         public void onTaskStackChanged() { }
 146         public void onActivityPinned() { }
 147         public void onPinnedActivityRestartAttempt() { }
 148         public void onPinnedStackAnimationEnded() { }
 149         public void onActivityForcedResizable(String packageName, int taskId) { }
 150         public void onActivityDismissingDockedStack() { }
 151     }
 152
 153     /**
 154      * Implementation of {@link android.app.ITaskStackListener} to listen task stack changes from
 155      * ActivityManagerNative.
 156      * This simply passes callbacks to listeners through {@link H}.
 157      * */
 158     private ITaskStackListener.Stub mTaskStackListener = new ITaskStackListener.Stub() {
 159         @Override
 160         public void onTaskStackChanged() throws RemoteException {
 161             mHandler.removeMessages(H.ON_TASK_STACK_CHANGED);
 162             mHandler.sendEmptyMessage(H.ON_TASK_STACK_CHANGED);
 163         }
 164
 165         @Override
 166         public void onActivityPinned() throws RemoteException {
 167             mHandler.removeMessages(H.ON_ACTIVITY_PINNED);
 168             mHandler.sendEmptyMessage(H.ON_ACTIVITY_PINNED);
 169         }
 170
 171         @Override
 172         public void onPinnedActivityRestartAttempt() throws RemoteException{
 173             mHandler.removeMessages(H.ON_PINNED_ACTIVITY_RESTART_ATTEMPT);
 174             mHandler.sendEmptyMessage(H.ON_PINNED_ACTIVITY_RESTART_ATTEMPT);
 175         }
 176
 177         @Override
 178         public void onPinnedStackAnimationEnded() throws RemoteException {
 179             mHandler.removeMessages(H.ON_PINNED_STACK_ANIMATION_ENDED);
 180             mHandler.sendEmptyMessage(H.ON_PINNED_STACK_ANIMATION_ENDED);
 181         }
 182
 183         @Override
 184         public void onActivityForcedResizable(String packageName, int taskId)
 185                 throws RemoteException {
 186             mHandler.obtainMessage(H.ON_ACTIVITY_FORCED_RESIZABLE, taskId, 0, packageName)
 187                     .sendToTarget();
 188         }
 189
 190         @Override
 191         public void onActivityDismissingDockedStack() throws RemoteException {
 192             mHandler.sendEmptyMessage(H.ON_ACTIVITY_DISMISSING_DOCKED_STACK);
 193         }
 194     };
 195
 196     /**
 197      * List of {@link TaskStackListener} registered from {@link #registerTaskStackListener}.
 198      */
 199     private List<TaskStackListener> mTaskStackListeners = new ArrayList<>();
 200
 201     /** Private constructor */
 202     private SystemServicesProxy(Context context) {
 203         mAccm = AccessibilityManager.getInstance(context);
 204         mAm = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
 205         mIam = ActivityManagerNative.getDefault();
 206         mPm = context.getPackageManager();
 207         mIpm = AppGlobals.getPackageManager();
 208         mAssistUtils = new AssistUtils(context);
 209         mWm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
 210         mUm = UserManager.get(context);
 211         mDisplay = mWm.getDefaultDisplay();
 212         mRecentsPackage = context.getPackageName();
 213         mHasFreeformWorkspaceSupport =
 214                 mPm.hasSystemFeature(PackageManager.FEATURE_FREEFORM_WINDOW_MANAGEMENT) ||
 215                         Settings.Global.getInt(context.getContentResolver(),
 216                                 DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT, 0) != 0;
 217         mIsSafeMode = mPm.isSafeMode();
 218
 219         // Get the dummy thumbnail width/heights
 220         Resources res = context.getResources();
 221         int wId = com.android.internal.R.dimen.thumbnail_width;
 222         int hId = com.android.internal.R.dimen.thumbnail_height;
 223         mDummyThumbnailWidth = res.getDimensionPixelSize(wId);
 224         mDummyThumbnailHeight = res.getDimensionPixelSize(hId);
 225
 226         // Create the protection paints
 227         mBgProtectionPaint = new Paint();
 228         mBgProtectionPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_ATOP));
 229         mBgProtectionPaint.setColor(0xFFffffff);
 230         mBgProtectionCanvas = new Canvas();
 231
 232         // Resolve the assist intent
 233         mAssistComponent = mAssistUtils.getAssistComponentForUser(UserHandle.myUserId());
 234
 235         if (RecentsDebugFlags.Static.EnableMockTasks) {
 236             // Create a dummy icon
 237             mDummyIcon = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
 238             mDummyIcon.eraseColor(0xFF999999);
 239         }
 240
 241         UiModeManager uiModeManager = (UiModeManager) context.
 242                 getSystemService(Context.UI_MODE_SERVICE);
 243         if (uiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_TELEVISION) {
 244             Collections.addAll(sRecentsBlacklist,
 245                     res.getStringArray(R.array.recents_tv_blacklist_array));
 246         } else {
 247             Collections.addAll(sRecentsBlacklist,
 248                     res.getStringArray(R.array.recents_blacklist_array));
 249         }
 250     }
 251
 252     /**
 253      * Returns the single instance of the {@link SystemServicesProxy}.
 254      * This should only be called on the main thread.
 255      */
 256     public static SystemServicesProxy getInstance(Context context) {
 257         if (!Looper.getMainLooper().isCurrentThread()) {
 258             throw new RuntimeException("Must be called on the UI thread");
 259         }
 260         if (sSystemServicesProxy == null) {
 261             sSystemServicesProxy = new SystemServicesProxy(context);
 262         }
 263         return sSystemServicesProxy;
 264     }
 265
 266     /**
 267      * @return whether the provided {@param className} is blacklisted
 268      */
 269     public boolean isBlackListedActivity(String className) {
 270         return sRecentsBlacklist.contains(className);
 271     }
 272
 273     /**
 274      * Returns a list of the recents tasks.
 275      *
 276      * @param includeFrontMostExcludedTask if set, will ensure that the front most excluded task
 277      *                                     will be visible, otherwise no excluded tasks will be
 278      *                                     visible.
 279      */
 280     public List<ActivityManager.RecentTaskInfo> getRecentTasks(int numLatestTasks, int userId,
 281             boolean includeFrontMostExcludedTask, ArraySet<Integer> quietProfileIds) {
 282         if (mAm == null) return null;
 283
 284         // If we are mocking, then create some recent tasks
 285         if (RecentsDebugFlags.Static.EnableMockTasks) {
 286             ArrayList<ActivityManager.RecentTaskInfo> tasks =
 287                     new ArrayList<ActivityManager.RecentTaskInfo>();
 288             int count = Math.min(numLatestTasks, RecentsDebugFlags.Static.MockTaskCount);
 289             for (int i = 0; i < count; i++) {
 290                 // Create a dummy component name
 291                 int packageIndex = i % RecentsDebugFlags.Static.MockTasksPackageCount;
 292                 ComponentName cn = new ComponentName("com.android.test" + packageIndex,
 293                         "com.android.test" + i + ".Activity");
 294                 String description = "" + i + " - " +
 295                         Long.toString(Math.abs(new Random().nextLong()), 36);
 296                 // Create the recent task info
 297                 ActivityManager.RecentTaskInfo rti = new ActivityManager.RecentTaskInfo();
 298                 rti.id = rti.persistentId = rti.affiliatedTaskId = i;
 299                 rti.baseIntent = new Intent();
 300                 rti.baseIntent.setComponent(cn);
 301                 rti.description = description;
 302                 rti.firstActiveTime = rti.lastActiveTime = i;
 303                 if (i % 2 == 0) {
 304                     rti.taskDescription = new ActivityManager.TaskDescription(description,
 305                         Bitmap.createBitmap(mDummyIcon), null,
 306                         0xFF000000 | (0xFFFFFF & new Random().nextInt()),
 307                         0xFF000000 | (0xFFFFFF & new Random().nextInt()));
 308                 } else {
 309                     rti.taskDescription = new ActivityManager.TaskDescription();
 310                 }
 311                 tasks.add(rti);
 312             }
 313             return tasks;
 314         }
 315
 316         // Remove home/recents/excluded tasks
 317         int minNumTasksToQuery = 10;
 318         int numTasksToQuery = Math.max(minNumTasksToQuery, numLatestTasks);
 319         int flags = ActivityManager.RECENT_IGNORE_HOME_STACK_TASKS |
 320                 ActivityManager.RECENT_INGORE_DOCKED_STACK_TOP_TASK |
 321                 ActivityManager.RECENT_INGORE_PINNED_STACK_TASKS |
 322                 ActivityManager.RECENT_IGNORE_UNAVAILABLE |
 323                 ActivityManager.RECENT_INCLUDE_PROFILES;
 324         if (includeFrontMostExcludedTask) {
 325             flags |= ActivityManager.RECENT_WITH_EXCLUDED;
 326         }
 327         List<ActivityManager.RecentTaskInfo> tasks = null;
 328         try {
 329             tasks = mAm.getRecentTasksForUser(numTasksToQuery, flags, userId);
 330         } catch (Exception e) {
 331             Log.e(TAG, "Failed to get recent tasks", e);
 332         }
 333
 334         // Break early if we can't get a valid set of tasks
 335         if (tasks == null) {
 336             return new ArrayList<>();
 337         }
 338
 339         boolean isFirstValidTask = true;
 340         Iterator<ActivityManager.RecentTaskInfo> iter = tasks.iterator();
 341         while (iter.hasNext()) {
 342             ActivityManager.RecentTaskInfo t = iter.next();
 343
 344             // NOTE: The order of these checks happens in the expected order of the traversal of the
 345             // tasks
 346
 347             // Remove the task if it or it's package are blacklsited
 348             if (sRecentsBlacklist.contains(t.realActivity.getClassName()) ||
 349                     sRecentsBlacklist.contains(t.realActivity.getPackageName())) {
 350                 iter.remove();
 351                 continue;
 352             }
 353
 354             // Remove the task if it is marked as excluded, unless it is the first most task and we
 355             // are requested to include it
 356             boolean isExcluded = (t.baseIntent.getFlags() & Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
 357                     == Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
 358             isExcluded |= quietProfileIds.contains(t.userId);
 359             if (isExcluded && (!isFirstValidTask || !includeFrontMostExcludedTask)) {
 360                 iter.remove();
 361             }
 362
 363             isFirstValidTask = false;
 364         }
 365
 366         return tasks.subList(0, Math.min(tasks.size(), numLatestTasks));
 367     }
 368
 369     /**
 370      * Returns the top running task.
 371      */
 372     public ActivityManager.RunningTaskInfo getRunningTask() {
 373         List<ActivityManager.RunningTaskInfo> tasks = mAm.getRunningTasks(1);
 374         if (tasks != null && !tasks.isEmpty()) {
 375             return tasks.get(0);
 376         }
 377         return null;
 378     }
 379
 380     /**
 381      * Returns whether the recents activity is currently visible.
 382      */
 383     public boolean isRecentsActivityVisible() {
 384         return isRecentsActivityVisible(null);
 385     }
 386
 387     /**
 388      * Returns whether the recents activity is currently visible.
 389      *
 390      * @param isHomeStackVisible if provided, will return whether the home stack is visible
 391      *                           regardless of the recents visibility
 392      */
 393     public boolean isRecentsActivityVisible(MutableBoolean isHomeStackVisible) {
 394         if (mIam == null) return false;
 395
 396         try {
 397             ActivityManager.StackInfo stackInfo = mIam.getStackInfo(
 398                     ActivityManager.StackId.HOME_STACK_ID);
 399             ActivityManager.StackInfo fullscreenStackInfo = mIam.getStackInfo(
 400                     ActivityManager.StackId.FULLSCREEN_WORKSPACE_STACK_ID);
 401             ComponentName topActivity = stackInfo.topActivity;
 402             boolean homeStackVisibleNotOccluded = stackInfo.visible;
 403             if (fullscreenStackInfo != null) {
 404                 boolean isFullscreenStackOccludingHome = fullscreenStackInfo.visible &&
 405                         fullscreenStackInfo.position > stackInfo.position;
 406                 homeStackVisibleNotOccluded &= !isFullscreenStackOccludingHome;
 407             }
 408             if (isHomeStackVisible != null) {
 409                 isHomeStackVisible.value = homeStackVisibleNotOccluded;
 410             }
 411             return (homeStackVisibleNotOccluded && topActivity != null
 412                     && topActivity.getPackageName().equals(RecentsImpl.RECENTS_PACKAGE)
 413                     && (topActivity.getClassName().equals(RecentsImpl.RECENTS_ACTIVITY)
 414                         || topActivity.getClassName().equals(RecentsTvImpl.RECENTS_TV_ACTIVITY)));
 415         } catch (RemoteException e) {
 416             e.printStackTrace();
 417         }
 418         return false;
 419     }
 420
 421     /**
 422      * Returns whether this device has freeform workspaces.
 423      */
 424     public boolean hasFreeformWorkspaceSupport() {
 425         return mHasFreeformWorkspaceSupport;
 426     }
 427
 428     /**
 429      * Returns whether this device is in the safe mode.
 430      */
 431     public boolean isInSafeMode() {
 432         return mIsSafeMode;
 433     }
 434
 435     /** Docks a task to the side of the screen and starts it. */
 436     public boolean startTaskInDockedMode(int taskId, int createMode) {
 437         if (mIam == null) return false;
 438
 439         try {
 440             final ActivityOptions options = ActivityOptions.makeBasic();
 441             options.setDockCreateMode(createMode);
 442             options.setLaunchStackId(DOCKED_STACK_ID);
 443             mIam.startActivityFromRecents(taskId, options.toBundle());
 444             return true;
 445         } catch (Exception e) {
 446             Log.e(TAG, "Failed to dock task: " + taskId + " with createMode: " + createMode, e);
 447         }
 448         return false;
 449     }
 450
 451     /** Docks an already resumed task to the side of the screen. */
 452     public boolean moveTaskToDockedStack(int taskId, int createMode, Rect initialBounds) {
 453         if (mIam == null) {
 454             return false;
 455         }
 456
 457         try {
 458             return mIam.moveTaskToDockedStack(taskId, createMode, true /* onTop */,
 459                     false /* animate */, initialBounds, true /* moveHomeStackFront */ );
 460         } catch (RemoteException e) {
 461             e.printStackTrace();
 462         }
 463         return false;
 464     }
 465
 466     /**
 467      * Returns whether the given stack id is the home stack id.
 468      */
 469     public static boolean isHomeStack(int stackId) {
 470         return stackId == HOME_STACK_ID;
 471     }
 472
 473     /**
 474      * Returns whether the given stack id is the pinned stack id.
 475      */
 476     public static boolean isPinnedStack(int stackId){
 477         return stackId == PINNED_STACK_ID;
 478     }
 479
 480     /**
 481      * Returns whether the given stack id is the docked stack id.
 482      */
 483     public static boolean isDockedStack(int stackId) {
 484         return stackId == DOCKED_STACK_ID;
 485     }
 486
 487     /**
 488      * Returns whether the given stack id is the freeform workspace stack id.
 489      */
 490     public static boolean isFreeformStack(int stackId) {
 491         return stackId == FREEFORM_WORKSPACE_STACK_ID;
 492     }
 493
 494     /**
 495      * @return whether there are any docked tasks for the current user.
 496      */
 497     public boolean hasDockedTask() {
 498         if (mIam == null) return false;
 499
 500         ActivityManager.StackInfo stackInfo = null;
 501         try {
 502             stackInfo = mIam.getStackInfo(DOCKED_STACK_ID);
 503         } catch (RemoteException e) {
 504             e.printStackTrace();
 505         }
 506
 507         if (stackInfo != null) {
 508             int userId = getCurrentUser();
 509             boolean hasUserTask = false;
 510             for (int i = stackInfo.taskUserIds.length - 1; i >= 0 && !hasUserTask; i--) {
 511                 hasUserTask = (stackInfo.taskUserIds[i] == userId);
 512             }
 513             return hasUserTask;
 514         }
 515         return false;
 516     }
 517
 518     /**
 519      * Returns whether there is a soft nav bar.
 520      */
 521     public boolean hasSoftNavigationBar() {
 522         try {
 523             return WindowManagerGlobal.getWindowManagerService().hasNavigationBar();
 524         } catch (RemoteException e) {
 525             e.printStackTrace();
 526         }
 527         return false;
 528     }
 529
 530     /**
 531      * Returns whether the device has a transposed nav bar (on the right of the screen) in the
 532      * current display orientation.
 533      */
 534     public boolean hasTransposedNavigationBar() {
 535         Rect insets = new Rect();
 536         getStableInsets(insets);
 537         return insets.right > 0;
 538     }
 539
 540     /**
 541      * Cancels the current window transtion to/from Recents for the given task id.
 542      */
 543     public void cancelWindowTransition(int taskId) {
 544         if (mWm == null) return;
 545
 546         try {
 547             WindowManagerGlobal.getWindowManagerService().cancelTaskWindowTransition(taskId);
 548         } catch (RemoteException e) {
 549             e.printStackTrace();
 550         }
 551     }
 552
 553     /**
 554      * Cancels the current thumbnail transtion to/from Recents for the given task id.
 555      */
 556     public void cancelThumbnailTransition(int taskId) {
 557         if (mWm == null) return;
 558
 559         try {
 560             WindowManagerGlobal.getWindowManagerService().cancelTaskThumbnailTransition(taskId);
 561         } catch (RemoteException e) {
 562             e.printStackTrace();
 563         }
 564     }
 565
 566     /** Returns the top task thumbnail for the given task id */
 567     public ThumbnailData getTaskThumbnail(int taskId) {
 568         if (mAm == null) return null;
 569         ThumbnailData thumbnailData = new ThumbnailData();
 570
 571         // If we are mocking, then just return a dummy thumbnail
 572         if (RecentsDebugFlags.Static.EnableMockTasks) {
 573             thumbnailData.thumbnail = Bitmap.createBitmap(mDummyThumbnailWidth,
 574                     mDummyThumbnailHeight, Bitmap.Config.ARGB_8888);
 575             thumbnailData.thumbnail.eraseColor(0xff333333);
 576             return thumbnailData;
 577         }
 578
 579         getThumbnail(taskId, thumbnailData);
 580         if (thumbnailData.thumbnail != null) {
 581             thumbnailData.thumbnail.setHasAlpha(false);
 582             // We use a dumb heuristic for now, if the thumbnail is purely transparent in the top
 583             // left pixel, then assume the whole thumbnail is transparent. Generally, proper
 584             // screenshots are always composed onto a bitmap that has no alpha.
 585             if (Color.alpha(thumbnailData.thumbnail.getPixel(0, 0)) == 0) {
 586                 mBgProtectionCanvas.setBitmap(thumbnailData.thumbnail);
 587                 mBgProtectionCanvas.drawRect(0, 0, thumbnailData.thumbnail.getWidth(),
 588                         thumbnailData.thumbnail.getHeight(), mBgProtectionPaint);
 589                 mBgProtectionCanvas.setBitmap(null);
 590                 Log.e(TAG, "Invalid screenshot detected from getTaskThumbnail()");
 591             }
 592         }
 593         return thumbnailData;
 594     }
 595
 596     /**
 597      * Returns a task thumbnail from the activity manager
 598      */
 599     public void getThumbnail(int taskId, ThumbnailData thumbnailDataOut) {
 600         if (mAm == null) {
 601             return;
 602         }
 603
 604         ActivityManager.TaskThumbnail taskThumbnail = mAm.getTaskThumbnail(taskId);
 605         if (taskThumbnail == null) {
 606             return;
 607         }
 608
 609         Bitmap thumbnail = taskThumbnail.mainThumbnail;
 610         ParcelFileDescriptor descriptor = taskThumbnail.thumbnailFileDescriptor;
 611         if (thumbnail == null && descriptor != null) {
 612             thumbnail = BitmapFactory.decodeFileDescriptor(descriptor.getFileDescriptor(),
 613                     null, sBitmapOptions);
 614         }
 615         if (descriptor != null) {
 616             try {
 617                 descriptor.close();
 618             } catch (IOException e) {
 619             }
 620         }
 621         thumbnailDataOut.thumbnail = thumbnail;
 622         thumbnailDataOut.thumbnailInfo = taskThumbnail.thumbnailInfo;
 623     }
 624
 625     /**
 626      * Moves a task into another stack.
 627      */
 628     public void moveTaskToStack(int taskId, int stackId) {
 629         if (mIam == null) return;
 630
 631         try {
 632             mIam.positionTaskInStack(taskId, stackId, 0);
 633         } catch (RemoteException | IllegalArgumentException e) {
 634             e.printStackTrace();
 635         }
 636     }
 637
 638     /** Removes the task */
 639     public void removeTask(final int taskId) {
 640         if (mAm == null) return;
 641         if (RecentsDebugFlags.Static.EnableMockTasks) return;
 642
 643         // Remove the task.
 644         BackgroundThread.getHandler().post(new Runnable() {
 645             @Override
 646             public void run() {
 647                 mAm.removeTask(taskId);
 648             }
 649         });
 650     }
 651
 652     /**
 653      * Sends a message to close other system windows.
 654      */
 655     public void sendCloseSystemWindows(String reason) {
 656         if (ActivityManagerNative.isSystemReady()) {
 657             try {
 658                 mIam.closeSystemDialogs(reason);
 659             } catch (RemoteException e) {
 660             }
 661         }
 662     }
 663
 664     /**
 665      * Returns the activity info for a given component name.
 666      *
 667      * @param cn The component name of the activity.
 668      * @param userId The userId of the user that this is for.
 669      */
 670     public ActivityInfo getActivityInfo(ComponentName cn, int userId) {
 671         if (mIpm == null) return null;
 672         if (RecentsDebugFlags.Static.EnableMockTasks) return new ActivityInfo();
 673
 674         try {
 675             return mIpm.getActivityInfo(cn, PackageManager.GET_META_DATA, userId);
 676         } catch (RemoteException e) {
 677             e.printStackTrace();
 678             return null;
 679         }
 680     }
 681
 682     /**
 683      * Returns the activity info for a given component name.
 684      *
 685      * @param cn The component name of the activity.
 686      */
 687     public ActivityInfo getActivityInfo(ComponentName cn) {
 688         if (mPm == null) return null;
 689         if (RecentsDebugFlags.Static.EnableMockTasks) return new ActivityInfo();
 690
 691         try {
 692             return mPm.getActivityInfo(cn, PackageManager.GET_META_DATA);
 693         } catch (PackageManager.NameNotFoundException e) {
 694             e.printStackTrace();
 695             return null;
 696         }
 697     }
 698
 699     /**
 700      * Returns the activity label, badging if necessary.
 701      */
 702     public String getBadgedActivityLabel(ActivityInfo info, int userId) {
 703         if (mPm == null) return null;
 704
 705         // If we are mocking, then return a mock label
 706         if (RecentsDebugFlags.Static.EnableMockTasks) {
 707             return "Recent Task: " + userId;
 708         }
 709
 710         return getBadgedLabel(info.loadLabel(mPm).toString(), userId);
 711     }
 712
 713     /**
 714      * Returns the application label, badging if necessary.
 715      */
 716     public String getBadgedApplicationLabel(ApplicationInfo appInfo, int userId) {
 717         if (mPm == null) return null;
 718
 719         // If we are mocking, then return a mock label
 720         if (RecentsDebugFlags.Static.EnableMockTasks) {
 721             return "Recent Task App: " + userId;
 722         }
 723
 724         return getBadgedLabel(appInfo.loadLabel(mPm).toString(), userId);
 725     }
 726
 727     /**
 728      * Returns the content description for a given task, badging it if necessary.  The content
 729      * description joins the app and activity labels.
 730      */
 731     public String getBadgedContentDescription(ActivityInfo info, int userId, Resources res) {
 732         // If we are mocking, then return a mock label
 733         if (RecentsDebugFlags.Static.EnableMockTasks) {
 734             return "Recent Task Content Description: " + userId;
 735         }
 736
 737         String activityLabel = info.loadLabel(mPm).toString();
 738         String applicationLabel = info.applicationInfo.loadLabel(mPm).toString();
 739         String badgedApplicationLabel = getBadgedLabel(applicationLabel, userId);
 740         return applicationLabel.equals(activityLabel) ? badgedApplicationLabel
 741                 : res.getString(R.string.accessibility_recents_task_header,
 742                         badgedApplicationLabel, activityLabel);
 743     }
 744
 745     /**
 746      * Returns the activity icon for the ActivityInfo for a user, badging if
 747      * necessary.
 748      */
 749     public Drawable getBadgedActivityIcon(ActivityInfo info, int userId) {
 750         if (mPm == null) return null;
 751
 752         // If we are mocking, then return a mock label
 753         if (RecentsDebugFlags.Static.EnableMockTasks) {
 754             return new ColorDrawable(0xFF666666);
 755         }
 756
 757         Drawable icon = info.loadIcon(mPm);
 758         return getBadgedIcon(icon, userId);
 759     }
 760
 761     /**
 762      * Returns the application icon for the ApplicationInfo for a user, badging if
 763      * necessary.
 764      */
 765     public Drawable getBadgedApplicationIcon(ApplicationInfo appInfo, int userId) {
 766         if (mPm == null) return null;
 767
 768         // If we are mocking, then return a mock label
 769         if (RecentsDebugFlags.Static.EnableMockTasks) {
 770             return new ColorDrawable(0xFF666666);
 771         }
 772
 773         Drawable icon = appInfo.loadIcon(mPm);
 774         return getBadgedIcon(icon, userId);
 775     }
 776
 777     /**
 778      * Returns the task description icon, loading and badging it if it necessary.
 779      */
 780     public Drawable getBadgedTaskDescriptionIcon(ActivityManager.TaskDescription taskDescription,
 781             int userId, Resources res) {
 782
 783         // If we are mocking, then return a mock label
 784         if (RecentsDebugFlags.Static.EnableMockTasks) {
 785             return new ColorDrawable(0xFF666666);
 786         }
 787
 788         Bitmap tdIcon = taskDescription.getInMemoryIcon();
 789         if (tdIcon == null) {
 790             tdIcon = ActivityManager.TaskDescription.loadTaskDescriptionIcon(
 791                     taskDescription.getIconFilename(), userId);
 792         }
 793         if (tdIcon != null) {
 794             return getBadgedIcon(new BitmapDrawable(res, tdIcon), userId);
 795         }
 796         return null;
 797     }
 798
 799     /**
 800      * Returns the given icon for a user, badging if necessary.
 801      */
 802     private Drawable getBadgedIcon(Drawable icon, int userId) {
 803         if (userId != UserHandle.myUserId()) {
 804             icon = mPm.getUserBadgedIcon(icon, new UserHandle(userId));
 805         }
 806         return icon;
 807     }
 808
 809     /**
 810      * Returns a banner used on TV for the specified Activity.
 811      */
 812     public Drawable getActivityBanner(ActivityInfo info) {
 813         if (mPm == null) return null;
 814
 815         // If we are mocking, then return a mock banner
 816         if (RecentsDebugFlags.Static.EnableMockTasks) {
 817             return new ColorDrawable(0xFF666666);
 818         }
 819
 820         Drawable banner = info.loadBanner(mPm);
 821         return banner;
 822     }
 823
 824     /**
 825      * Returns a logo used on TV for the specified Activity.
 826      */
 827     public Drawable getActivityLogo(ActivityInfo info) {
 828         if (mPm == null) return null;
 829
 830         // If we are mocking, then return a mock logo
 831         if (RecentsDebugFlags.Static.EnableMockTasks) {
 832             return new ColorDrawable(0xFF666666);
 833         }
 834
 835         Drawable logo = info.loadLogo(mPm);
 836         return logo;
 837     }
 838
 839
 840     /**
 841      * Returns the given label for a user, badging if necessary.
 842      */
 843     private String getBadgedLabel(String label, int userId) {
 844         if (userId != UserHandle.myUserId()) {
 845             label = mPm.getUserBadgedLabel(label, new UserHandle(userId)).toString();
 846         }
 847         return label;
 848     }
 849
 850     /** Returns the package name of the home activity. */
 851     public String getHomeActivityPackageName() {
 852         if (mPm == null) return null;
 853         if (RecentsDebugFlags.Static.EnableMockTasks) return null;
 854
 855         ArrayList<ResolveInfo> homeActivities = new ArrayList<>();
 856         ComponentName defaultHomeActivity = mPm.getHomeActivities(homeActivities);
 857         if (defaultHomeActivity != null) {
 858             return defaultHomeActivity.getPackageName();
 859         } else if (homeActivities.size() == 1) {
 860             ResolveInfo info = homeActivities.get(0);
 861             if (info.activityInfo != null) {
 862                 return info.activityInfo.packageName;
 863             }
 864         }
 865         return null;
 866     }
 867
 868     /**
 869      * Returns whether the provided {@param userId} represents the system user.
 870      */
 871     public boolean isSystemUser(int userId) {
 872         return userId == UserHandle.USER_SYSTEM;
 873     }
 874
 875     /**
 876      * Returns the current user id.
 877      */
 878     public int getCurrentUser() {
 879         if (mAm == null) return 0;
 880
 881         return mAm.getCurrentUser();
 882     }
 883
 884     /**
 885      * Returns the processes user id.
 886      */
 887     public int getProcessUser() {
 888         if (mUm == null) return 0;
 889         return mUm.getUserHandle();
 890     }
 891
 892     /**
 893      * Returns whether touch exploration is currently enabled.
 894      */
 895     public boolean isTouchExplorationEnabled() {
 896         if (mAccm == null) return false;
 897
 898         return mAccm.isEnabled() && mAccm.isTouchExplorationEnabled();
 899     }
 900
 901     /**
 902      * Returns whether the current task is in screen-pinning mode.
 903      */
 904     public boolean isScreenPinningActive() {
 905         if (mIam == null) return false;
 906
 907         try {
 908             return mIam.isInLockTaskMode();
 909         } catch (RemoteException e) {
 910             return false;
 911         }
 912     }
 913
 914     /**
 915      * Returns a global setting.
 916      */
 917     public int getGlobalSetting(Context context, String setting) {
 918         ContentResolver cr = context.getContentResolver();
 919         return Settings.Global.getInt(cr, setting, 0);
 920     }
 921
 922     /**
 923      * Returns a system setting.
 924      */
 925     public int getSystemSetting(Context context, String setting) {
 926         ContentResolver cr = context.getContentResolver();
 927         return Settings.System.getInt(cr, setting, 0);
 928     }
 929
 930     /**
 931      * Returns a system property.
 932      */
 933     public String getSystemProperty(String key) {
 934         return SystemProperties.get(key);
 935     }
 936
 937     /**
 938      * Returns the smallest width/height.
 939      */
 940     public int getDeviceSmallestWidth() {
 941         if (mDisplay == null) return 0;
 942
 943         Point smallestSizeRange = new Point();
 944         Point largestSizeRange = new Point();
 945         mDisplay.getCurrentSizeRange(smallestSizeRange, largestSizeRange);
 946         return smallestSizeRange.x;
 947     }
 948
 949     /**
 950      * Returns the current display rect in the current display orientation.
 951      */
 952     public Rect getDisplayRect() {
 953         Rect displayRect = new Rect();
 954         if (mDisplay == null) return displayRect;
 955
 956         Point p = new Point();
 957         mDisplay.getRealSize(p);
 958         displayRect.set(0, 0, p.x, p.y);
 959         return displayRect;
 960     }
 961
 962     /**
 963      * Returns the window rect for the RecentsActivity, based on the dimensions of the home stack.
 964      */
 965     public Rect getWindowRect() {
 966         Rect windowRect = new Rect();
 967         if (mIam == null) return windowRect;
 968
 969         try {
 970             // Use the home stack bounds
 971             ActivityManager.StackInfo stackInfo = mIam.getStackInfo(HOME_STACK_ID);
 972             if (stackInfo != null) {
 973                 windowRect.set(stackInfo.bounds);
 974             }
 975         } catch (RemoteException e) {
 976             e.printStackTrace();
 977         } finally {
 978             return windowRect;
 979         }
 980     }
 981
 982     /** Starts an activity from recents. */
 983     public boolean startActivityFromRecents(Context context, Task.TaskKey taskKey, String taskName,
 984             ActivityOptions options) {
 985         if (mIam != null) {
 986             try {
 987                 if (taskKey.stackId == DOCKED_STACK_ID) {
 988                     // We show non-visible docked tasks in Recents, but we always want to launch
 989                     // them in the fullscreen stack.
 990                     if (options == null) {
 991                         options = ActivityOptions.makeBasic();
 992                     }
 993                     options.setLaunchStackId(FULLSCREEN_WORKSPACE_STACK_ID);
 994                 }
 995                 mIam.startActivityFromRecents(
 996                         taskKey.id, options == null ? null : options.toBundle());
 997                 return true;
 998             } catch (Exception e) {
 999                 Log.e(TAG, context.getString(R.string.recents_launch_error_message, taskName), e);
1000             }
1001         }
1002         return false;
1003     }
1004
1005     /** Starts an in-place animation on the front most application windows. */
1006     public void startInPlaceAnimationOnFrontMostApplication(ActivityOptions opts) {
1007         if (mIam == null) return;
1008
1009         try {
1010             mIam.startInPlaceAnimationOnFrontMostApplication(opts);
1011         } catch (Exception e) {
1012             e.printStackTrace();
1013         }
1014     }
1015
1016     /**
1017      * Registers a task stack listener with the system.
1018      * This should be called on the main thread.
1019      */
1020     public void registerTaskStackListener(TaskStackListener listener) {
1021         if (mIam == null) return;
1022
1023         mTaskStackListeners.add(listener);
1024         if (mTaskStackListeners.size() == 1) {
1025             // Register mTaskStackListener to IActivityManager only once if needed.
1026             try {
1027                 mIam.registerTaskStackListener(mTaskStackListener);
1028             } catch (Exception e) {
1029                 Log.w(TAG, "Failed to call registerTaskStackListener", e);
1030             }
1031         }
1032     }
1033
1034     public void endProlongedAnimations() {
1035         if (mWm == null) {
1036             return;
1037         }
1038         try {
1039             WindowManagerGlobal.getWindowManagerService().endProlongedAnimations();
1040         } catch (Exception e) {
1041             e.printStackTrace();
1042         }
1043     }
1044
1045     public void registerDockedStackListener(IDockedStackListener listener) {
1046         if (mWm == null) return;
1047
1048         try {
1049             WindowManagerGlobal.getWindowManagerService().registerDockedStackListener(listener);
1050         } catch (Exception e) {
1051             e.printStackTrace();
1052         }
1053     }
1054
1055     /**
1056      * Calculates the size of the dock divider in the current orientation.
1057      */
1058     public int getDockedDividerSize(Context context) {
1059         Resources res = context.getResources();
1060         int dividerWindowWidth = res.getDimensionPixelSize(
1061                 com.android.internal.R.dimen.docked_stack_divider_thickness);
1062         int dividerInsets = res.getDimensionPixelSize(
1063                 com.android.internal.R.dimen.docked_stack_divider_insets);
1064         return dividerWindowWidth - 2 * dividerInsets;
1065     }
1066
1067     public void requestKeyboardShortcuts(
1068             Context context, KeyboardShortcutsReceiver receiver, int deviceId) {
1069         mWm.requestAppKeyboardShortcuts(receiver, deviceId);
1070     }
1071
1072     public void getStableInsets(Rect outStableInsets) {
1073         if (mWm == null) return;
1074
1075         try {
1076             WindowManagerGlobal.getWindowManagerService().getStableInsets(outStableInsets);
1077         } catch (Exception e) {
1078             e.printStackTrace();
1079         }
1080     }
1081
1082     public void overridePendingAppTransitionMultiThumbFuture(
1083             IAppTransitionAnimationSpecsFuture future, IRemoteCallback animStartedListener,
1084             boolean scaleUp) {
1085         try {
1086             WindowManagerGlobal.getWindowManagerService()
1087                     .overridePendingAppTransitionMultiThumbFuture(future, animStartedListener,
1088                             scaleUp);
1089         } catch (RemoteException e) {
1090             Log.w(TAG, "Failed to override transition: " + e);
1091         }
1092     }
1093
1094     private final class H extends Handler {
1095         private static final int ON_TASK_STACK_CHANGED = 1;
1096         private static final int ON_ACTIVITY_PINNED = 2;
1097         private static final int ON_PINNED_ACTIVITY_RESTART_ATTEMPT = 3;
1098         private static final int ON_PINNED_STACK_ANIMATION_ENDED = 4;
1099         private static final int ON_ACTIVITY_FORCED_RESIZABLE = 5;
1100         private static final int ON_ACTIVITY_DISMISSING_DOCKED_STACK = 6;
1101
1102         @Override
1103         public void handleMessage(Message msg) {
1104             switch (msg.what) {
1105                 case ON_TASK_STACK_CHANGED: {
1106                     for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
1107                         mTaskStackListeners.get(i).onTaskStackChanged();
1108                     }
1109                     break;
1110                 }
1111                 case ON_ACTIVITY_PINNED: {
1112                     for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
1113                         mTaskStackListeners.get(i).onActivityPinned();
1114                     }
1115                     break;
1116                 }
1117                 case ON_PINNED_ACTIVITY_RESTART_ATTEMPT: {
1118                     for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
1119                         mTaskStackListeners.get(i).onPinnedActivityRestartAttempt();
1120                     }
1121                     break;
1122                 }
1123                 case ON_PINNED_STACK_ANIMATION_ENDED: {
1124                     for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
1125                         mTaskStackListeners.get(i).onPinnedStackAnimationEnded();
1126                     }
1127                     break;
1128                 }
1129                 case ON_ACTIVITY_FORCED_RESIZABLE: {
1130                     for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
1131                         mTaskStackListeners.get(i).onActivityForcedResizable(
1132                                 (String) msg.obj, msg.arg1);
1133                     }
1134                     break;
1135                 }
1136                 case ON_ACTIVITY_DISMISSING_DOCKED_STACK: {
1137                     for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
1138                         mTaskStackListeners.get(i).onActivityDismissingDockedStack();
1139                     }
1140                     break;
1141                 }
1142             }
1143         }
1144     }
1145 }