packages/SystemUI/src/com/android/systemui/statusbar/BaseStatusBar.java

   1 /*
   2  * Copyright (C) 2010 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.statusbar;
  18
  19 import android.animation.Animator;
  20 import android.animation.AnimatorListenerAdapter;
  21 import android.animation.TimeInterpolator;
  22 import android.app.ActivityManager;
  23 import android.app.ActivityManagerNative;
  24 import android.app.Notification;
  25 import android.app.NotificationManager;
  26 import android.app.PendingIntent;
  27 import android.app.TaskStackBuilder;
  28 import android.app.admin.DevicePolicyManager;
  29 import android.content.BroadcastReceiver;
  30 import android.content.ComponentName;
  31 import android.content.Context;
  32 import android.content.Intent;
  33 import android.content.IntentFilter;
  34 import android.content.pm.ApplicationInfo;
  35 import android.content.pm.PackageManager;
  36 import android.content.pm.PackageManager.NameNotFoundException;
  37 import android.content.pm.ResolveInfo;
  38 import android.content.pm.UserInfo;
  39 import android.content.res.Configuration;
  40 import android.content.res.Resources;
  41 import android.database.ContentObserver;
  42 import android.graphics.PorterDuff;
  43 import android.graphics.drawable.Drawable;
  44 import android.os.AsyncTask;
  45 import android.os.Build;
  46 import android.os.Handler;
  47 import android.os.IBinder;
  48 import android.os.Message;
  49 import android.os.PowerManager;
  50 import android.os.RemoteException;
  51 import android.os.ServiceManager;
  52 import android.os.UserHandle;
  53 import android.os.UserManager;
  54 import android.provider.Settings;
  55 import android.service.dreams.DreamService;
  56 import android.service.dreams.IDreamManager;
  57 import android.service.notification.NotificationListenerService;
  58 import android.service.notification.NotificationListenerService.RankingMap;
  59 import android.service.notification.StatusBarNotification;
  60 import android.text.TextUtils;
  61 import android.util.Log;
  62 import android.util.Slog;
  63 import android.util.SparseArray;
  64 import android.util.SparseBooleanArray;
  65 import android.view.Display;
  66 import android.view.IWindowManager;
  67 import android.view.LayoutInflater;
  68 import android.view.MotionEvent;
  69 import android.view.View;
  70 import android.view.ViewAnimationUtils;
  71 import android.view.ViewGroup;
  72 import android.view.ViewGroup.LayoutParams;
  73 import android.view.ViewParent;
  74 import android.view.ViewStub;
  75 import android.view.WindowManager;
  76 import android.view.WindowManagerGlobal;
  77 import android.view.accessibility.AccessibilityManager;
  78 import android.view.animation.AnimationUtils;
  79 import android.widget.DateTimeView;
  80 import android.widget.ImageView;
  81 import android.widget.LinearLayout;
  82 import android.widget.RemoteViews;
  83 import android.widget.TextView;
  84
  85 import com.android.internal.statusbar.IStatusBarService;
  86 import com.android.internal.statusbar.StatusBarIcon;
  87 import com.android.internal.statusbar.StatusBarIconList;
  88 import com.android.internal.util.NotificationColorUtil;
  89 import com.android.internal.widget.LockPatternUtils;
  90 import com.android.systemui.R;
  91 import com.android.systemui.RecentsComponent;
  92 import com.android.systemui.SearchPanelView;
  93 import com.android.systemui.SwipeHelper;
  94 import com.android.systemui.SystemUI;
  95 import com.android.systemui.statusbar.NotificationData.Entry;
  96 import com.android.systemui.statusbar.phone.NavigationBarView;
  97 import com.android.systemui.statusbar.phone.StatusBarKeyguardViewManager;
  98 import com.android.systemui.statusbar.policy.HeadsUpNotificationView;
  99 import com.android.systemui.statusbar.policy.PreviewInflater;
 100 import com.android.systemui.statusbar.stack.NotificationStackScrollLayout;
 101
 102 import java.util.ArrayList;
 103 import java.util.List;
 104 import java.util.Locale;
 105
 106 import static com.android.keyguard.KeyguardHostView.OnDismissAction;
 107
 108 public abstract class BaseStatusBar extends SystemUI implements
 109         CommandQueue.Callbacks, ActivatableNotificationView.OnActivatedListener,
 110         RecentsComponent.Callbacks, ExpandableNotificationRow.ExpansionLogger,
 111         NotificationData.Environment {
 112     public static final String TAG = "StatusBar";
 113     public static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
 114     public static final boolean MULTIUSER_DEBUG = false;
 115
 116     // STOPSHIP disable once we resolve b/18102199
 117     private static final boolean NOTIFICATION_CLICK_DEBUG = true;
 118
 119     protected static final int MSG_SHOW_RECENT_APPS = 1019;
 120     protected static final int MSG_HIDE_RECENT_APPS = 1020;
 121     protected static final int MSG_TOGGLE_RECENTS_APPS = 1021;
 122     protected static final int MSG_PRELOAD_RECENT_APPS = 1022;
 123     protected static final int MSG_CANCEL_PRELOAD_RECENT_APPS = 1023;
 124     protected static final int MSG_SHOW_NEXT_AFFILIATED_TASK = 1024;
 125     protected static final int MSG_SHOW_PREV_AFFILIATED_TASK = 1025;
 126     protected static final int MSG_CLOSE_SEARCH_PANEL = 1027;
 127     protected static final int MSG_SHOW_HEADS_UP = 1028;
 128     protected static final int MSG_HIDE_HEADS_UP = 1029;
 129     protected static final int MSG_ESCALATE_HEADS_UP = 1030;
 130     protected static final int MSG_DECAY_HEADS_UP = 1031;
 131
 132     protected static final boolean ENABLE_HEADS_UP = true;
 133     // scores above this threshold should be displayed in heads up mode.
 134     protected static final int INTERRUPTION_THRESHOLD = 10;
 135     protected static final String SETTING_HEADS_UP_TICKER = "ticker_gets_heads_up";
 136
 137     // Should match the value in PhoneWindowManager
 138     public static final String SYSTEM_DIALOG_REASON_RECENT_APPS = "recentapps";
 139
 140     public static final int EXPANDED_LEAVE_ALONE = -10000;
 141     public static final int EXPANDED_FULL_OPEN = -10001;
 142
 143     private static final int HIDDEN_NOTIFICATION_ID = 10000;
 144     private static final String BANNER_ACTION_CANCEL =
 145             "com.android.systemui.statusbar.banner_action_cancel";
 146     private static final String BANNER_ACTION_SETUP =
 147             "com.android.systemui.statusbar.banner_action_setup";
 148
 149     protected CommandQueue mCommandQueue;
 150     protected IStatusBarService mBarService;
 151     protected H mHandler = createHandler();
 152
 153     // all notifications
 154     protected NotificationData mNotificationData;
 155     protected NotificationStackScrollLayout mStackScroller;
 156
 157     // for heads up notifications
 158     protected HeadsUpNotificationView mHeadsUpNotificationView;
 159     protected int mHeadsUpNotificationDecay;
 160
 161     // Search panel
 162     protected SearchPanelView mSearchPanelView;
 163
 164     protected int mCurrentUserId = 0;
 165     final protected SparseArray<UserInfo> mCurrentProfiles = new SparseArray<UserInfo>();
 166
 167     protected int mLayoutDirection = -1; // invalid
 168     protected AccessibilityManager mAccessibilityManager;
 169
 170     // on-screen navigation buttons
 171     protected NavigationBarView mNavigationBarView = null;
 172
 173     protected Boolean mScreenOn;
 174
 175     // The second field is a bit different from the first one because it only listens to screen on/
 176     // screen of events from Keyguard. We need this so we don't have a race condition with the
 177     // broadcast. In the future, we should remove the first field altogether and rename the second
 178     // field.
 179     protected boolean mScreenOnFromKeyguard;
 180
 181     protected boolean mVisible;
 182
 183     // mScreenOnFromKeyguard && mVisible.
 184     private boolean mVisibleToUser;
 185
 186     private Locale mLocale;
 187     private float mFontScale;
 188
 189     protected boolean mUseHeadsUp = false;
 190     protected boolean mHeadsUpTicker = false;
 191     protected boolean mDisableNotificationAlerts = false;
 192
 193     protected DevicePolicyManager mDevicePolicyManager;
 194     protected IDreamManager mDreamManager;
 195     PowerManager mPowerManager;
 196     protected StatusBarKeyguardViewManager mStatusBarKeyguardViewManager;
 197     protected int mRowMinHeight;
 198     protected int mRowMaxHeight;
 199
 200     // public mode, private notifications, etc
 201     private boolean mLockscreenPublicMode = false;
 202     private final SparseBooleanArray mUsersAllowingPrivateNotifications = new SparseBooleanArray();
 203     private NotificationColorUtil mNotificationColorUtil;
 204
 205     private UserManager mUserManager;
 206
 207     // UI-specific methods
 208
 209     /**
 210      * Create all windows necessary for the status bar (including navigation, overlay panels, etc)
 211      * and add them to the window manager.
 212      */
 213     protected abstract void createAndAddWindows();
 214
 215     protected WindowManager mWindowManager;
 216     protected IWindowManager mWindowManagerService;
 217
 218     protected abstract void refreshLayout(int layoutDirection);
 219
 220     protected Display mDisplay;
 221
 222     private boolean mDeviceProvisioned = false;
 223
 224     private RecentsComponent mRecents;
 225
 226     protected int mZenMode;
 227
 228     // which notification is currently being longpress-examined by the user
 229     private NotificationGuts mNotificationGutsExposed;
 230
 231     private TimeInterpolator mLinearOutSlowIn, mFastOutLinearIn;
 232
 233     /**
 234      * The {@link StatusBarState} of the status bar.
 235      */
 236     protected int mState;
 237     protected boolean mBouncerShowing;
 238     protected boolean mShowLockscreenNotifications;
 239
 240     protected NotificationOverflowContainer mKeyguardIconOverflowContainer;
 241     protected DismissView mDismissView;
 242     protected EmptyShadeView mEmptyShadeView;
 243
 244     @Override  // NotificationData.Environment
 245     public boolean isDeviceProvisioned() {
 246         return mDeviceProvisioned;
 247     }
 248
 249     protected final ContentObserver mSettingsObserver = new ContentObserver(mHandler) {
 250         @Override
 251         public void onChange(boolean selfChange) {
 252             final boolean provisioned = 0 != Settings.Global.getInt(
 253                     mContext.getContentResolver(), Settings.Global.DEVICE_PROVISIONED, 0);
 254             if (provisioned != mDeviceProvisioned) {
 255                 mDeviceProvisioned = provisioned;
 256                 updateNotifications();
 257             }
 258             final int mode = Settings.Global.getInt(mContext.getContentResolver(),
 259                     Settings.Global.ZEN_MODE, Settings.Global.ZEN_MODE_OFF);
 260             setZenMode(mode);
 261
 262             updateLockscreenNotificationSetting();
 263         }
 264     };
 265
 266     private final ContentObserver mLockscreenSettingsObserver = new ContentObserver(mHandler) {
 267         @Override
 268         public void onChange(boolean selfChange) {
 269             // We don't know which user changed LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
 270             // so we just dump our cache ...
 271             mUsersAllowingPrivateNotifications.clear();
 272             // ... and refresh all the notifications
 273             updateNotifications();
 274         }
 275     };
 276
 277     private RemoteViews.OnClickHandler mOnClickHandler = new RemoteViews.OnClickHandler() {
 278         @Override
 279         public boolean onClickHandler(
 280                 final View view, final PendingIntent pendingIntent, final Intent fillInIntent) {
 281             if (DEBUG) {
 282                 Log.v(TAG, "Notification click handler invoked for intent: " + pendingIntent);
 283             }
 284             logActionClick(view);
 285             // The intent we are sending is for the application, which
 286             // won't have permission to immediately start an activity after
 287             // the user switches to home.  We know it is safe to do at this
 288             // point, so make sure new activity switches are now allowed.
 289             try {
 290                 ActivityManagerNative.getDefault().resumeAppSwitches();
 291             } catch (RemoteException e) {
 292             }
 293             final boolean isActivity = pendingIntent.isActivity();
 294             if (isActivity) {
 295                 final boolean keyguardShowing = mStatusBarKeyguardViewManager.isShowing();
 296                 final boolean afterKeyguardGone = PreviewInflater.wouldLaunchResolverActivity(
 297                         mContext, pendingIntent.getIntent(), mCurrentUserId);
 298                 dismissKeyguardThenExecute(new OnDismissAction() {
 299                     @Override
 300                     public boolean onDismiss() {
 301                         if (keyguardShowing && !afterKeyguardGone) {
 302                             try {
 303                                 ActivityManagerNative.getDefault()
 304                                         .keyguardWaitingForActivityDrawn();
 305                             } catch (RemoteException e) {
 306                             }
 307                         }
 308
 309                         boolean handled = superOnClickHandler(view, pendingIntent, fillInIntent);
 310                         overrideActivityPendingAppTransition(keyguardShowing && !afterKeyguardGone);
 311
 312                         // close the shade if it was open
 313                         if (handled) {
 314                             animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_RECENTS_PANEL,
 315                                     true /* force */);
 316                             visibilityChanged(false);
 317                         }
 318                         // Wait for activity start.
 319                         return handled;
 320                     }
 321                 }, afterKeyguardGone);
 322                 return true;
 323             } else {
 324                 return super.onClickHandler(view, pendingIntent, fillInIntent);
 325             }
 326         }
 327
 328         private void logActionClick(View view) {
 329             ViewParent parent = view.getParent();
 330             String key = getNotificationKeyForParent(parent);
 331             if (key == null) {
 332                 Log.w(TAG, "Couldn't determine notification for click.");
 333                 return;
 334             }
 335             int index = -1;
 336             // If this is a default template, determine the index of the button.
 337             if (view.getId() == com.android.internal.R.id.action0 &&
 338                     parent != null && parent instanceof ViewGroup) {
 339                 ViewGroup actionGroup = (ViewGroup) parent;
 340                 index = actionGroup.indexOfChild(view);
 341             }
 342             if (NOTIFICATION_CLICK_DEBUG) {
 343                 Log.d(TAG, "Clicked on button " + index + " for " + key);
 344             }
 345             try {
 346                 mBarService.onNotificationActionClick(key, index);
 347             } catch (RemoteException e) {
 348                 // Ignore
 349             }
 350         }
 351
 352         private String getNotificationKeyForParent(ViewParent parent) {
 353             while (parent != null) {
 354                 if (parent instanceof ExpandableNotificationRow) {
 355                     return ((ExpandableNotificationRow) parent).getStatusBarNotification().getKey();
 356                 }
 357                 parent = parent.getParent();
 358             }
 359             return null;
 360         }
 361
 362         private boolean superOnClickHandler(View view, PendingIntent pendingIntent,
 363                 Intent fillInIntent) {
 364             return super.onClickHandler(view, pendingIntent, fillInIntent);
 365         }
 366     };
 367
 368     private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
 369         @Override
 370         public void onReceive(Context context, Intent intent) {
 371             String action = intent.getAction();
 372             if (Intent.ACTION_USER_SWITCHED.equals(action)) {
 373                 mCurrentUserId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, -1);
 374                 updateCurrentProfilesCache();
 375                 if (true) Log.v(TAG, "userId " + mCurrentUserId + " is in the house");
 376
 377                 updateLockscreenNotificationSetting();
 378
 379                 userSwitched(mCurrentUserId);
 380             } else if (Intent.ACTION_USER_ADDED.equals(action)) {
 381                 updateCurrentProfilesCache();
 382             } else if (DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED.equals(
 383                     action)) {
 384                 mUsersAllowingPrivateNotifications.clear();
 385                 updateLockscreenNotificationSetting();
 386                 updateNotifications();
 387             } else if (BANNER_ACTION_CANCEL.equals(action) || BANNER_ACTION_SETUP.equals(action)) {
 388                 NotificationManager noMan = (NotificationManager)
 389                         mContext.getSystemService(Context.NOTIFICATION_SERVICE);
 390                 noMan.cancel(HIDDEN_NOTIFICATION_ID);
 391
 392                 Settings.Secure.putInt(mContext.getContentResolver(),
 393                         Settings.Secure.SHOW_NOTE_ABOUT_NOTIFICATION_HIDING, 0);
 394                 if (BANNER_ACTION_SETUP.equals(action)) {
 395                     animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_RECENTS_PANEL,
 396                             true /* force */);
 397                     mContext.startActivity(new Intent(Settings.ACTION_APP_NOTIFICATION_REDACTION)
 398                             .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
 399
 400                     );
 401                 }
 402             }
 403         }
 404     };
 405
 406     private final NotificationListenerService mNotificationListener =
 407             new NotificationListenerService() {
 408         @Override
 409         public void onListenerConnected() {
 410             if (DEBUG) Log.d(TAG, "onListenerConnected");
 411             final StatusBarNotification[] notifications = getActiveNotifications();
 412             final RankingMap currentRanking = getCurrentRanking();
 413             mHandler.post(new Runnable() {
 414                 @Override
 415                 public void run() {
 416                     for (StatusBarNotification sbn : notifications) {
 417                         addNotification(sbn, currentRanking);
 418                     }
 419                 }
 420             });
 421         }
 422
 423         @Override
 424         public void onNotificationPosted(final StatusBarNotification sbn,
 425                 final RankingMap rankingMap) {
 426             if (DEBUG) Log.d(TAG, "onNotificationPosted: " + sbn);
 427             mHandler.post(new Runnable() {
 428                 @Override
 429                 public void run() {
 430                     Notification n = sbn.getNotification();
 431                     boolean isUpdate = mNotificationData.get(sbn.getKey()) != null
 432                             || isHeadsUp(sbn.getKey());
 433
 434                     // Ignore children of notifications that have a summary, since we're not
 435                     // going to show them anyway. This is true also when the summary is canceled,
 436                     // because children are automatically canceled by NoMan in that case.
 437                     if (n.isGroupChild() &&
 438                             mNotificationData.isGroupWithSummary(sbn.getGroupKey())) {
 439                         if (DEBUG) {
 440                             Log.d(TAG, "Ignoring group child due to existing summary: " + sbn);
 441                         }
 442
 443                         // Remove existing notification to avoid stale data.
 444                         if (isUpdate) {
 445                             removeNotification(sbn.getKey(), rankingMap);
 446                         } else {
 447                             mNotificationData.updateRanking(rankingMap);
 448                         }
 449                         return;
 450                     }
 451                     if (isUpdate) {
 452                         updateNotification(sbn, rankingMap);
 453                     } else {
 454                         addNotification(sbn, rankingMap);
 455                     }
 456                 }
 457             });
 458         }
 459
 460         @Override
 461         public void onNotificationRemoved(final StatusBarNotification sbn,
 462                 final RankingMap rankingMap) {
 463             if (DEBUG) Log.d(TAG, "onNotificationRemoved: " + sbn);
 464             mHandler.post(new Runnable() {
 465                 @Override
 466                 public void run() {
 467                     removeNotification(sbn.getKey(), rankingMap);
 468                 }
 469             });
 470         }
 471
 472         @Override
 473         public void onNotificationRankingUpdate(final RankingMap rankingMap) {
 474             if (DEBUG) Log.d(TAG, "onRankingUpdate");
 475             mHandler.post(new Runnable() {
 476                 @Override
 477                 public void run() {
 478                     updateNotificationRanking(rankingMap);
 479                 }
 480             });
 481         }
 482
 483     };
 484
 485     private void updateCurrentProfilesCache() {
 486         synchronized (mCurrentProfiles) {
 487             mCurrentProfiles.clear();
 488             if (mUserManager != null) {
 489                 for (UserInfo user : mUserManager.getProfiles(mCurrentUserId)) {
 490                     mCurrentProfiles.put(user.id, user);
 491                 }
 492             }
 493         }
 494     }
 495
 496     public void start() {
 497         mWindowManager = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
 498         mWindowManagerService = WindowManagerGlobal.getWindowManagerService();
 499         mDisplay = mWindowManager.getDefaultDisplay();
 500         mDevicePolicyManager = (DevicePolicyManager)mContext.getSystemService(
 501                 Context.DEVICE_POLICY_SERVICE);
 502
 503         mNotificationColorUtil = NotificationColorUtil.getInstance(mContext);
 504
 505         mNotificationData = new NotificationData(this);
 506
 507         mAccessibilityManager = (AccessibilityManager)
 508                 mContext.getSystemService(Context.ACCESSIBILITY_SERVICE);
 509
 510         mDreamManager = IDreamManager.Stub.asInterface(
 511                 ServiceManager.checkService(DreamService.DREAM_SERVICE));
 512         mPowerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
 513
 514         mSettingsObserver.onChange(false); // set up
 515         mContext.getContentResolver().registerContentObserver(
 516                 Settings.Global.getUriFor(Settings.Global.DEVICE_PROVISIONED), true,
 517                 mSettingsObserver);
 518         mContext.getContentResolver().registerContentObserver(
 519                 Settings.Global.getUriFor(Settings.Global.ZEN_MODE), false,
 520                 mSettingsObserver);
 521         mContext.getContentResolver().registerContentObserver(
 522                 Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS), false,
 523                 mSettingsObserver,
 524                 UserHandle.USER_ALL);
 525
 526         mContext.getContentResolver().registerContentObserver(
 527                 Settings.Secure.getUriFor(Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS),
 528                 true,
 529                 mLockscreenSettingsObserver,
 530                 UserHandle.USER_ALL);
 531
 532         mBarService = IStatusBarService.Stub.asInterface(
 533                 ServiceManager.getService(Context.STATUS_BAR_SERVICE));
 534
 535         mRecents = getComponent(RecentsComponent.class);
 536         mRecents.setCallback(this);
 537
 538         final Configuration currentConfig = mContext.getResources().getConfiguration();
 539         mLocale = currentConfig.locale;
 540         mLayoutDirection = TextUtils.getLayoutDirectionFromLocale(mLocale);
 541         mFontScale = currentConfig.fontScale;
 542
 543         mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
 544
 545         mLinearOutSlowIn = AnimationUtils.loadInterpolator(mContext,
 546                 android.R.interpolator.linear_out_slow_in);
 547         mFastOutLinearIn = AnimationUtils.loadInterpolator(mContext,
 548                 android.R.interpolator.fast_out_linear_in);
 549
 550         // Connect in to the status bar manager service
 551         StatusBarIconList iconList = new StatusBarIconList();
 552         mCommandQueue = new CommandQueue(this, iconList);
 553
 554         int[] switches = new int[8];
 555         ArrayList<IBinder> binders = new ArrayList<IBinder>();
 556         try {
 557             mBarService.registerStatusBar(mCommandQueue, iconList, switches, binders);
 558         } catch (RemoteException ex) {
 559             // If the system process isn't there we're doomed anyway.
 560         }
 561
 562         createAndAddWindows();
 563
 564         disable(switches[0], false /* animate */);
 565         setSystemUiVisibility(switches[1], 0xffffffff);
 566         topAppWindowChanged(switches[2] != 0);
 567         // StatusBarManagerService has a back up of IME token and it's restored here.
 568         setImeWindowStatus(binders.get(0), switches[3], switches[4], switches[5] != 0);
 569
 570         // Set up the initial icon state
 571         int N = iconList.size();
 572         int viewIndex = 0;
 573         for (int i=0; i<N; i++) {
 574             StatusBarIcon icon = iconList.getIcon(i);
 575             if (icon != null) {
 576                 addIcon(iconList.getSlot(i), i, viewIndex, icon);
 577                 viewIndex++;
 578             }
 579         }
 580
 581         // Set up the initial notification state.
 582         try {
 583             mNotificationListener.registerAsSystemService(mContext,
 584                     new ComponentName(mContext.getPackageName(), getClass().getCanonicalName()),
 585                     UserHandle.USER_ALL);
 586         } catch (RemoteException e) {
 587             Log.e(TAG, "Unable to register notification listener", e);
 588         }
 589
 590
 591         if (DEBUG) {
 592             Log.d(TAG, String.format(
 593                     "init: icons=%d disabled=0x%08x lights=0x%08x menu=0x%08x imeButton=0x%08x",
 594                    iconList.size(),
 595                    switches[0],
 596                    switches[1],
 597                    switches[2],
 598                    switches[3]
 599                    ));
 600         }
 601
 602         mCurrentUserId = ActivityManager.getCurrentUser();
 603         setHeadsUpUser(mCurrentUserId);
 604
 605         IntentFilter filter = new IntentFilter();
 606         filter.addAction(Intent.ACTION_USER_SWITCHED);
 607         filter.addAction(Intent.ACTION_USER_ADDED);
 608         filter.addAction(BANNER_ACTION_CANCEL);
 609         filter.addAction(BANNER_ACTION_SETUP);
 610         filter.addAction(DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED);
 611         mContext.registerReceiver(mBroadcastReceiver, filter);
 612
 613         updateCurrentProfilesCache();
 614     }
 615
 616     protected void notifyUserAboutHiddenNotifications() {
 617         if (0 != Settings.Secure.getInt(mContext.getContentResolver(),
 618                 Settings.Secure.SHOW_NOTE_ABOUT_NOTIFICATION_HIDING, 1)) {
 619             Log.d(TAG, "user hasn't seen notification about hidden notifications");
 620             final LockPatternUtils lockPatternUtils = new LockPatternUtils(mContext);
 621             if (!lockPatternUtils.isSecure()) {
 622                 Log.d(TAG, "insecure lockscreen, skipping notification");
 623                 Settings.Secure.putInt(mContext.getContentResolver(),
 624                         Settings.Secure.SHOW_NOTE_ABOUT_NOTIFICATION_HIDING, 0);
 625                 return;
 626             }
 627             Log.d(TAG, "disabling lockecreen notifications and alerting the user");
 628             // disable lockscreen notifications until user acts on the banner.
 629             Settings.Secure.putInt(mContext.getContentResolver(),
 630                     Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, 0);
 631             Settings.Secure.putInt(mContext.getContentResolver(),
 632                     Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 0);
 633
 634             final String packageName = mContext.getPackageName();
 635             PendingIntent cancelIntent = PendingIntent.getBroadcast(mContext, 0,
 636                     new Intent(BANNER_ACTION_CANCEL).setPackage(packageName),
 637                     PendingIntent.FLAG_CANCEL_CURRENT);
 638             PendingIntent setupIntent = PendingIntent.getBroadcast(mContext, 0,
 639                     new Intent(BANNER_ACTION_SETUP).setPackage(packageName),
 640                     PendingIntent.FLAG_CANCEL_CURRENT);
 641
 642             final Resources res = mContext.getResources();
 643             final int colorRes = com.android.internal.R.color.system_notification_accent_color;
 644             Notification.Builder note = new Notification.Builder(mContext)
 645                     .setSmallIcon(R.drawable.ic_android)
 646                     .setContentTitle(mContext.getString(R.string.hidden_notifications_title))
 647                     .setContentText(mContext.getString(R.string.hidden_notifications_text))
 648                     .setPriority(Notification.PRIORITY_HIGH)
 649                     .setOngoing(true)
 650                     .setColor(res.getColor(colorRes))
 651                     .setContentIntent(setupIntent)
 652                     .addAction(R.drawable.ic_close,
 653                             mContext.getString(R.string.hidden_notifications_cancel),
 654                             cancelIntent)
 655                     .addAction(R.drawable.ic_settings,
 656                             mContext.getString(R.string.hidden_notifications_setup),
 657                             setupIntent);
 658
 659             NotificationManager noMan =
 660                     (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
 661             noMan.notify(HIDDEN_NOTIFICATION_ID, note.build());
 662         }
 663     }
 664
 665     public void userSwitched(int newUserId) {
 666         setHeadsUpUser(newUserId);
 667     }
 668
 669     private void setHeadsUpUser(int newUserId) {
 670         if (mHeadsUpNotificationView != null) {
 671             mHeadsUpNotificationView.setUser(newUserId);
 672         }
 673     }
 674
 675     public boolean isHeadsUp(String key) {
 676       return mHeadsUpNotificationView != null && mHeadsUpNotificationView.isShowing(key);
 677     }
 678
 679     @Override  // NotificationData.Environment
 680     public boolean isNotificationForCurrentProfiles(StatusBarNotification n) {
 681         final int thisUserId = mCurrentUserId;
 682         final int notificationUserId = n.getUserId();
 683         if (DEBUG && MULTIUSER_DEBUG) {
 684             Log.v(TAG, String.format("%s: current userid: %d, notification userid: %d",
 685                     n, thisUserId, notificationUserId));
 686         }
 687         return isCurrentProfile(notificationUserId);
 688     }
 689
 690     protected boolean isCurrentProfile(int userId) {
 691         synchronized (mCurrentProfiles) {
 692             return userId == UserHandle.USER_ALL || mCurrentProfiles.get(userId) != null;
 693         }
 694     }
 695
 696     @Override
 697     public String getCurrentMediaNotificationKey() {
 698         return null;
 699     }
 700
 701     /**
 702      * Takes the necessary steps to prepare the status bar for starting an activity, then starts it.
 703      * @param action A dismiss action that is called if it's safe to start the activity.
 704      * @param afterKeyguardGone Whether the action should be executed after the Keyguard is gone.
 705      */
 706     protected void dismissKeyguardThenExecute(OnDismissAction action, boolean afterKeyguardGone) {
 707         action.onDismiss();
 708     }
 709
 710     @Override
 711     protected void onConfigurationChanged(Configuration newConfig) {
 712         final Locale locale = mContext.getResources().getConfiguration().locale;
 713         final int ld = TextUtils.getLayoutDirectionFromLocale(locale);
 714         final float fontScale = newConfig.fontScale;
 715
 716         if (! locale.equals(mLocale) || ld != mLayoutDirection || fontScale != mFontScale) {
 717             if (DEBUG) {
 718                 Log.v(TAG, String.format(
 719                         "config changed locale/LD: %s (%d) -> %s (%d)", mLocale, mLayoutDirection,
 720                         locale, ld));
 721             }
 722             mLocale = locale;
 723             mLayoutDirection = ld;
 724             refreshLayout(ld);
 725         }
 726     }
 727
 728     protected View updateNotificationVetoButton(View row, StatusBarNotification n) {
 729         View vetoButton = row.findViewById(R.id.veto);
 730         if (n.isClearable() || (mHeadsUpNotificationView.getEntry() != null
 731                 && mHeadsUpNotificationView.getEntry().row == row)) {
 732             final String _pkg = n.getPackageName();
 733             final String _tag = n.getTag();
 734             final int _id = n.getId();
 735             final int _userId = n.getUserId();
 736             vetoButton.setOnClickListener(new View.OnClickListener() {
 737                     public void onClick(View v) {
 738                         // Accessibility feedback
 739                         v.announceForAccessibility(
 740                                 mContext.getString(R.string.accessibility_notification_dismissed));
 741                         try {
 742                             mBarService.onNotificationClear(_pkg, _tag, _id, _userId);
 743
 744                         } catch (RemoteException ex) {
 745                             // system process is dead if we're here.
 746                         }
 747                     }
 748                 });
 749             vetoButton.setVisibility(View.VISIBLE);
 750         } else {
 751             vetoButton.setVisibility(View.GONE);
 752         }
 753         vetoButton.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_NO);
 754         return vetoButton;
 755     }
 756
 757
 758     protected void applyColorsAndBackgrounds(StatusBarNotification sbn,
 759             NotificationData.Entry entry) {
 760
 761         if (entry.expanded.getId() != com.android.internal.R.id.status_bar_latest_event_content) {
 762             // Using custom RemoteViews
 763             if (entry.targetSdk >= Build.VERSION_CODES.GINGERBREAD
 764                     && entry.targetSdk < Build.VERSION_CODES.LOLLIPOP) {
 765                 entry.row.setShowingLegacyBackground(true);
 766                 entry.legacy = true;
 767             }
 768         } else {
 769             // Using platform templates
 770             final int color = sbn.getNotification().color;
 771             if (isMediaNotification(entry)) {
 772                 entry.row.setTintColor(color == Notification.COLOR_DEFAULT
 773                         ? mContext.getResources().getColor(
 774                                 R.color.notification_material_background_media_default_color)
 775                         : color);
 776             }
 777         }
 778
 779         if (entry.icon != null) {
 780             if (entry.targetSdk >= Build.VERSION_CODES.LOLLIPOP) {
 781                 entry.icon.setColorFilter(mContext.getResources().getColor(android.R.color.white));
 782             } else {
 783                 entry.icon.setColorFilter(null);
 784             }
 785         }
 786     }
 787
 788     public boolean isMediaNotification(NotificationData.Entry entry) {
 789         // TODO: confirm that there's a valid media key
 790         return entry.expandedBig != null &&
 791                entry.expandedBig.findViewById(com.android.internal.R.id.media_actions) != null;
 792     }
 793
 794     // The gear button in the guts that links to the app's own notification settings
 795     private void startAppOwnNotificationSettingsActivity(Intent intent,
 796             final int notificationId, final String notificationTag, final int appUid) {
 797         intent.putExtra("notification_id", notificationId);
 798         intent.putExtra("notification_tag", notificationTag);
 799         startNotificationGutsIntent(intent, appUid);
 800     }
 801
 802     // The (i) button in the guts that links to the system notification settings for that app
 803     private void startAppNotificationSettingsActivity(String packageName, final int appUid) {
 804         final Intent intent = new Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS);
 805         intent.putExtra(Settings.EXTRA_APP_PACKAGE, packageName);
 806         intent.putExtra(Settings.EXTRA_APP_UID, appUid);
 807         startNotificationGutsIntent(intent, appUid);
 808     }
 809
 810     private void startNotificationGutsIntent(final Intent intent, final int appUid) {
 811         final boolean keyguardShowing = mStatusBarKeyguardViewManager.isShowing();
 812         dismissKeyguardThenExecute(new OnDismissAction() {
 813             @Override
 814             public boolean onDismiss() {
 815                 AsyncTask.execute(new Runnable() {
 816                     public void run() {
 817                         try {
 818                             if (keyguardShowing) {
 819                                 ActivityManagerNative.getDefault()
 820                                         .keyguardWaitingForActivityDrawn();
 821                             }
 822                             TaskStackBuilder.create(mContext)
 823                                     .addNextIntentWithParentStack(intent)
 824                                     .startActivities(null,
 825                                             new UserHandle(UserHandle.getUserId(appUid)));
 826                             overrideActivityPendingAppTransition(keyguardShowing);
 827                         } catch (RemoteException e) {
 828                         }
 829                     }
 830                 });
 831                 animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_RECENTS_PANEL, true /* force */);
 832                 return true;
 833             }
 834         }, false /* afterKeyguardGone */);
 835     }
 836
 837     private void inflateGuts(ExpandableNotificationRow row) {
 838         ViewStub stub = (ViewStub) row.findViewById(R.id.notification_guts_stub);
 839         if (stub != null) {
 840             stub.inflate();
 841         }
 842         final StatusBarNotification sbn = row.getStatusBarNotification();
 843         PackageManager pmUser = getPackageManagerForUser(
 844                 sbn.getUser().getIdentifier());
 845         row.setTag(sbn.getPackageName());
 846         final View guts = row.findViewById(R.id.notification_guts);
 847         final String pkg = sbn.getPackageName();
 848         String appname = pkg;
 849         Drawable pkgicon = null;
 850         int appUid = -1;
 851         try {
 852             final ApplicationInfo info = pmUser.getApplicationInfo(pkg,
 853                     PackageManager.GET_UNINSTALLED_PACKAGES
 854                             | PackageManager.GET_DISABLED_COMPONENTS);
 855             if (info != null) {
 856                 appname = String.valueOf(pmUser.getApplicationLabel(info));
 857                 pkgicon = pmUser.getApplicationIcon(info);
 858                 appUid = info.uid;
 859             }
 860         } catch (NameNotFoundException e) {
 861             // app is gone, just show package name and generic icon
 862             pkgicon = pmUser.getDefaultActivityIcon();
 863         }
 864         ((ImageView) row.findViewById(android.R.id.icon)).setImageDrawable(pkgicon);
 865         ((DateTimeView) row.findViewById(R.id.timestamp)).setTime(sbn.getPostTime());
 866         ((TextView) row.findViewById(R.id.pkgname)).setText(appname);
 867         final View settingsButton = guts.findViewById(R.id.notification_inspect_item);
 868         final View appSettingsButton
 869                 = guts.findViewById(R.id.notification_inspect_app_provided_settings);
 870         if (appUid >= 0) {
 871             final int appUidF = appUid;
 872             settingsButton.setOnClickListener(new View.OnClickListener() {
 873                 public void onClick(View v) {
 874                     startAppNotificationSettingsActivity(pkg, appUidF);
 875                 }
 876             });
 877
 878             final Intent appSettingsQueryIntent
 879                     = new Intent(Intent.ACTION_MAIN)
 880                     .addCategory(Notification.INTENT_CATEGORY_NOTIFICATION_PREFERENCES)
 881                     .setPackage(pkg);
 882             List<ResolveInfo> infos = pmUser.queryIntentActivities(appSettingsQueryIntent, 0);
 883             if (infos.size() > 0) {
 884                 appSettingsButton.setVisibility(View.VISIBLE);
 885                 appSettingsButton.setContentDescription(
 886                         mContext.getResources().getString(
 887                                 R.string.status_bar_notification_app_settings_title,
 888                                 appname
 889                         ));
 890                 final Intent appSettingsLaunchIntent = new Intent(appSettingsQueryIntent)
 891                         .setClassName(pkg, infos.get(0).activityInfo.name);
 892                 appSettingsButton.setOnClickListener(new View.OnClickListener() {
 893                     public void onClick(View v) {
 894                         startAppOwnNotificationSettingsActivity(appSettingsLaunchIntent,
 895                                 sbn.getId(),
 896                                 sbn.getTag(),
 897                                 appUidF);
 898                     }
 899                 });
 900             } else {
 901                 appSettingsButton.setVisibility(View.GONE);
 902             }
 903         } else {
 904             settingsButton.setVisibility(View.GONE);
 905             appSettingsButton.setVisibility(View.GONE);
 906         }
 907
 908     }
 909
 910     protected SwipeHelper.LongPressListener getNotificationLongClicker() {
 911         return new SwipeHelper.LongPressListener() {
 912             @Override
 913             public boolean onLongPress(View v, int x, int y) {
 914                 dismissPopups();
 915
 916                 if (!(v instanceof ExpandableNotificationRow)) {
 917                     return false;
 918                 }
 919                 if (v.getWindowToken() == null) {
 920                     Log.e(TAG, "Trying to show notification guts, but not attached to window");
 921                     return false;
 922                 }
 923
 924                 inflateGuts((ExpandableNotificationRow) v);
 925
 926                 // Assume we are a status_bar_notification_row
 927                 final NotificationGuts guts = (NotificationGuts) v.findViewById(
 928                         R.id.notification_guts);
 929                 if (guts == null) {
 930                     // This view has no guts. Examples are the more card or the dismiss all view
 931                     return false;
 932                 }
 933
 934                 // Already showing?
 935                 if (guts.getVisibility() == View.VISIBLE) {
 936                     Log.e(TAG, "Trying to show notification guts, but already visible");
 937                     return false;
 938                 }
 939
 940                 guts.setVisibility(View.VISIBLE);
 941                 final double horz = Math.max(guts.getWidth() - x, x);
 942                 final double vert = Math.max(guts.getActualHeight() - y, y);
 943                 final float r = (float) Math.hypot(horz, vert);
 944                 final Animator a
 945                         = ViewAnimationUtils.createCircularReveal(guts, x, y, 0, r);
 946                 a.setDuration(400);
 947                 a.setInterpolator(mLinearOutSlowIn);
 948                 a.start();
 949
 950                 mNotificationGutsExposed = guts;
 951
 952                 return true;
 953             }
 954         };
 955     }
 956
 957     public void dismissPopups() {
 958         if (mNotificationGutsExposed != null) {
 959             final NotificationGuts v = mNotificationGutsExposed;
 960             mNotificationGutsExposed = null;
 961
 962             if (v.getWindowToken() == null) return;
 963
 964             final int x = (v.getLeft() + v.getRight()) / 2;
 965             final int y = (v.getTop() + v.getActualHeight() / 2);
 966             final Animator a = ViewAnimationUtils.createCircularReveal(v,
 967                     x, y, x, 0);
 968             a.setDuration(200);
 969             a.setInterpolator(mFastOutLinearIn);
 970             a.addListener(new AnimatorListenerAdapter() {
 971                 @Override
 972                 public void onAnimationEnd(Animator animation) {
 973                     super.onAnimationEnd(animation);
 974                     v.setVisibility(View.GONE);
 975                 }
 976             });
 977             a.start();
 978         }
 979     }
 980
 981     public void onHeadsUpDismissed() {
 982     }
 983
 984     @Override
 985     public void showRecentApps(boolean triggeredFromAltTab) {
 986         int msg = MSG_SHOW_RECENT_APPS;
 987         mHandler.removeMessages(msg);
 988         mHandler.obtainMessage(msg, triggeredFromAltTab ? 1 : 0, 0).sendToTarget();
 989     }
 990
 991     @Override
 992     public void hideRecentApps(boolean triggeredFromAltTab, boolean triggeredFromHomeKey) {
 993         int msg = MSG_HIDE_RECENT_APPS;
 994         mHandler.removeMessages(msg);
 995         mHandler.obtainMessage(msg, triggeredFromAltTab ? 1 : 0,
 996                 triggeredFromHomeKey ? 1 : 0).sendToTarget();
 997     }
 998
 999     @Override
1000     public void toggleRecentApps() {
1001         int msg = MSG_TOGGLE_RECENTS_APPS;
1002         mHandler.removeMessages(msg);
1003         mHandler.sendEmptyMessage(msg);
1004     }
1005
1006     @Override
1007     public void preloadRecentApps() {
1008         int msg = MSG_PRELOAD_RECENT_APPS;
1009         mHandler.removeMessages(msg);
1010         mHandler.sendEmptyMessage(msg);
1011     }
1012
1013     @Override
1014     public void cancelPreloadRecentApps() {
1015         int msg = MSG_CANCEL_PRELOAD_RECENT_APPS;
1016         mHandler.removeMessages(msg);
1017         mHandler.sendEmptyMessage(msg);
1018     }
1019
1020     /** Jumps to the next affiliated task in the group. */
1021     public void showNextAffiliatedTask() {
1022         int msg = MSG_SHOW_NEXT_AFFILIATED_TASK;
1023         mHandler.removeMessages(msg);
1024         mHandler.sendEmptyMessage(msg);
1025     }
1026
1027     /** Jumps to the previous affiliated task in the group. */
1028     public void showPreviousAffiliatedTask() {
1029         int msg = MSG_SHOW_PREV_AFFILIATED_TASK;
1030         mHandler.removeMessages(msg);
1031         mHandler.sendEmptyMessage(msg);
1032     }
1033
1034     @Override
1035     public void showSearchPanel() {
1036         if (mSearchPanelView != null && mSearchPanelView.isAssistantAvailable()) {
1037             mSearchPanelView.show(true, true);
1038         }
1039     }
1040
1041     @Override
1042     public void hideSearchPanel() {
1043         int msg = MSG_CLOSE_SEARCH_PANEL;
1044         mHandler.removeMessages(msg);
1045         mHandler.sendEmptyMessage(msg);
1046     }
1047
1048     protected abstract WindowManager.LayoutParams getSearchLayoutParams(
1049             LayoutParams layoutParams);
1050
1051     protected void updateSearchPanel() {
1052         // Search Panel
1053         boolean visible = false;
1054         if (mSearchPanelView != null) {
1055             visible = mSearchPanelView.isShowing();
1056             mWindowManager.removeView(mSearchPanelView);
1057         }
1058
1059         // Provide SearchPanel with a temporary parent to allow layout params to work.
1060         LinearLayout tmpRoot = new LinearLayout(mContext);
1061         mSearchPanelView = (SearchPanelView) LayoutInflater.from(mContext).inflate(
1062                  R.layout.status_bar_search_panel, tmpRoot, false);
1063         mSearchPanelView.setOnTouchListener(
1064                  new TouchOutsideListener(MSG_CLOSE_SEARCH_PANEL, mSearchPanelView));
1065         mSearchPanelView.setVisibility(View.GONE);
1066         boolean vertical = mNavigationBarView != null && mNavigationBarView.isVertical();
1067         mSearchPanelView.setHorizontal(vertical);
1068
1069         WindowManager.LayoutParams lp = getSearchLayoutParams(mSearchPanelView.getLayoutParams());
1070
1071         mWindowManager.addView(mSearchPanelView, lp);
1072         mSearchPanelView.setBar(this);
1073         if (visible) {
1074             mSearchPanelView.show(true, false);
1075         }
1076     }
1077
1078     protected H createHandler() {
1079          return new H();
1080     }
1081
1082     static void sendCloseSystemWindows(Context context, String reason) {
1083         if (ActivityManagerNative.isSystemReady()) {
1084             try {
1085                 ActivityManagerNative.getDefault().closeSystemDialogs(reason);
1086             } catch (RemoteException e) {
1087             }
1088         }
1089     }
1090
1091     protected abstract View getStatusBarView();
1092
1093     protected View.OnTouchListener mRecentsPreloadOnTouchListener = new View.OnTouchListener() {
1094         // additional optimization when we have software system buttons - start loading the recent
1095         // tasks on touch down
1096         @Override
1097         public boolean onTouch(View v, MotionEvent event) {
1098             int action = event.getAction() & MotionEvent.ACTION_MASK;
1099             if (action == MotionEvent.ACTION_DOWN) {
1100                 preloadRecents();
1101             } else if (action == MotionEvent.ACTION_CANCEL) {
1102                 cancelPreloadingRecents();
1103             } else if (action == MotionEvent.ACTION_UP) {
1104                 if (!v.isPressed()) {
1105                     cancelPreloadingRecents();
1106                 }
1107
1108             }
1109             return false;
1110         }
1111     };
1112
1113     /** Proxy for RecentsComponent */
1114
1115     protected void showRecents(boolean triggeredFromAltTab) {
1116         if (mRecents != null) {
1117             sendCloseSystemWindows(mContext, SYSTEM_DIALOG_REASON_RECENT_APPS);
1118             mRecents.showRecents(triggeredFromAltTab, getStatusBarView());
1119         }
1120     }
1121
1122     protected void hideRecents(boolean triggeredFromAltTab, boolean triggeredFromHomeKey) {
1123         if (mRecents != null) {
1124             mRecents.hideRecents(triggeredFromAltTab, triggeredFromHomeKey);
1125         }
1126     }
1127
1128     protected void toggleRecents() {
1129         if (mRecents != null) {
1130             sendCloseSystemWindows(mContext, SYSTEM_DIALOG_REASON_RECENT_APPS);
1131             mRecents.toggleRecents(mDisplay, mLayoutDirection, getStatusBarView());
1132         }
1133     }
1134
1135     protected void preloadRecents() {
1136         if (mRecents != null) {
1137             mRecents.preloadRecents();
1138         }
1139     }
1140
1141     protected void cancelPreloadingRecents() {
1142         if (mRecents != null) {
1143             mRecents.cancelPreloadingRecents();
1144         }
1145     }
1146
1147     protected void showRecentsNextAffiliatedTask() {
1148         if (mRecents != null) {
1149             mRecents.showNextAffiliatedTask();
1150         }
1151     }
1152
1153     protected void showRecentsPreviousAffiliatedTask() {
1154         if (mRecents != null) {
1155             mRecents.showPrevAffiliatedTask();
1156         }
1157     }
1158
1159     @Override
1160     public void onVisibilityChanged(boolean visible) {
1161         // Do nothing
1162     }
1163
1164     public abstract void resetHeadsUpDecayTimer();
1165
1166     public abstract void scheduleHeadsUpOpen();
1167
1168     public abstract void scheduleHeadsUpClose();
1169
1170     public abstract void scheduleHeadsUpEscalation();
1171
1172     /**
1173      * Save the current "public" (locked and secure) state of the lockscreen.
1174      */
1175     public void setLockscreenPublicMode(boolean publicMode) {
1176         mLockscreenPublicMode = publicMode;
1177     }
1178
1179     public boolean isLockscreenPublicMode() {
1180         return mLockscreenPublicMode;
1181     }
1182
1183     /**
1184      * Has the given user chosen to allow their private (full) notifications to be shown even
1185      * when the lockscreen is in "public" (secure & locked) mode?
1186      */
1187     public boolean userAllowsPrivateNotificationsInPublic(int userHandle) {
1188         if (userHandle == UserHandle.USER_ALL) {
1189             return true;
1190         }
1191
1192         if (mUsersAllowingPrivateNotifications.indexOfKey(userHandle) < 0) {
1193             final boolean allowed = 0 != Settings.Secure.getIntForUser(
1194                     mContext.getContentResolver(),
1195                     Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 0, userHandle);
1196             final int dpmFlags = mDevicePolicyManager.getKeyguardDisabledFeatures(null /* admin */,
1197                     userHandle);
1198             final boolean allowedByDpm = (dpmFlags
1199                     & DevicePolicyManager.KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS) == 0;
1200             mUsersAllowingPrivateNotifications.append(userHandle, allowed && allowedByDpm);
1201             return allowed;
1202         }
1203
1204         return mUsersAllowingPrivateNotifications.get(userHandle);
1205     }
1206
1207     /**
1208      * Returns true if we're on a secure lockscreen and the user wants to hide "sensitive"
1209      * notification data. If so, private notifications should show their (possibly
1210      * auto-generated) publicVersion, and secret notifications should be totally invisible.
1211      */
1212     @Override  // NotificationData.Environment
1213     public boolean shouldHideSensitiveContents(int userid) {
1214         return isLockscreenPublicMode() && !userAllowsPrivateNotificationsInPublic(userid);
1215     }
1216
1217     public void onNotificationClear(StatusBarNotification notification) {
1218         try {
1219             mBarService.onNotificationClear(
1220                     notification.getPackageName(),
1221                     notification.getTag(),
1222                     notification.getId(),
1223                     notification.getUserId());
1224         } catch (android.os.RemoteException ex) {
1225             // oh well
1226         }
1227     }
1228
1229     protected class H extends Handler {
1230         public void handleMessage(Message m) {
1231             switch (m.what) {
1232              case MSG_SHOW_RECENT_APPS:
1233                  showRecents(m.arg1 > 0);
1234                  break;
1235              case MSG_HIDE_RECENT_APPS:
1236                  hideRecents(m.arg1 > 0, m.arg2 > 0);
1237                  break;
1238              case MSG_TOGGLE_RECENTS_APPS:
1239                  toggleRecents();
1240                  break;
1241              case MSG_PRELOAD_RECENT_APPS:
1242                   preloadRecents();
1243                   break;
1244              case MSG_CANCEL_PRELOAD_RECENT_APPS:
1245                   cancelPreloadingRecents();
1246                   break;
1247              case MSG_SHOW_NEXT_AFFILIATED_TASK:
1248                   showRecentsNextAffiliatedTask();
1249                   break;
1250              case MSG_SHOW_PREV_AFFILIATED_TASK:
1251                   showRecentsPreviousAffiliatedTask();
1252                   break;
1253              case MSG_CLOSE_SEARCH_PANEL:
1254                  if (DEBUG) Log.d(TAG, "closing search panel");
1255                  if (mSearchPanelView != null && mSearchPanelView.isShowing()) {
1256                      mSearchPanelView.show(false, true);
1257                  }
1258                  break;
1259             }
1260         }
1261     }
1262
1263     public class TouchOutsideListener implements View.OnTouchListener {
1264         private int mMsg;
1265         private StatusBarPanel mPanel;
1266
1267         public TouchOutsideListener(int msg, StatusBarPanel panel) {
1268             mMsg = msg;
1269             mPanel = panel;
1270         }
1271
1272         public boolean onTouch(View v, MotionEvent ev) {
1273             final int action = ev.getAction();
1274             if (action == MotionEvent.ACTION_OUTSIDE
1275                 || (action == MotionEvent.ACTION_DOWN
1276                     && !mPanel.isInContentArea((int)ev.getX(), (int)ev.getY()))) {
1277                 mHandler.removeMessages(mMsg);
1278                 mHandler.sendEmptyMessage(mMsg);
1279                 return true;
1280             }
1281             return false;
1282         }
1283     }
1284
1285     protected void workAroundBadLayerDrawableOpacity(View v) {
1286     }
1287
1288     private boolean inflateViews(NotificationData.Entry entry, ViewGroup parent) {
1289             return inflateViews(entry, parent, false);
1290     }
1291
1292     protected boolean inflateViewsForHeadsUp(NotificationData.Entry entry, ViewGroup parent) {
1293             return inflateViews(entry, parent, true);
1294     }
1295
1296     private boolean inflateViews(NotificationData.Entry entry, ViewGroup parent, boolean isHeadsUp) {
1297         PackageManager pmUser = getPackageManagerForUser(
1298                 entry.notification.getUser().getIdentifier());
1299
1300         int maxHeight = mRowMaxHeight;
1301         final StatusBarNotification sbn = entry.notification;
1302         RemoteViews contentView = sbn.getNotification().contentView;
1303         RemoteViews bigContentView = sbn.getNotification().bigContentView;
1304
1305         if (isHeadsUp) {
1306             maxHeight =
1307                     mContext.getResources().getDimensionPixelSize(R.dimen.notification_mid_height);
1308             bigContentView = sbn.getNotification().headsUpContentView;
1309         }
1310
1311         if (contentView == null) {
1312             return false;
1313         }
1314
1315         if (DEBUG) {
1316             Log.v(TAG, "publicNotification: " + sbn.getNotification().publicVersion);
1317         }
1318
1319         Notification publicNotification = sbn.getNotification().publicVersion;
1320
1321         ExpandableNotificationRow row;
1322
1323         // Stash away previous user expansion state so we can restore it at
1324         // the end.
1325         boolean hasUserChangedExpansion = false;
1326         boolean userExpanded = false;
1327         boolean userLocked = false;
1328
1329         if (entry.row != null) {
1330             row = entry.row;
1331             hasUserChangedExpansion = row.hasUserChangedExpansion();
1332             userExpanded = row.isUserExpanded();
1333             userLocked = row.isUserLocked();
1334             entry.reset();
1335             if (hasUserChangedExpansion) {
1336                 row.setUserExpanded(userExpanded);
1337             }
1338         } else {
1339             // create the row view
1340             LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(
1341                     Context.LAYOUT_INFLATER_SERVICE);
1342             row = (ExpandableNotificationRow) inflater.inflate(R.layout.status_bar_notification_row,
1343                     parent, false);
1344             row.setExpansionLogger(this, entry.notification.getKey());
1345         }
1346
1347         workAroundBadLayerDrawableOpacity(row);
1348         View vetoButton = updateNotificationVetoButton(row, sbn);
1349         vetoButton.setContentDescription(mContext.getString(
1350                 R.string.accessibility_remove_notification));
1351
1352         // NB: the large icon is now handled entirely by the template
1353
1354         // bind the click event to the content area
1355         NotificationContentView expanded =
1356                 (NotificationContentView) row.findViewById(R.id.expanded);
1357         NotificationContentView expandedPublic =
1358                 (NotificationContentView) row.findViewById(R.id.expandedPublic);
1359
1360         row.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
1361
1362         PendingIntent contentIntent = sbn.getNotification().contentIntent;
1363         if (contentIntent != null) {
1364             final View.OnClickListener listener = makeClicker(contentIntent, sbn.getKey(),
1365                     isHeadsUp);
1366             row.setOnClickListener(listener);
1367         } else {
1368             row.setOnClickListener(null);
1369         }
1370
1371         // set up the adaptive layout
1372         View contentViewLocal = null;
1373         View bigContentViewLocal = null;
1374         try {
1375             contentViewLocal = contentView.apply(mContext, expanded,
1376                     mOnClickHandler);
1377             if (bigContentView != null) {
1378                 bigContentViewLocal = bigContentView.apply(mContext, expanded,
1379                         mOnClickHandler);
1380             }
1381         }
1382         catch (RuntimeException e) {
1383             final String ident = sbn.getPackageName() + "/0x" + Integer.toHexString(sbn.getId());
1384             Log.e(TAG, "couldn't inflate view for notification " + ident, e);
1385             return false;
1386         }
1387
1388         if (contentViewLocal != null) {
1389             contentViewLocal.setIsRootNamespace(true);
1390             expanded.setContractedChild(contentViewLocal);
1391         }
1392         if (bigContentViewLocal != null) {
1393             bigContentViewLocal.setIsRootNamespace(true);
1394             expanded.setExpandedChild(bigContentViewLocal);
1395         }
1396
1397         // now the public version
1398         View publicViewLocal = null;
1399         if (publicNotification != null) {
1400             try {
1401                 publicViewLocal = publicNotification.contentView.apply(mContext, expandedPublic,
1402                         mOnClickHandler);
1403
1404                 if (publicViewLocal != null) {
1405                     publicViewLocal.setIsRootNamespace(true);
1406                     expandedPublic.setContractedChild(publicViewLocal);
1407                 }
1408             }
1409             catch (RuntimeException e) {
1410                 final String ident = sbn.getPackageName() + "/0x" + Integer.toHexString(sbn.getId());
1411                 Log.e(TAG, "couldn't inflate public view for notification " + ident, e);
1412                 publicViewLocal = null;
1413             }
1414         }
1415
1416         // Extract target SDK version.
1417         try {
1418             ApplicationInfo info = pmUser.getApplicationInfo(sbn.getPackageName(), 0);
1419             entry.targetSdk = info.targetSdkVersion;
1420         } catch (NameNotFoundException ex) {
1421             Log.e(TAG, "Failed looking up ApplicationInfo for " + sbn.getPackageName(), ex);
1422         }
1423
1424         if (publicViewLocal == null) {
1425             // Add a basic notification template
1426             publicViewLocal = LayoutInflater.from(mContext).inflate(
1427                     R.layout.notification_public_default,
1428                     expandedPublic, false);
1429             publicViewLocal.setIsRootNamespace(true);
1430             expandedPublic.setContractedChild(publicViewLocal);
1431
1432             final TextView title = (TextView) publicViewLocal.findViewById(R.id.title);
1433             try {
1434                 title.setText(pmUser.getApplicationLabel(
1435                         pmUser.getApplicationInfo(entry.notification.getPackageName(), 0)));
1436             } catch (NameNotFoundException e) {
1437                 title.setText(entry.notification.getPackageName());
1438             }
1439
1440             final ImageView icon = (ImageView) publicViewLocal.findViewById(R.id.icon);
1441             final ImageView profileBadge = (ImageView) publicViewLocal.findViewById(
1442                     R.id.profile_badge_line3);
1443
1444             final StatusBarIcon ic = new StatusBarIcon(entry.notification.getPackageName(),
1445                     entry.notification.getUser(),
1446                     entry.notification.getNotification().icon,
1447                     entry.notification.getNotification().iconLevel,
1448                     entry.notification.getNotification().number,
1449                     entry.notification.getNotification().tickerText);
1450
1451             Drawable iconDrawable = StatusBarIconView.getIcon(mContext, ic);
1452             icon.setImageDrawable(iconDrawable);
1453             if (entry.targetSdk >= Build.VERSION_CODES.LOLLIPOP
1454                     || mNotificationColorUtil.isGrayscaleIcon(iconDrawable)) {
1455                 icon.setBackgroundResource(
1456                         com.android.internal.R.drawable.notification_icon_legacy_bg);
1457                 int padding = mContext.getResources().getDimensionPixelSize(
1458                         com.android.internal.R.dimen.notification_large_icon_circle_padding);
1459                 icon.setPadding(padding, padding, padding, padding);
1460                 if (sbn.getNotification().color != Notification.COLOR_DEFAULT) {
1461                     icon.getBackground().setColorFilter(
1462                             sbn.getNotification().color, PorterDuff.Mode.SRC_ATOP);
1463                 }
1464             }
1465
1466             if (profileBadge != null) {
1467                 Drawable profileDrawable = mContext.getPackageManager().getUserBadgeForDensity(
1468                         entry.notification.getUser(), 0);
1469                 if (profileDrawable != null) {
1470                     profileBadge.setImageDrawable(profileDrawable);
1471                     profileBadge.setVisibility(View.VISIBLE);
1472                 } else {
1473                     profileBadge.setVisibility(View.GONE);
1474                 }
1475             }
1476
1477             final View privateTime = contentViewLocal.findViewById(com.android.internal.R.id.time);
1478             final DateTimeView time = (DateTimeView) publicViewLocal.findViewById(R.id.time);
1479             if (privateTime != null && privateTime.getVisibility() == View.VISIBLE) {
1480                 time.setVisibility(View.VISIBLE);
1481                 time.setTime(entry.notification.getNotification().when);
1482             }
1483
1484             final TextView text = (TextView) publicViewLocal.findViewById(R.id.text);
1485             if (text != null) {
1486                 text.setText(R.string.notification_hidden_text);
1487                 text.setTextAppearance(mContext,
1488                         R.style.TextAppearance_Material_Notification_Parenthetical);
1489             }
1490
1491             int topPadding = Notification.Builder.calculateTopPadding(mContext,
1492                     false /* hasThreeLines */,
1493                     mContext.getResources().getConfiguration().fontScale);
1494             title.setPadding(0, topPadding, 0, 0);
1495
1496             entry.autoRedacted = true;
1497         }
1498
1499         if (MULTIUSER_DEBUG) {
1500             TextView debug = (TextView) row.findViewById(R.id.debug_info);
1501             if (debug != null) {
1502                 debug.setVisibility(View.VISIBLE);
1503                 debug.setText("CU " + mCurrentUserId +" NU " + entry.notification.getUserId());
1504             }
1505         }
1506         entry.row = row;
1507         entry.row.setHeightRange(mRowMinHeight, maxHeight);
1508         entry.row.setOnActivatedListener(this);
1509         entry.expanded = contentViewLocal;
1510         entry.expandedPublic = publicViewLocal;
1511         entry.setBigContentView(bigContentViewLocal);
1512
1513         applyColorsAndBackgrounds(sbn, entry);
1514
1515         // Restore previous flags.
1516         if (hasUserChangedExpansion) {
1517             // Note: setUserExpanded() conveniently ignores calls with
1518             //       userExpanded=true if !isExpandable().
1519             row.setUserExpanded(userExpanded);
1520         }
1521         row.setUserLocked(userLocked);
1522         row.setStatusBarNotification(entry.notification);
1523         return true;
1524     }
1525
1526     public NotificationClicker makeClicker(PendingIntent intent, String notificationKey,
1527             boolean forHun) {
1528         return new NotificationClicker(intent, notificationKey, forHun);
1529     }
1530
1531     protected class NotificationClicker implements View.OnClickListener {
1532         private PendingIntent mIntent;
1533         private final String mNotificationKey;
1534         private boolean mIsHeadsUp;
1535
1536         public NotificationClicker(PendingIntent intent, String notificationKey, boolean forHun) {
1537             mIntent = intent;
1538             mNotificationKey = notificationKey;
1539             mIsHeadsUp = forHun;
1540         }
1541
1542         public void onClick(final View v) {
1543             if (NOTIFICATION_CLICK_DEBUG) {
1544                 Log.d(TAG, "Clicked on content of " + mNotificationKey);
1545             }
1546             final boolean keyguardShowing = mStatusBarKeyguardViewManager.isShowing();
1547             final boolean afterKeyguardGone = mIntent.isActivity()
1548                     && PreviewInflater.wouldLaunchResolverActivity(mContext, mIntent.getIntent(),
1549                             mCurrentUserId);
1550             dismissKeyguardThenExecute(new OnDismissAction() {
1551                 public boolean onDismiss() {
1552                     if (mIsHeadsUp) {
1553                         // Release the HUN notification to the shade.
1554                         //
1555                         // In most cases, when FLAG_AUTO_CANCEL is set, the notification will
1556                         // become canceled shortly by NoMan, but we can't assume that.
1557                         mHeadsUpNotificationView.releaseAndClose();
1558                     }
1559                     new Thread() {
1560                         @Override
1561                         public void run() {
1562                             try {
1563                                 if (keyguardShowing && !afterKeyguardGone) {
1564                                     ActivityManagerNative.getDefault()
1565                                             .keyguardWaitingForActivityDrawn();
1566                                 }
1567
1568                                 // The intent we are sending is for the application, which
1569                                 // won't have permission to immediately start an activity after
1570                                 // the user switches to home.  We know it is safe to do at this
1571                                 // point, so make sure new activity switches are now allowed.
1572                                 ActivityManagerNative.getDefault().resumeAppSwitches();
1573                             } catch (RemoteException e) {
1574                             }
1575
1576                             if (mIntent != null) {
1577                                 try {
1578                                     mIntent.send();
1579                                 } catch (PendingIntent.CanceledException e) {
1580                                     // the stack trace isn't very helpful here.
1581                                     // Just log the exception message.
1582                                     Log.w(TAG, "Sending contentIntent failed: " + e);
1583
1584                                     // TODO: Dismiss Keyguard.
1585                                 }
1586                                 if (mIntent.isActivity()) {
1587                                     overrideActivityPendingAppTransition(keyguardShowing
1588                                             && !afterKeyguardGone);
1589                                 }
1590                             }
1591
1592                             try {
1593                                 mBarService.onNotificationClick(mNotificationKey);
1594                             } catch (RemoteException ex) {
1595                                 // system process is dead if we're here.
1596                             }
1597                         }
1598                     }.start();
1599
1600                     // close the shade if it was open
1601                     animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_RECENTS_PANEL,
1602                             true /* force */);
1603                     visibilityChanged(false);
1604
1605                     return mIntent != null && mIntent.isActivity();
1606                 }
1607             }, afterKeyguardGone);
1608         }
1609     }
1610
1611     public void animateCollapsePanels(int flags, boolean force) {
1612     }
1613
1614     public void overrideActivityPendingAppTransition(boolean keyguardShowing) {
1615         if (keyguardShowing) {
1616             try {
1617                 mWindowManagerService.overridePendingAppTransition(null, 0, 0, null);
1618             } catch (RemoteException e) {
1619                 Log.w(TAG, "Error overriding app transition: " + e);
1620             }
1621         }
1622     }
1623
1624     protected void visibilityChanged(boolean visible) {
1625         if (mVisible != visible) {
1626             mVisible = visible;
1627             if (!visible) {
1628                 dismissPopups();
1629             }
1630         }
1631         updateVisibleToUser();
1632     }
1633
1634     protected void updateVisibleToUser() {
1635         boolean oldVisibleToUser = mVisibleToUser;
1636         mVisibleToUser = mVisible && mScreenOnFromKeyguard;
1637
1638         if (oldVisibleToUser != mVisibleToUser) {
1639             handleVisibleToUserChanged(mVisibleToUser);
1640         }
1641     }
1642
1643     /**
1644      * The LEDs are turned off when the notification panel is shown, even just a little bit.
1645      * This was added last-minute and is inconsistent with the way the rest of the notifications
1646      * are handled, because the notification isn't really cancelled.  The lights are just
1647      * turned off.  If any other notifications happen, the lights will turn back on.  Steve says
1648      * this is what he wants. (see bug 1131461)
1649      */
1650     protected void handleVisibleToUserChanged(boolean visibleToUser) {
1651         try {
1652             if (visibleToUser) {
1653                 // Only stop blinking, vibrating, ringing when the user went into the shade
1654                 // manually (SHADE or SHADE_LOCKED).
1655                 boolean clearNotificationEffects =
1656                         (mState == StatusBarState.SHADE || mState == StatusBarState.SHADE_LOCKED);
1657                 mBarService.onPanelRevealed(clearNotificationEffects);
1658             } else {
1659                 mBarService.onPanelHidden();
1660             }
1661         } catch (RemoteException ex) {
1662             // Won't fail unless the world has ended.
1663         }
1664     }
1665
1666     /**
1667      * Cancel this notification and tell the StatusBarManagerService / NotificationManagerService
1668      * about the failure.
1669      *
1670      * WARNING: this will call back into us.  Don't hold any locks.
1671      */
1672     void handleNotificationError(StatusBarNotification n, String message) {
1673         removeNotification(n.getKey(), null);
1674         try {
1675             mBarService.onNotificationError(n.getPackageName(), n.getTag(), n.getId(), n.getUid(),
1676                     n.getInitialPid(), message, n.getUserId());
1677         } catch (RemoteException ex) {
1678             // The end is nigh.
1679         }
1680     }
1681
1682     protected StatusBarNotification removeNotificationViews(String key, RankingMap ranking) {
1683         NotificationData.Entry entry = mNotificationData.remove(key, ranking);
1684         if (entry == null) {
1685             Log.w(TAG, "removeNotification for unknown key: " + key);
1686             return null;
1687         }
1688         updateNotifications();
1689         return entry.notification;
1690     }
1691
1692     protected NotificationData.Entry createNotificationViews(StatusBarNotification sbn) {
1693         if (DEBUG) {
1694             Log.d(TAG, "createNotificationViews(notification=" + sbn);
1695         }
1696         // Construct the icon.
1697         Notification n = sbn.getNotification();
1698         final StatusBarIconView iconView = new StatusBarIconView(mContext,
1699                 sbn.getPackageName() + "/0x" + Integer.toHexString(sbn.getId()), n);
1700         iconView.setScaleType(ImageView.ScaleType.CENTER_INSIDE);
1701
1702         final StatusBarIcon ic = new StatusBarIcon(sbn.getPackageName(),
1703                 sbn.getUser(),
1704                     n.icon,
1705                     n.iconLevel,
1706                     n.number,
1707                     n.tickerText);
1708         if (!iconView.set(ic)) {
1709             handleNotificationError(sbn, "Couldn't create icon: " + ic);
1710             return null;
1711         }
1712         // Construct the expanded view.
1713         NotificationData.Entry entry = new NotificationData.Entry(sbn, iconView);
1714         if (!inflateViews(entry, mStackScroller)) {
1715             handleNotificationError(sbn, "Couldn't expand RemoteViews for: " + sbn);
1716             return null;
1717         }
1718         return entry;
1719     }
1720
1721     protected void addNotificationViews(Entry entry, RankingMap ranking) {
1722         if (entry == null) {
1723             return;
1724         }
1725         // Add the expanded view and icon.
1726         mNotificationData.add(entry, ranking);
1727         updateNotifications();
1728     }
1729
1730     /**
1731      * @return The number of notifications we show on Keyguard.
1732      */
1733     protected abstract int getMaxKeyguardNotifications();
1734
1735     /**
1736      * Updates expanded, dimmed and locked states of notification rows.
1737      */
1738     protected void updateRowStates() {
1739         int maxKeyguardNotifications = getMaxKeyguardNotifications();
1740         mKeyguardIconOverflowContainer.getIconsView().removeAllViews();
1741
1742         ArrayList<Entry> activeNotifications = mNotificationData.getActiveNotifications();
1743         final int N = activeNotifications.size();
1744
1745         int visibleNotifications = 0;
1746         boolean onKeyguard = mState == StatusBarState.KEYGUARD;
1747         for (int i = 0; i < N; i++) {
1748             NotificationData.Entry entry = activeNotifications.get(i);
1749             if (onKeyguard) {
1750                 entry.row.setExpansionDisabled(true);
1751             } else {
1752                 entry.row.setExpansionDisabled(false);
1753                 if (!entry.row.isUserLocked()) {
1754                     boolean top = (i == 0);
1755                     entry.row.setSystemExpanded(top);
1756                 }
1757             }
1758             boolean showOnKeyguard = shouldShowOnKeyguard(entry.notification);
1759             if ((isLockscreenPublicMode() && !mShowLockscreenNotifications) ||
1760                     (onKeyguard && (visibleNotifications >= maxKeyguardNotifications
1761                             || !showOnKeyguard))) {
1762                 entry.row.setVisibility(View.GONE);
1763                 if (onKeyguard && showOnKeyguard) {
1764                     mKeyguardIconOverflowContainer.getIconsView().addNotification(entry);
1765                 }
1766             } else {
1767                 boolean wasGone = entry.row.getVisibility() == View.GONE;
1768                 entry.row.setVisibility(View.VISIBLE);
1769                 if (wasGone) {
1770                     // notify the scroller of a child addition
1771                     mStackScroller.generateAddAnimation(entry.row, true /* fromMoreCard */);
1772                 }
1773                 visibleNotifications++;
1774             }
1775         }
1776
1777         if (onKeyguard && mKeyguardIconOverflowContainer.getIconsView().getChildCount() > 0) {
1778             mKeyguardIconOverflowContainer.setVisibility(View.VISIBLE);
1779         } else {
1780             mKeyguardIconOverflowContainer.setVisibility(View.GONE);
1781         }
1782
1783         mStackScroller.changeViewPosition(mKeyguardIconOverflowContainer,
1784                 mStackScroller.getChildCount() - 3);
1785         mStackScroller.changeViewPosition(mEmptyShadeView, mStackScroller.getChildCount() - 2);
1786         mStackScroller.changeViewPosition(mDismissView, mStackScroller.getChildCount() - 1);
1787     }
1788
1789     private boolean shouldShowOnKeyguard(StatusBarNotification sbn) {
1790         return mShowLockscreenNotifications && !mNotificationData.isAmbient(sbn.getKey());
1791     }
1792
1793     protected void setZenMode(int mode) {
1794         if (!isDeviceProvisioned()) return;
1795         mZenMode = mode;
1796         updateNotifications();
1797     }
1798
1799     // extended in PhoneStatusBar
1800     protected void setShowLockscreenNotifications(boolean show) {
1801         mShowLockscreenNotifications = show;
1802     }
1803
1804     private void updateLockscreenNotificationSetting() {
1805         final boolean show = Settings.Secure.getIntForUser(mContext.getContentResolver(),
1806                 Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS,
1807                 1,
1808                 mCurrentUserId) != 0;
1809         final int dpmFlags = mDevicePolicyManager.getKeyguardDisabledFeatures(
1810                 null /* admin */, mCurrentUserId);
1811         final boolean allowedByDpm = (dpmFlags
1812                 & DevicePolicyManager.KEYGUARD_DISABLE_SECURE_NOTIFICATIONS) == 0;
1813         setShowLockscreenNotifications(show && allowedByDpm);
1814     }
1815
1816     protected abstract void haltTicker();
1817     protected abstract void setAreThereNotifications();
1818     protected abstract void updateNotifications();
1819     protected abstract void tick(StatusBarNotification n, boolean firstTime);
1820     protected abstract void updateExpandedViewPos(int expandedPosition);
1821     protected abstract boolean shouldDisableNavbarGestures();
1822
1823     public abstract void addNotification(StatusBarNotification notification,
1824             RankingMap ranking);
1825     protected abstract void updateNotificationRanking(RankingMap ranking);
1826     public abstract void removeNotification(String key, RankingMap ranking);
1827
1828     public void updateNotification(StatusBarNotification notification, RankingMap ranking) {
1829         if (DEBUG) Log.d(TAG, "updateNotification(" + notification + ")");
1830
1831         final String key = notification.getKey();
1832         boolean wasHeadsUp = isHeadsUp(key);
1833         Entry oldEntry;
1834         if (wasHeadsUp) {
1835             oldEntry = mHeadsUpNotificationView.getEntry();
1836         } else {
1837             oldEntry = mNotificationData.get(key);
1838         }
1839         if (oldEntry == null) {
1840             return;
1841         }
1842
1843         final StatusBarNotification oldNotification = oldEntry.notification;
1844
1845         // XXX: modify when we do something more intelligent with the two content views
1846         final RemoteViews oldContentView = oldNotification.getNotification().contentView;
1847         Notification n = notification.getNotification();
1848         final RemoteViews contentView = n.contentView;
1849         final RemoteViews oldBigContentView = oldNotification.getNotification().bigContentView;
1850         final RemoteViews bigContentView = n.bigContentView;
1851         final RemoteViews oldHeadsUpContentView = oldNotification.getNotification().headsUpContentView;
1852         final RemoteViews headsUpContentView = n.headsUpContentView;
1853         final Notification oldPublicNotification = oldNotification.getNotification().publicVersion;
1854         final RemoteViews oldPublicContentView = oldPublicNotification != null
1855                 ? oldPublicNotification.contentView : null;
1856         final Notification publicNotification = n.publicVersion;
1857         final RemoteViews publicContentView = publicNotification != null
1858                 ? publicNotification.contentView : null;
1859
1860         if (DEBUG) {
1861             Log.d(TAG, "old notification: when=" + oldNotification.getNotification().when
1862                     + " ongoing=" + oldNotification.isOngoing()
1863                     + " expanded=" + oldEntry.expanded
1864                     + " contentView=" + oldContentView
1865                     + " bigContentView=" + oldBigContentView
1866                     + " publicView=" + oldPublicContentView
1867                     + " rowParent=" + oldEntry.row.getParent());
1868             Log.d(TAG, "new notification: when=" + n.when
1869                     + " ongoing=" + oldNotification.isOngoing()
1870                     + " contentView=" + contentView
1871                     + " bigContentView=" + bigContentView
1872                     + " publicView=" + publicContentView);
1873         }
1874
1875         // Can we just reapply the RemoteViews in place?
1876
1877         // 1U is never null
1878         boolean contentsUnchanged = oldEntry.expanded != null
1879                 && contentView.getPackage() != null
1880                 && oldContentView.getPackage() != null
1881                 && oldContentView.getPackage().equals(contentView.getPackage())
1882                 && oldContentView.getLayoutId() == contentView.getLayoutId();
1883         // large view may be null
1884         boolean bigContentsUnchanged =
1885                 (oldEntry.getBigContentView() == null && bigContentView == null)
1886                 || ((oldEntry.getBigContentView() != null && bigContentView != null)
1887                     && bigContentView.getPackage() != null
1888                     && oldBigContentView.getPackage() != null
1889                     && oldBigContentView.getPackage().equals(bigContentView.getPackage())
1890                     && oldBigContentView.getLayoutId() == bigContentView.getLayoutId());
1891         boolean headsUpContentsUnchanged =
1892                 (oldHeadsUpContentView == null && headsUpContentView == null)
1893                 || ((oldHeadsUpContentView != null && headsUpContentView != null)
1894                     && headsUpContentView.getPackage() != null
1895                     && oldHeadsUpContentView.getPackage() != null
1896                     && oldHeadsUpContentView.getPackage().equals(headsUpContentView.getPackage())
1897                     && oldHeadsUpContentView.getLayoutId() == headsUpContentView.getLayoutId());
1898         boolean publicUnchanged  =
1899                 (oldPublicContentView == null && publicContentView == null)
1900                 || ((oldPublicContentView != null && publicContentView != null)
1901                         && publicContentView.getPackage() != null
1902                         && oldPublicContentView.getPackage() != null
1903                         && oldPublicContentView.getPackage().equals(publicContentView.getPackage())
1904                         && oldPublicContentView.getLayoutId() == publicContentView.getLayoutId());
1905         boolean updateTicker = n.tickerText != null
1906                 && !TextUtils.equals(n.tickerText,
1907                 oldEntry.notification.getNotification().tickerText);
1908
1909         final boolean shouldInterrupt = shouldInterrupt(notification);
1910         final boolean alertAgain = alertAgain(oldEntry, n);
1911         boolean updateSuccessful = false;
1912         if (contentsUnchanged && bigContentsUnchanged && headsUpContentsUnchanged
1913                 && publicUnchanged) {
1914             if (DEBUG) Log.d(TAG, "reusing notification for key: " + key);
1915             oldEntry.notification = notification;
1916             try {
1917                 if (oldEntry.icon != null) {
1918                     // Update the icon
1919                     final StatusBarIcon ic = new StatusBarIcon(notification.getPackageName(),
1920                             notification.getUser(),
1921                             n.icon,
1922                             n.iconLevel,
1923                             n.number,
1924                             n.tickerText);
1925                     oldEntry.icon.setNotification(n);
1926                     if (!oldEntry.icon.set(ic)) {
1927                         handleNotificationError(notification, "Couldn't update icon: " + ic);
1928                         return;
1929                     }
1930                 }
1931
1932                 if (wasHeadsUp) {
1933                     if (shouldInterrupt) {
1934                         updateHeadsUpViews(oldEntry, notification);
1935                         if (alertAgain) {
1936                             resetHeadsUpDecayTimer();
1937                         }
1938                     } else {
1939                         // we updated the notification above, so release to build a new shade entry
1940                         mHeadsUpNotificationView.releaseAndClose();
1941                         return;
1942                     }
1943                 } else {
1944                     if (shouldInterrupt && alertAgain) {
1945                         removeNotificationViews(key, ranking);
1946                         addNotification(notification, ranking);  //this will pop the headsup
1947                     } else {
1948                         updateNotificationViews(oldEntry, notification);
1949                     }
1950                 }
1951                 mNotificationData.updateRanking(ranking);
1952                 updateNotifications();
1953                 updateSuccessful = true;
1954             }
1955             catch (RuntimeException e) {
1956                 // It failed to add cleanly.  Log, and remove the view from the panel.
1957                 Log.w(TAG, "Couldn't reapply views for package " + contentView.getPackage(), e);
1958             }
1959         }
1960         if (!updateSuccessful) {
1961             if (DEBUG) Log.d(TAG, "not reusing notification for key: " + key);
1962             if (wasHeadsUp) {
1963                 if (shouldInterrupt) {
1964                     if (DEBUG) Log.d(TAG, "rebuilding heads up for key: " + key);
1965                     Entry newEntry = new Entry(notification, null);
1966                     ViewGroup holder = mHeadsUpNotificationView.getHolder();
1967                     if (inflateViewsForHeadsUp(newEntry, holder)) {
1968                         mHeadsUpNotificationView.showNotification(newEntry);
1969                         if (alertAgain) {
1970                             resetHeadsUpDecayTimer();
1971                         }
1972                     } else {
1973                         Log.w(TAG, "Couldn't create new updated headsup for package "
1974                                 + contentView.getPackage());
1975                     }
1976                 } else {
1977                     if (DEBUG) Log.d(TAG, "releasing heads up for key: " + key);
1978                     oldEntry.notification = notification;
1979                     mHeadsUpNotificationView.releaseAndClose();
1980                     return;
1981                 }
1982             } else {
1983                 if (shouldInterrupt && alertAgain) {
1984                     if (DEBUG) Log.d(TAG, "reposting to invoke heads up for key: " + key);
1985                     removeNotificationViews(key, ranking);
1986                     addNotification(notification, ranking);  //this will pop the headsup
1987                 } else {
1988                     if (DEBUG) Log.d(TAG, "rebuilding update in place for key: " + key);
1989                     oldEntry.notification = notification;
1990                     final StatusBarIcon ic = new StatusBarIcon(notification.getPackageName(),
1991                             notification.getUser(),
1992                             n.icon,
1993                             n.iconLevel,
1994                             n.number,
1995                             n.tickerText);
1996                     oldEntry.icon.setNotification(n);
1997                     oldEntry.icon.set(ic);
1998                     inflateViews(oldEntry, mStackScroller, wasHeadsUp);
1999                     mNotificationData.updateRanking(ranking);
2000                     updateNotifications();
2001                 }
2002             }
2003         }
2004
2005         // Update the veto button accordingly (and as a result, whether this row is
2006         // swipe-dismissable)
2007         updateNotificationVetoButton(oldEntry.row, notification);
2008
2009         // Is this for you?
2010         boolean isForCurrentUser = isNotificationForCurrentProfiles(notification);
2011         if (DEBUG) Log.d(TAG, "notification is " + (isForCurrentUser ? "" : "not ") + "for you");
2012
2013         // Restart the ticker if it's still running
2014         if (updateTicker && isForCurrentUser) {
2015             haltTicker();
2016             tick(notification, false);
2017         }
2018
2019         // Recalculate the position of the sliding windows and the titles.
2020         setAreThereNotifications();
2021         updateExpandedViewPos(EXPANDED_LEAVE_ALONE);
2022     }
2023
2024     private void updateNotificationViews(NotificationData.Entry entry,
2025             StatusBarNotification notification) {
2026         updateNotificationViews(entry, notification, false);
2027     }
2028
2029     private void updateHeadsUpViews(NotificationData.Entry entry,
2030             StatusBarNotification notification) {
2031         updateNotificationViews(entry, notification, true);
2032     }
2033
2034     private void updateNotificationViews(NotificationData.Entry entry,
2035             StatusBarNotification notification, boolean isHeadsUp) {
2036         final RemoteViews contentView = notification.getNotification().contentView;
2037         final RemoteViews bigContentView = isHeadsUp
2038                 ? notification.getNotification().headsUpContentView
2039                 : notification.getNotification().bigContentView;
2040         final Notification publicVersion = notification.getNotification().publicVersion;
2041         final RemoteViews publicContentView = publicVersion != null ? publicVersion.contentView
2042                 : null;
2043
2044         // Reapply the RemoteViews
2045         contentView.reapply(mContext, entry.expanded, mOnClickHandler);
2046         if (bigContentView != null && entry.getBigContentView() != null) {
2047             bigContentView.reapply(mContext, entry.getBigContentView(),
2048                     mOnClickHandler);
2049         }
2050         if (publicContentView != null && entry.getPublicContentView() != null) {
2051             publicContentView.reapply(mContext, entry.getPublicContentView(), mOnClickHandler);
2052         }
2053         // update the contentIntent
2054         final PendingIntent contentIntent = notification.getNotification().contentIntent;
2055         if (contentIntent != null) {
2056             final View.OnClickListener listener = makeClicker(contentIntent, notification.getKey(),
2057                     isHeadsUp);
2058             entry.row.setOnClickListener(listener);
2059         } else {
2060             entry.row.setOnClickListener(null);
2061         }
2062         entry.row.setStatusBarNotification(notification);
2063         entry.row.notifyContentUpdated();
2064         entry.row.resetHeight();
2065     }
2066
2067     protected void notifyHeadsUpScreenOn(boolean screenOn) {
2068         if (!screenOn) {
2069             scheduleHeadsUpEscalation();
2070         }
2071     }
2072
2073     private boolean alertAgain(Entry oldEntry, Notification newNotification) {
2074         return oldEntry == null || !oldEntry.hasInterrupted()
2075                 || (newNotification.flags & Notification.FLAG_ONLY_ALERT_ONCE) == 0;
2076     }
2077
2078     protected boolean shouldInterrupt(StatusBarNotification sbn) {
2079         if (mNotificationData.shouldFilterOut(sbn)) {
2080             if (DEBUG) {
2081                 Log.d(TAG, "Skipping HUN check for " + sbn.getKey() + " since it's filtered out.");
2082             }
2083             return false;
2084         }
2085
2086         if (mHeadsUpNotificationView.isSnoozed(sbn.getPackageName())) {
2087             return false;
2088         }
2089
2090         Notification notification = sbn.getNotification();
2091         // some predicates to make the boolean logic legible
2092         boolean isNoisy = (notification.defaults & Notification.DEFAULT_SOUND) != 0
2093                 || (notification.defaults & Notification.DEFAULT_VIBRATE) != 0
2094                 || notification.sound != null
2095                 || notification.vibrate != null;
2096         boolean isHighPriority = sbn.getScore() >= INTERRUPTION_THRESHOLD;
2097         boolean isFullscreen = notification.fullScreenIntent != null;
2098         boolean hasTicker = mHeadsUpTicker && !TextUtils.isEmpty(notification.tickerText);
2099         boolean isAllowed = notification.extras.getInt(Notification.EXTRA_AS_HEADS_UP,
2100                 Notification.HEADS_UP_ALLOWED) != Notification.HEADS_UP_NEVER;
2101         boolean accessibilityForcesLaunch = isFullscreen
2102                 && mAccessibilityManager.isTouchExplorationEnabled();
2103
2104         boolean interrupt = (isFullscreen || (isHighPriority && (isNoisy || hasTicker)))
2105                 && isAllowed
2106                 && !accessibilityForcesLaunch
2107                 && mPowerManager.isScreenOn()
2108                 && (!mStatusBarKeyguardViewManager.isShowing()
2109                         || mStatusBarKeyguardViewManager.isOccluded())
2110                 && !mStatusBarKeyguardViewManager.isInputRestricted();
2111         try {
2112             interrupt = interrupt && !mDreamManager.isDreaming();
2113         } catch (RemoteException e) {
2114             Log.d(TAG, "failed to query dream manager", e);
2115         }
2116         if (DEBUG) Log.d(TAG, "interrupt: " + interrupt);
2117         return interrupt;
2118     }
2119
2120     public void setInteracting(int barWindow, boolean interacting) {
2121         // hook for subclasses
2122     }
2123
2124     public void setBouncerShowing(boolean bouncerShowing) {
2125         mBouncerShowing = bouncerShowing;
2126     }
2127
2128     /**
2129      * @return Whether the security bouncer from Keyguard is showing.
2130      */
2131     public boolean isBouncerShowing() {
2132         return mBouncerShowing;
2133     }
2134
2135     public void destroy() {
2136         if (mSearchPanelView != null) {
2137             mWindowManager.removeViewImmediate(mSearchPanelView);
2138         }
2139         mContext.unregisterReceiver(mBroadcastReceiver);
2140         try {
2141             mNotificationListener.unregisterAsSystemService();
2142         } catch (RemoteException e) {
2143             // Ignore.
2144         }
2145     }
2146
2147     /**
2148      * @return a PackageManger for userId or if userId is < 0 (USER_ALL etc) then
2149      *         return PackageManager for mContext
2150      */
2151     protected PackageManager getPackageManagerForUser(int userId) {
2152         Context contextForUser = mContext;
2153         // UserHandle defines special userId as negative values, e.g. USER_ALL
2154         if (userId >= 0) {
2155             try {
2156                 // Create a context for the correct user so if a package isn't installed
2157                 // for user 0 we can still load information about the package.
2158                 contextForUser =
2159                         mContext.createPackageContextAsUser(mContext.getPackageName(),
2160                         Context.CONTEXT_RESTRICTED,
2161                         new UserHandle(userId));
2162             } catch (NameNotFoundException e) {
2163                 // Shouldn't fail to find the package name for system ui.
2164             }
2165         }
2166         return contextForUser.getPackageManager();
2167     }
2168
2169     @Override
2170     public void logNotificationExpansion(String key, boolean userAction, boolean expanded) {
2171         try {
2172             mBarService.onNotificationExpansionChanged(key, userAction, expanded);
2173         } catch (RemoteException e) {
2174             // Ignore.
2175         }
2176     }
2177
2178     public boolean isKeyguardSecure() {
2179         if (mStatusBarKeyguardViewManager == null) {
2180             // startKeyguard() hasn't been called yet, so we don't know.
2181             // Make sure anything that needs to know isKeyguardSecure() checks and re-checks this
2182             // value onVisibilityChanged().
2183             Slog.w(TAG, "isKeyguardSecure() called before startKeyguard(), returning false",
2184                     new Throwable());
2185             return false;
2186         }
2187         return mStatusBarKeyguardViewManager.isSecure();
2188     }
2189 }