/* * Copyright (C) 2010 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.systemui.statusbar.phone; import static android.app.StatusBarManager.NAVIGATION_HINT_BACK_ALT; import static android.app.StatusBarManager.NAVIGATION_HINT_IME_SHOWN; import static android.app.StatusBarManager.WINDOW_STATE_HIDDEN; import static android.app.StatusBarManager.WINDOW_STATE_SHOWING; import static android.app.StatusBarManager.windowStateToString; import static com.android.systemui.statusbar.phone.BarTransitions.MODE_LIGHTS_OUT; import static com.android.systemui.statusbar.phone.BarTransitions.MODE_OPAQUE; import static com.android.systemui.statusbar.phone.BarTransitions.MODE_SEMI_TRANSPARENT; import static com.android.systemui.statusbar.phone.BarTransitions.MODE_TRANSLUCENT; import static com.android.systemui.statusbar.phone.BarTransitions.MODE_TRANSPARENT; import static com.android.systemui.statusbar.phone.BarTransitions.MODE_WARNING; import android.animation.Animator; import android.animation.AnimatorListenerAdapter; import android.animation.TimeInterpolator; import android.annotation.NonNull; import android.app.ActivityManager; import android.app.ActivityManagerNative; import android.app.IActivityManager; import android.app.Notification; import android.app.PendingIntent; import android.app.StatusBarManager; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.res.Configuration; import android.content.res.Resources; import android.database.ContentObserver; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.ColorFilter; import android.graphics.PixelFormat; import android.graphics.Point; import android.graphics.PorterDuff; import android.graphics.PorterDuffXfermode; import android.graphics.Rect; import android.graphics.Xfermode; import android.graphics.drawable.ColorDrawable; import android.graphics.drawable.Drawable; import android.inputmethodservice.InputMethodService; import android.media.AudioAttributes; import android.media.MediaMetadata; import android.media.session.MediaController; import android.media.session.MediaSession; import android.media.session.MediaSessionManager; import android.media.session.PlaybackState; import android.os.AsyncTask; import android.os.Bundle; import android.os.Handler; import android.os.IBinder; import android.os.Message; import android.os.PowerManager; import android.os.RemoteException; import android.os.SystemClock; import android.os.UserHandle; import android.provider.Settings; import android.service.notification.NotificationListenerService; import android.service.notification.NotificationListenerService.RankingMap; import android.service.notification.StatusBarNotification; import android.util.ArraySet; import android.util.DisplayMetrics; import android.util.EventLog; import android.util.Log; import android.view.Display; import android.view.Gravity; import android.view.HardwareCanvas; import android.view.KeyEvent; import android.view.LayoutInflater; import android.view.MotionEvent; import android.view.VelocityTracker; import android.view.View; import android.view.ViewGroup; import android.view.ViewGroup.LayoutParams; import android.view.ViewPropertyAnimator; import android.view.ViewStub; import android.view.ViewTreeObserver; import android.view.WindowManager; import android.view.accessibility.AccessibilityEvent; import android.view.accessibility.AccessibilityManager; import android.view.animation.AccelerateDecelerateInterpolator; import android.view.animation.AccelerateInterpolator; import android.view.animation.Animation; import android.view.animation.AnimationUtils; import android.view.animation.DecelerateInterpolator; import android.view.animation.Interpolator; import android.view.animation.LinearInterpolator; import android.view.animation.PathInterpolator; import android.widget.FrameLayout; import android.widget.ImageView; import android.widget.LinearLayout; import android.widget.TextView; import com.android.internal.statusbar.StatusBarIcon; import com.android.keyguard.KeyguardHostView.OnDismissAction; import com.android.keyguard.ViewMediatorCallback; import com.android.systemui.BatteryMeterView; import com.android.systemui.DemoMode; import com.android.systemui.EventLogTags; import com.android.systemui.FontSizeUtils; import com.android.systemui.R; import com.android.systemui.doze.DozeHost; import com.android.systemui.doze.DozeLog; import com.android.systemui.keyguard.KeyguardViewMediator; import com.android.systemui.qs.QSPanel; import com.android.systemui.statusbar.ActivatableNotificationView; import com.android.systemui.statusbar.BackDropView; import com.android.systemui.statusbar.BaseStatusBar; import com.android.systemui.statusbar.CommandQueue; import com.android.systemui.statusbar.DismissView; import com.android.systemui.statusbar.DragDownHelper; import com.android.systemui.statusbar.EmptyShadeView; import com.android.systemui.statusbar.ExpandableNotificationRow; import com.android.systemui.statusbar.GestureRecorder; import com.android.systemui.statusbar.KeyguardIndicationController; import com.android.systemui.statusbar.NotificationData; import com.android.systemui.statusbar.NotificationData.Entry; import com.android.systemui.statusbar.NotificationOverflowContainer; import com.android.systemui.statusbar.ScrimView; import com.android.systemui.statusbar.SignalClusterView; import com.android.systemui.statusbar.SpeedBumpView; import com.android.systemui.statusbar.StatusBarIconView; import com.android.systemui.statusbar.StatusBarState; import com.android.systemui.statusbar.policy.AccessibilityController; import com.android.systemui.statusbar.policy.BatteryController; import com.android.systemui.statusbar.policy.BatteryController.BatteryStateChangeCallback; import com.android.systemui.statusbar.policy.BluetoothControllerImpl; import com.android.systemui.statusbar.policy.BrightnessMirrorController; import com.android.systemui.statusbar.policy.CastControllerImpl; import com.android.systemui.statusbar.policy.FlashlightController; import com.android.systemui.statusbar.policy.HeadsUpNotificationView; import com.android.systemui.statusbar.policy.HotspotControllerImpl; import com.android.systemui.statusbar.policy.KeyButtonView; import com.android.systemui.statusbar.policy.KeyguardMonitor; import com.android.systemui.statusbar.policy.KeyguardUserSwitcher; import com.android.systemui.statusbar.policy.LocationControllerImpl; import com.android.systemui.statusbar.policy.NetworkControllerImpl; import com.android.systemui.statusbar.policy.NextAlarmController; import com.android.systemui.statusbar.policy.PreviewInflater; import com.android.systemui.statusbar.policy.RotationLockControllerImpl; import com.android.systemui.statusbar.policy.SecurityControllerImpl; import com.android.systemui.statusbar.policy.UserInfoController; import com.android.systemui.statusbar.policy.UserSwitcherController; import com.android.systemui.statusbar.policy.ZenModeController; import com.android.systemui.statusbar.stack.NotificationStackScrollLayout; import com.android.systemui.statusbar.stack.NotificationStackScrollLayout.OnChildLocationsChangedListener; import com.android.systemui.statusbar.stack.StackScrollAlgorithm; import com.android.systemui.statusbar.stack.StackScrollState.ViewState; import com.android.systemui.volume.VolumeComponent; import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; public class PhoneStatusBar extends BaseStatusBar implements DemoMode, DragDownHelper.DragDownCallback, ActivityStarter { static final String TAG = "PhoneStatusBar"; public static final boolean DEBUG = BaseStatusBar.DEBUG; public static final boolean SPEW = false; public static final boolean DUMPTRUCK = true; // extra dumpsys info public static final boolean DEBUG_GESTURES = false; public static final boolean DEBUG_MEDIA = false; public static final boolean DEBUG_MEDIA_FAKE_ARTWORK = false; public static final boolean DEBUG_WINDOW_STATE = false; // additional instrumentation for testing purposes; intended to be left on during development public static final boolean CHATTY = DEBUG; public static final String ACTION_STATUSBAR_START = "com.android.internal.policy.statusbar.START"; public static final boolean SHOW_LOCKSCREEN_MEDIA_ARTWORK = true; private static final int MSG_OPEN_NOTIFICATION_PANEL = 1000; private static final int MSG_CLOSE_PANELS = 1001; private static final int MSG_OPEN_SETTINGS_PANEL = 1002; // 1020-1040 reserved for BaseStatusBar private static final boolean CLOSE_PANEL_WHEN_EMPTIED = true; private static final int NOTIFICATION_PRIORITY_MULTIPLIER = 10; // see NotificationManagerService private static final int HIDE_ICONS_BELOW_SCORE = Notification.PRIORITY_LOW * NOTIFICATION_PRIORITY_MULTIPLIER; private static final int STATUS_OR_NAV_TRANSIENT = View.STATUS_BAR_TRANSIENT | View.NAVIGATION_BAR_TRANSIENT; private static final long AUTOHIDE_TIMEOUT_MS = 3000; /** The minimum delay in ms between reports of notification visibility. */ private static final int VISIBILITY_REPORT_MIN_DELAY_MS = 500; /** * The delay to reset the hint text when the hint animation is finished running. */ private static final int HINT_RESET_DELAY_MS = 1200; private static final AudioAttributes VIBRATION_ATTRIBUTES = new AudioAttributes.Builder() .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION) .setUsage(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION) .build(); public static final int FADE_KEYGUARD_START_DELAY = 100; public static final int FADE_KEYGUARD_DURATION = 300; /** Allow some time inbetween the long press for back and recents. */ private static final int LOCK_TO_APP_GESTURE_TOLERENCE = 200; PhoneStatusBarPolicy mIconPolicy; // These are no longer handled by the policy, because we need custom strategies for them BluetoothControllerImpl mBluetoothController; SecurityControllerImpl mSecurityController; BatteryController mBatteryController; LocationControllerImpl mLocationController; NetworkControllerImpl mNetworkController; HotspotControllerImpl mHotspotController; RotationLockControllerImpl mRotationLockController; UserInfoController mUserInfoController; ZenModeController mZenModeController; CastControllerImpl mCastController; VolumeComponent mVolumeComponent; KeyguardUserSwitcher mKeyguardUserSwitcher; FlashlightController mFlashlightController; UserSwitcherController mUserSwitcherController; NextAlarmController mNextAlarmController; KeyguardMonitor mKeyguardMonitor; BrightnessMirrorController mBrightnessMirrorController; AccessibilityController mAccessibilityController; int mNaturalBarHeight = -1; int mIconSize = -1; int mIconHPadding = -1; Display mDisplay; Point mCurrentDisplaySize = new Point(); StatusBarWindowView mStatusBarWindow; PhoneStatusBarView mStatusBarView; private int mStatusBarWindowState = WINDOW_STATE_SHOWING; private StatusBarWindowManager mStatusBarWindowManager; private UnlockMethodCache mUnlockMethodCache; private DozeServiceHost mDozeServiceHost; private boolean mScreenOnComingFromTouch; int mPixelFormat; Object mQueueLock = new Object(); // viewgroup containing the normal contents of the statusbar LinearLayout mStatusBarContents; // right-hand icons LinearLayout mSystemIconArea; LinearLayout mSystemIcons; // left-hand icons LinearLayout mStatusIcons; LinearLayout mStatusIconsKeyguard; // the icons themselves IconMerger mNotificationIcons; View mNotificationIconArea; // [+> View mMoreIcon; // expanded notifications NotificationPanelView mNotificationPanel; // the sliding/resizing panel within the notification window View mExpandedContents; int mNotificationPanelGravity; int mNotificationPanelMarginBottomPx; float mNotificationPanelMinHeightFrac; TextView mNotificationPanelDebugText; // settings View mFlipSettingsView; private QSPanel mQSPanel; // top bar StatusBarHeaderView mHeader; KeyguardStatusBarView mKeyguardStatusBar; View mKeyguardStatusView; KeyguardBottomAreaView mKeyguardBottomArea; boolean mLeaveOpenOnKeyguardHide; KeyguardIndicationController mKeyguardIndicationController; private boolean mKeyguardFadingAway; private long mKeyguardFadingAwayDelay; private long mKeyguardFadingAwayDuration; int mKeyguardMaxNotificationCount; // carrier/wifi label private TextView mCarrierLabel; private boolean mCarrierLabelVisible = false; private int mCarrierLabelHeight; private int mStatusBarHeaderHeight; private boolean mShowCarrierInPanel = false; // position int[] mPositionTmp = new int[2]; boolean mExpandedVisible; private int mNavigationBarWindowState = WINDOW_STATE_SHOWING; // the tracker view int mTrackingPosition; // the position of the top of the tracking view. // ticker private boolean mTickerEnabled; private Ticker mTicker; private View mTickerView; private boolean mTicking; // Tracking finger for opening/closing. int mEdgeBorder; // corresponds to R.dimen.status_bar_edge_ignore boolean mTracking; VelocityTracker mVelocityTracker; int[] mAbsPos = new int[2]; ArrayList mPostCollapseRunnables = new ArrayList<>(); // for disabling the status bar int mDisabled = 0; // tracking calls to View.setSystemUiVisibility() int mSystemUiVisibility = View.SYSTEM_UI_FLAG_VISIBLE; DisplayMetrics mDisplayMetrics = new DisplayMetrics(); // XXX: gesture research private final GestureRecorder mGestureRec = DEBUG_GESTURES ? new GestureRecorder("/sdcard/statusbar_gestures.dat") : null; private int mNavigationIconHints = 0; // ensure quick settings is disabled until the current user makes it through the setup wizard private boolean mUserSetup = false; private ContentObserver mUserSetupObserver = new ContentObserver(new Handler()) { @Override public void onChange(boolean selfChange) { final boolean userSetup = 0 != Settings.Secure.getIntForUser( mContext.getContentResolver(), Settings.Secure.USER_SETUP_COMPLETE, 0 /*default */, mCurrentUserId); if (MULTIUSER_DEBUG) Log.d(TAG, String.format("User setup changed: " + "selfChange=%s userSetup=%s mUserSetup=%s", selfChange, userSetup, mUserSetup)); if (userSetup != mUserSetup) { mUserSetup = userSetup; if (!mUserSetup && mStatusBarView != null) animateCollapseQuickSettings(); } } }; final private ContentObserver mHeadsUpObserver = new ContentObserver(mHandler) { @Override public void onChange(boolean selfChange) { boolean wasUsing = mUseHeadsUp; mUseHeadsUp = ENABLE_HEADS_UP && !mDisableNotificationAlerts && Settings.Global.HEADS_UP_OFF != Settings.Global.getInt( mContext.getContentResolver(), Settings.Global.HEADS_UP_NOTIFICATIONS_ENABLED, Settings.Global.HEADS_UP_OFF); mHeadsUpTicker = mUseHeadsUp && 0 != Settings.Global.getInt( mContext.getContentResolver(), SETTING_HEADS_UP_TICKER, 0); Log.d(TAG, "heads up is " + (mUseHeadsUp ? "enabled" : "disabled")); if (wasUsing != mUseHeadsUp) { if (!mUseHeadsUp) { Log.d(TAG, "dismissing any existing heads up notification on disable event"); setHeadsUpVisibility(false); mHeadsUpNotificationView.release(); removeHeadsUpView(); } else { addHeadsUpView(); } } } }; private int mInteractingWindows; private boolean mAutohideSuspended; private int mStatusBarMode; private int mNavigationBarMode; private Boolean mScreenOn; // The second field is a bit different from the first one because it only listens to screen on/ // screen of events from Keyguard. We need this so we don't have a race condition with the // broadcast. In the future, we should remove the first field altogether and rename the second // field. private boolean mScreenOnFromKeyguard; private ViewMediatorCallback mKeyguardViewMediatorCallback; private ScrimController mScrimController; private final Runnable mAutohide = new Runnable() { @Override public void run() { int requested = mSystemUiVisibility & ~STATUS_OR_NAV_TRANSIENT; if (mSystemUiVisibility != requested) { notifyUiVisibilityChanged(requested); } }}; private boolean mVisible; private boolean mWaitingForKeyguardExit; private boolean mDozing; private boolean mScrimSrcModeEnabled; private Interpolator mLinearOutSlowIn; private Interpolator mLinearInterpolator = new LinearInterpolator(); private Interpolator mBackdropInterpolator = new AccelerateDecelerateInterpolator(); public static final Interpolator ALPHA_IN = new PathInterpolator(0.4f, 0f, 1f, 1f); public static final Interpolator ALPHA_OUT = new PathInterpolator(0f, 0f, 0.8f, 1f); private BackDropView mBackdrop; private ImageView mBackdropFront, mBackdropBack; private PorterDuffXfermode mSrcXferMode = new PorterDuffXfermode(PorterDuff.Mode.SRC); private PorterDuffXfermode mSrcOverXferMode = new PorterDuffXfermode(PorterDuff.Mode.SRC_OVER); private MediaSessionManager mMediaSessionManager; private MediaController mMediaController; private String mMediaNotificationKey; private MediaMetadata mMediaMetadata; private MediaController.Callback mMediaListener = new MediaController.Callback() { @Override public void onPlaybackStateChanged(PlaybackState state) { super.onPlaybackStateChanged(state); if (DEBUG_MEDIA) Log.v(TAG, "DEBUG_MEDIA: onPlaybackStateChanged: " + state); } @Override public void onMetadataChanged(MediaMetadata metadata) { super.onMetadataChanged(metadata); if (DEBUG_MEDIA) Log.v(TAG, "DEBUG_MEDIA: onMetadataChanged: " + metadata); mMediaMetadata = metadata; updateMediaMetaData(true); } }; private final OnChildLocationsChangedListener mOnChildLocationsChangedListener = new OnChildLocationsChangedListener() { @Override public void onChildLocationsChanged(NotificationStackScrollLayout stackScrollLayout) { userActivity(); } }; private int mDisabledUnmodified; /** Keys of notifications currently visible to the user. */ private final ArraySet mCurrentlyVisibleNotifications = new ArraySet(); private long mLastVisibilityReportUptimeMs; private final ShadeUpdates mShadeUpdates = new ShadeUpdates(); private int mDrawCount; private Runnable mLaunchTransitionEndRunnable; private boolean mLaunchTransitionFadingAway; private ExpandableNotificationRow mDraggedDownRow; private static final int VISIBLE_LOCATIONS = ViewState.LOCATION_FIRST_CARD | ViewState.LOCATION_TOP_STACK_PEEKING | ViewState.LOCATION_MAIN_AREA | ViewState.LOCATION_BOTTOM_STACK_PEEKING; private final OnChildLocationsChangedListener mNotificationLocationsChangedListener = new OnChildLocationsChangedListener() { @Override public void onChildLocationsChanged( NotificationStackScrollLayout stackScrollLayout) { if (mHandler.hasCallbacks(mVisibilityReporter)) { // Visibilities will be reported when the existing // callback is executed. return; } // Calculate when we're allowed to run the visibility // reporter. Note that this timestamp might already have // passed. That's OK, the callback will just be executed // ASAP. long nextReportUptimeMs = mLastVisibilityReportUptimeMs + VISIBILITY_REPORT_MIN_DELAY_MS; mHandler.postAtTime(mVisibilityReporter, nextReportUptimeMs); } }; // Tracks notifications currently visible in mNotificationStackScroller and // emits visibility events via NoMan on changes. private final Runnable mVisibilityReporter = new Runnable() { private final ArrayList mTmpNewlyVisibleNotifications = new ArrayList(); private final ArrayList mTmpCurrentlyVisibleNotifications = new ArrayList(); @Override public void run() { mLastVisibilityReportUptimeMs = SystemClock.uptimeMillis(); // 1. Loop over mNotificationData entries: // A. Keep list of visible notifications. // B. Keep list of previously hidden, now visible notifications. // 2. Compute no-longer visible notifications by removing currently // visible notifications from the set of previously visible // notifications. // 3. Report newly visible and no-longer visible notifications. // 4. Keep currently visible notifications for next report. ArrayList activeNotifications = mNotificationData.getActiveNotifications(); int N = activeNotifications.size(); for (int i = 0; i < N; i++) { Entry entry = activeNotifications.get(i); String key = entry.notification.getKey(); boolean previouslyVisible = mCurrentlyVisibleNotifications.contains(key); boolean currentlyVisible = (mStackScroller.getChildLocation(entry.row) & VISIBLE_LOCATIONS) != 0; if (currentlyVisible) { // Build new set of visible notifications. mTmpCurrentlyVisibleNotifications.add(key); } if (!previouslyVisible && currentlyVisible) { mTmpNewlyVisibleNotifications.add(key); } } ArraySet noLongerVisibleNotifications = mCurrentlyVisibleNotifications; noLongerVisibleNotifications.removeAll(mTmpCurrentlyVisibleNotifications); logNotificationVisibilityChanges( mTmpNewlyVisibleNotifications, noLongerVisibleNotifications); mCurrentlyVisibleNotifications.clear(); mCurrentlyVisibleNotifications.addAll(mTmpCurrentlyVisibleNotifications); mTmpNewlyVisibleNotifications.clear(); mTmpCurrentlyVisibleNotifications.clear(); } }; private final View.OnClickListener mOverflowClickListener = new View.OnClickListener() { @Override public void onClick(View v) { goToLockedShade(null); } }; @Override public void start() { mDisplay = ((WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE)) .getDefaultDisplay(); updateDisplaySize(); mScrimSrcModeEnabled = mContext.getResources().getBoolean( R.bool.config_status_bar_scrim_behind_use_src); super.start(); // calls createAndAddWindows() mMediaSessionManager = (MediaSessionManager) mContext.getSystemService(Context.MEDIA_SESSION_SERVICE); // TODO: use MediaSessionManager.SessionListener to hook us up to future updates // in session state addNavigationBar(); // Lastly, call to the icon policy to install/update all the icons. mIconPolicy = new PhoneStatusBarPolicy(mContext, mCastController); mSettingsObserver.onChange(false); // set up mHeadsUpObserver.onChange(true); // set up if (ENABLE_HEADS_UP) { mContext.getContentResolver().registerContentObserver( Settings.Global.getUriFor(Settings.Global.HEADS_UP_NOTIFICATIONS_ENABLED), true, mHeadsUpObserver); mContext.getContentResolver().registerContentObserver( Settings.Global.getUriFor(SETTING_HEADS_UP_TICKER), true, mHeadsUpObserver); } mUnlockMethodCache = UnlockMethodCache.getInstance(mContext); startKeyguard(); mDozeServiceHost = new DozeServiceHost(); putComponent(DozeHost.class, mDozeServiceHost); putComponent(PhoneStatusBar.class, this); setControllerUsers(); notifyUserAboutHiddenNotifications(); } // ================================================================================ // Constructing the view // ================================================================================ protected PhoneStatusBarView makeStatusBarView() { final Context context = mContext; Resources res = context.getResources(); updateDisplaySize(); // populates mDisplayMetrics updateResources(); mIconSize = res.getDimensionPixelSize(com.android.internal.R.dimen.status_bar_icon_size); mStatusBarWindow = (StatusBarWindowView) View.inflate(context, R.layout.super_status_bar, null); mStatusBarWindow.mService = this; mStatusBarWindow.setOnTouchListener(new View.OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { checkUserAutohide(v, event); if (event.getAction() == MotionEvent.ACTION_DOWN) { if (mExpandedVisible) { animateCollapsePanels(); } } return mStatusBarWindow.onTouchEvent(event); }}); mStatusBarView = (PhoneStatusBarView) mStatusBarWindow.findViewById(R.id.status_bar); mStatusBarView.setBar(this); PanelHolder holder = (PanelHolder) mStatusBarWindow.findViewById(R.id.panel_holder); mStatusBarView.setPanelHolder(holder); mNotificationPanel = (NotificationPanelView) mStatusBarWindow.findViewById( R.id.notification_panel); mNotificationPanel.setStatusBar(this); if (!ActivityManager.isHighEndGfx()) { mStatusBarWindow.setBackground(null); mNotificationPanel.setBackground(new FastColorDrawable(context.getResources().getColor( R.color.notification_panel_solid_background))); } if (ENABLE_HEADS_UP) { mHeadsUpNotificationView = (HeadsUpNotificationView) View.inflate(context, R.layout.heads_up, null); mHeadsUpNotificationView.setVisibility(View.GONE); mHeadsUpNotificationView.setBar(this); } if (MULTIUSER_DEBUG) { mNotificationPanelDebugText = (TextView) mNotificationPanel.findViewById( R.id.header_debug_info); mNotificationPanelDebugText.setVisibility(View.VISIBLE); } updateShowSearchHoldoff(); try { boolean showNav = mWindowManagerService.hasNavigationBar(); if (DEBUG) Log.v(TAG, "hasNavigationBar=" + showNav); if (showNav) { mNavigationBarView = (NavigationBarView) View.inflate(context, R.layout.navigation_bar, null); mNavigationBarView.setDisabledFlags(mDisabled); mNavigationBarView.setBar(this); mNavigationBarView.setOnVerticalChangedListener( new NavigationBarView.OnVerticalChangedListener() { @Override public void onVerticalChanged(boolean isVertical) { if (mSearchPanelView != null) { mSearchPanelView.setHorizontal(isVertical); } mNotificationPanel.setQsScrimEnabled(!isVertical); } }); mNavigationBarView.setOnTouchListener(new View.OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { checkUserAutohide(v, event); return false; }}); } } catch (RemoteException ex) { // no window manager? good luck with that } // figure out which pixel-format to use for the status bar. mPixelFormat = PixelFormat.OPAQUE; mSystemIconArea = (LinearLayout) mStatusBarView.findViewById(R.id.system_icon_area); mSystemIcons = (LinearLayout) mStatusBarView.findViewById(R.id.system_icons); mStatusIcons = (LinearLayout)mStatusBarView.findViewById(R.id.statusIcons); mNotificationIconArea = mStatusBarView.findViewById(R.id.notification_icon_area_inner); mNotificationIcons = (IconMerger)mStatusBarView.findViewById(R.id.notificationIcons); mMoreIcon = mStatusBarView.findViewById(R.id.moreIcon); mNotificationIcons.setOverflowIndicator(mMoreIcon); mStatusBarContents = (LinearLayout)mStatusBarView.findViewById(R.id.status_bar_contents); mStackScroller = (NotificationStackScrollLayout) mStatusBarWindow.findViewById( R.id.notification_stack_scroller); mStackScroller.setLongPressListener(getNotificationLongClicker()); mStackScroller.setPhoneStatusBar(this); mKeyguardIconOverflowContainer = (NotificationOverflowContainer) LayoutInflater.from(mContext).inflate( R.layout.status_bar_notification_keyguard_overflow, mStackScroller, false); mKeyguardIconOverflowContainer.setOnActivatedListener(this); mKeyguardIconOverflowContainer.setOnClickListener(mOverflowClickListener); mStackScroller.addView(mKeyguardIconOverflowContainer); SpeedBumpView speedBump = (SpeedBumpView) LayoutInflater.from(mContext).inflate( R.layout.status_bar_notification_speed_bump, mStackScroller, false); mStackScroller.setSpeedBumpView(speedBump); mEmptyShadeView = (EmptyShadeView) LayoutInflater.from(mContext).inflate( R.layout.status_bar_no_notifications, mStackScroller, false); mStackScroller.setEmptyShadeView(mEmptyShadeView); mDismissView = (DismissView) LayoutInflater.from(mContext).inflate( R.layout.status_bar_notification_dismiss_all, mStackScroller, false); mDismissView.setOnButtonClickListener(new View.OnClickListener() { @Override public void onClick(View v) { clearAllNotifications(); } }); mStackScroller.setDismissView(mDismissView); mExpandedContents = mStackScroller; mBackdrop = (BackDropView) mStatusBarWindow.findViewById(R.id.backdrop); mBackdropFront = (ImageView) mBackdrop.findViewById(R.id.backdrop_front); mBackdropBack = (ImageView) mBackdrop.findViewById(R.id.backdrop_back); ScrimView scrimBehind = (ScrimView) mStatusBarWindow.findViewById(R.id.scrim_behind); ScrimView scrimInFront = (ScrimView) mStatusBarWindow.findViewById(R.id.scrim_in_front); mScrimController = new ScrimController(scrimBehind, scrimInFront, mScrimSrcModeEnabled); mScrimController.setBackDropView(mBackdrop); mStatusBarView.setScrimController(mScrimController); mHeader = (StatusBarHeaderView) mStatusBarWindow.findViewById(R.id.header); mHeader.setActivityStarter(this); mKeyguardStatusBar = (KeyguardStatusBarView) mStatusBarWindow.findViewById(R.id.keyguard_header); mStatusIconsKeyguard = (LinearLayout) mKeyguardStatusBar.findViewById(R.id.statusIcons); mKeyguardStatusView = mStatusBarWindow.findViewById(R.id.keyguard_status_view); mKeyguardBottomArea = (KeyguardBottomAreaView) mStatusBarWindow.findViewById(R.id.keyguard_bottom_area); mKeyguardBottomArea.setActivityStarter(this); mKeyguardIndicationController = new KeyguardIndicationController(mContext, (KeyguardIndicationTextView) mStatusBarWindow.findViewById( R.id.keyguard_indication_text)); mKeyguardBottomArea.setKeyguardIndicationController(mKeyguardIndicationController); mTickerEnabled = res.getBoolean(R.bool.enable_ticker); if (mTickerEnabled) { final ViewStub tickerStub = (ViewStub) mStatusBarView.findViewById(R.id.ticker_stub); if (tickerStub != null) { mTickerView = tickerStub.inflate(); mTicker = new MyTicker(context, mStatusBarView); TickerView tickerView = (TickerView) mStatusBarView.findViewById(R.id.tickerText); tickerView.mTicker = mTicker; } } mEdgeBorder = res.getDimensionPixelSize(R.dimen.status_bar_edge_ignore); // set the inital view visibility setAreThereNotifications(); // Other icons mLocationController = new LocationControllerImpl(mContext); // will post a notification mBatteryController = new BatteryController(mContext); mBatteryController.addStateChangedCallback(new BatteryStateChangeCallback() { @Override public void onPowerSaveChanged() { mHandler.post(mCheckBarModes); if (mDozeServiceHost != null) { mDozeServiceHost.firePowerSaveChanged(mBatteryController.isPowerSave()); } } @Override public void onBatteryLevelChanged(int level, boolean pluggedIn, boolean charging) { // noop } }); mNetworkController = new NetworkControllerImpl(mContext); mHotspotController = new HotspotControllerImpl(mContext); mBluetoothController = new BluetoothControllerImpl(mContext); mSecurityController = new SecurityControllerImpl(mContext); if (mContext.getResources().getBoolean(R.bool.config_showRotationLock)) { mRotationLockController = new RotationLockControllerImpl(mContext); } mUserInfoController = new UserInfoController(mContext); mVolumeComponent = getComponent(VolumeComponent.class); mZenModeController = mVolumeComponent.getZenController(); mCastController = new CastControllerImpl(mContext); final SignalClusterView signalCluster = (SignalClusterView) mStatusBarView.findViewById(R.id.signal_cluster); final SignalClusterView signalClusterKeyguard = (SignalClusterView) mKeyguardStatusBar.findViewById(R.id.signal_cluster); final SignalClusterView signalClusterQs = (SignalClusterView) mHeader.findViewById(R.id.signal_cluster); mNetworkController.addSignalCluster(signalCluster); mNetworkController.addSignalCluster(signalClusterKeyguard); mNetworkController.addSignalCluster(signalClusterQs); signalCluster.setSecurityController(mSecurityController); signalCluster.setNetworkController(mNetworkController); signalClusterKeyguard.setSecurityController(mSecurityController); signalClusterKeyguard.setNetworkController(mNetworkController); signalClusterQs.setSecurityController(mSecurityController); signalClusterQs.setNetworkController(mNetworkController); final boolean isAPhone = mNetworkController.hasVoiceCallingFeature(); if (isAPhone) { mNetworkController.addEmergencyLabelView(mHeader); } mCarrierLabel = (TextView)mStatusBarWindow.findViewById(R.id.carrier_label); mShowCarrierInPanel = (mCarrierLabel != null); if (DEBUG) Log.v(TAG, "carrierlabel=" + mCarrierLabel + " show=" + mShowCarrierInPanel); if (mShowCarrierInPanel) { mCarrierLabel.setVisibility(mCarrierLabelVisible ? View.VISIBLE : View.INVISIBLE); // for mobile devices, we always show mobile connection info here (SPN/PLMN) // for other devices, we show whatever network is connected if (mNetworkController.hasMobileDataFeature()) { mNetworkController.addMobileLabelView(mCarrierLabel); } else { mNetworkController.addCombinedLabelView(mCarrierLabel); } // set up the dynamic hide/show of the label // TODO: uncomment, handle this for the Stack scroller aswell // ((NotificationRowLayout) mStackScroller) // .setOnSizeChangedListener(new OnSizeChangedListener() { // @Override // public void onSizeChanged(View view, int w, int h, int oldw, int oldh) { // updateCarrierLabelVisibility(false); } mFlashlightController = new FlashlightController(mContext); mKeyguardBottomArea.setFlashlightController(mFlashlightController); mKeyguardBottomArea.setPhoneStatusBar(this); mAccessibilityController = new AccessibilityController(mContext); mKeyguardBottomArea.setAccessibilityController(mAccessibilityController); mNextAlarmController = new NextAlarmController(mContext); mKeyguardMonitor = new KeyguardMonitor(); mUserSwitcherController = new UserSwitcherController(mContext, mKeyguardMonitor); mKeyguardUserSwitcher = new KeyguardUserSwitcher(mContext, (ViewStub) mStatusBarWindow.findViewById(R.id.keyguard_user_switcher), mKeyguardStatusBar, mNotificationPanel, mUserSwitcherController); // Set up the quick settings tile panel mQSPanel = (QSPanel) mStatusBarWindow.findViewById(R.id.quick_settings_panel); if (mQSPanel != null) { final QSTileHost qsh = new QSTileHost(mContext, this, mBluetoothController, mLocationController, mRotationLockController, mNetworkController, mZenModeController, mHotspotController, mCastController, mFlashlightController, mUserSwitcherController, mKeyguardMonitor, mSecurityController); mQSPanel.setHost(qsh); mQSPanel.setTiles(qsh.getTiles()); mBrightnessMirrorController = new BrightnessMirrorController(mStatusBarWindow); mQSPanel.setBrightnessMirror(mBrightnessMirrorController); mHeader.setQSPanel(mQSPanel); qsh.setCallback(new QSTileHost.Callback() { @Override public void onTilesChanged() { mQSPanel.setTiles(qsh.getTiles()); } }); } // User info. Trigger first load. mHeader.setUserInfoController(mUserInfoController); mKeyguardStatusBar.setUserInfoController(mUserInfoController); mUserInfoController.reloadUserInfo(); mHeader.setBatteryController(mBatteryController); ((BatteryMeterView) mStatusBarView.findViewById(R.id.battery)).setBatteryController( mBatteryController); mKeyguardStatusBar.setBatteryController(mBatteryController); mHeader.setNextAlarmController(mNextAlarmController); PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); mBroadcastReceiver.onReceive(mContext, new Intent(pm.isScreenOn() ? Intent.ACTION_SCREEN_ON : Intent.ACTION_SCREEN_OFF)); // receive broadcasts IntentFilter filter = new IntentFilter(); filter.addAction(Intent.ACTION_CLOSE_SYSTEM_DIALOGS); filter.addAction(Intent.ACTION_SCREEN_OFF); filter.addAction(Intent.ACTION_SCREEN_ON); if (DEBUG_MEDIA_FAKE_ARTWORK) { filter.addAction("fake_artwork"); } filter.addAction(ACTION_DEMO); context.registerReceiver(mBroadcastReceiver, filter); // listen for USER_SETUP_COMPLETE setting (per-user) resetUserSetupObserver(); startGlyphRasterizeHack(); return mStatusBarView; } private void clearAllNotifications() { // animate-swipe all dismissable notifications, then animate the shade closed int numChildren = mStackScroller.getChildCount(); final ArrayList viewsToHide = new ArrayList(numChildren); for (int i = 0; i < numChildren; i++) { final View child = mStackScroller.getChildAt(i); if (mStackScroller.canChildBeDismissed(child)) { if (child.getVisibility() == View.VISIBLE) { viewsToHide.add(child); } } } if (viewsToHide.isEmpty()) { animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_NONE); return; } addPostCollapseAction(new Runnable() { @Override public void run() { try { mBarService.onClearAllNotifications(mCurrentUserId); } catch (Exception ex) { } } }); performDismissAllAnimations(viewsToHide); } private void performDismissAllAnimations(ArrayList hideAnimatedList) { Runnable animationFinishAction = new Runnable() { @Override public void run() { mStackScroller.post(new Runnable() { @Override public void run() { mStackScroller.setDismissAllInProgress(false); } }); animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_NONE); } }; // let's disable our normal animations mStackScroller.setDismissAllInProgress(true); // Decrease the delay for every row we animate to give the sense of // accelerating the swipes int rowDelayDecrement = 10; int currentDelay = 140; int totalDelay = 0; int numItems = hideAnimatedList.size(); for (int i = 0; i < numItems; i++) { View view = hideAnimatedList.get(i); Runnable endRunnable = null; if (i == numItems - 1) { endRunnable = animationFinishAction; } mStackScroller.dismissViewAnimated(view, endRunnable, totalDelay, 260); currentDelay = Math.max(50, currentDelay - rowDelayDecrement); totalDelay += currentDelay; } } /** * Hack to improve glyph rasterization for scaled text views. */ private void startGlyphRasterizeHack() { mStatusBarView.getViewTreeObserver().addOnPreDrawListener( new ViewTreeObserver.OnPreDrawListener() { @Override public boolean onPreDraw() { if (mDrawCount == 1) { mStatusBarView.getViewTreeObserver().removeOnPreDrawListener(this); HardwareCanvas.setProperty("extraRasterBucket", Float.toString(StackScrollAlgorithm.DIMMED_SCALE)); HardwareCanvas.setProperty("extraRasterBucket", Float.toString( mContext.getResources().getDimensionPixelSize( R.dimen.qs_time_collapsed_size) / mContext.getResources().getDimensionPixelSize( R.dimen.qs_time_expanded_size))); } mDrawCount++; return true; } }); } @Override protected void setZenMode(int mode) { super.setZenMode(mode); if (mIconPolicy != null) { mIconPolicy.setZenMode(mode); } } private void startKeyguard() { KeyguardViewMediator keyguardViewMediator = getComponent(KeyguardViewMediator.class); mStatusBarKeyguardViewManager = keyguardViewMediator.registerStatusBar(this, mStatusBarWindow, mStatusBarWindowManager, mScrimController); mKeyguardViewMediatorCallback = keyguardViewMediator.getViewMediatorCallback(); } @Override protected View getStatusBarView() { return mStatusBarView; } public StatusBarWindowView getStatusBarWindow() { return mStatusBarWindow; } @Override protected WindowManager.LayoutParams getSearchLayoutParams(LayoutParams layoutParams) { boolean opaque = false; WindowManager.LayoutParams lp = new WindowManager.LayoutParams( LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL, WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN | WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM | WindowManager.LayoutParams.FLAG_SPLIT_TOUCH, (opaque ? PixelFormat.OPAQUE : PixelFormat.TRANSLUCENT)); if (ActivityManager.isHighEndGfx()) { lp.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED; } lp.gravity = Gravity.BOTTOM | Gravity.START; lp.setTitle("SearchPanel"); lp.softInputMode = WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING; return lp; } @Override protected void updateSearchPanel() { super.updateSearchPanel(); if (mNavigationBarView != null) { mNavigationBarView.setDelegateView(mSearchPanelView); } } @Override public void showSearchPanel() { super.showSearchPanel(); mHandler.removeCallbacks(mShowSearchPanel); // we want to freeze the sysui state wherever it is mSearchPanelView.setSystemUiVisibility(mSystemUiVisibility); if (mNavigationBarView != null) { WindowManager.LayoutParams lp = (android.view.WindowManager.LayoutParams) mNavigationBarView.getLayoutParams(); lp.flags &= ~WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL; mWindowManager.updateViewLayout(mNavigationBarView, lp); } } @Override public void hideSearchPanel() { super.hideSearchPanel(); if (mNavigationBarView != null) { WindowManager.LayoutParams lp = (android.view.WindowManager.LayoutParams) mNavigationBarView.getLayoutParams(); lp.flags |= WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL; mWindowManager.updateViewLayout(mNavigationBarView, lp); } } public int getStatusBarHeight() { if (mNaturalBarHeight < 0) { final Resources res = mContext.getResources(); mNaturalBarHeight = res.getDimensionPixelSize(com.android.internal.R.dimen.status_bar_height); } return mNaturalBarHeight; } private View.OnClickListener mRecentsClickListener = new View.OnClickListener() { public void onClick(View v) { awakenDreams(); toggleRecentApps(); } }; private long mLastLockToAppLongPress; private View.OnLongClickListener mLongPressBackRecentsListener = new View.OnLongClickListener() { @Override public boolean onLongClick(View v) { handleLongPressBackRecents(v); return true; } }; private int mShowSearchHoldoff = 0; private Runnable mShowSearchPanel = new Runnable() { public void run() { showSearchPanel(); awakenDreams(); } }; View.OnTouchListener mHomeActionListener = new View.OnTouchListener() { public boolean onTouch(View v, MotionEvent event) { switch(event.getAction()) { case MotionEvent.ACTION_DOWN: if (!shouldDisableNavbarGestures()) { mHandler.removeCallbacks(mShowSearchPanel); mHandler.postDelayed(mShowSearchPanel, mShowSearchHoldoff); } break; case MotionEvent.ACTION_UP: case MotionEvent.ACTION_CANCEL: mHandler.removeCallbacks(mShowSearchPanel); awakenDreams(); break; } return false; } }; private void awakenDreams() { if (mDreamManager != null) { try { mDreamManager.awaken(); } catch (RemoteException e) { // fine, stay asleep then } } } private void prepareNavigationBarView() { mNavigationBarView.reorient(); mNavigationBarView.getRecentsButton().setOnClickListener(mRecentsClickListener); mNavigationBarView.getRecentsButton().setOnTouchListener(mRecentsPreloadOnTouchListener); mNavigationBarView.getRecentsButton().setLongClickable(true); mNavigationBarView.getRecentsButton().setOnLongClickListener(mLongPressBackRecentsListener); mNavigationBarView.getBackButton().setLongClickable(true); mNavigationBarView.getBackButton().setOnLongClickListener(mLongPressBackRecentsListener); mNavigationBarView.getHomeButton().setOnTouchListener(mHomeActionListener); updateSearchPanel(); } // For small-screen devices (read: phones) that lack hardware navigation buttons private void addNavigationBar() { if (DEBUG) Log.v(TAG, "addNavigationBar: about to add " + mNavigationBarView); if (mNavigationBarView == null) return; prepareNavigationBarView(); mWindowManager.addView(mNavigationBarView, getNavigationBarLayoutParams()); } private void repositionNavigationBar() { if (mNavigationBarView == null || !mNavigationBarView.isAttachedToWindow()) return; prepareNavigationBarView(); mWindowManager.updateViewLayout(mNavigationBarView, getNavigationBarLayoutParams()); } private void notifyNavigationBarScreenOn(boolean screenOn) { if (mNavigationBarView == null) return; mNavigationBarView.notifyScreenOn(screenOn); } private WindowManager.LayoutParams getNavigationBarLayoutParams() { WindowManager.LayoutParams lp = new WindowManager.LayoutParams( LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.TYPE_NAVIGATION_BAR, 0 | WindowManager.LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH | WindowManager.LayoutParams.FLAG_SPLIT_TOUCH, PixelFormat.TRANSLUCENT); // this will allow the navbar to run in an overlay on devices that support this if (ActivityManager.isHighEndGfx()) { lp.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED; } lp.setTitle("NavigationBar"); lp.windowAnimations = 0; return lp; } private void addHeadsUpView() { int headsUpHeight = mContext.getResources() .getDimensionPixelSize(R.dimen.heads_up_window_height); WindowManager.LayoutParams lp = new WindowManager.LayoutParams( LayoutParams.MATCH_PARENT, headsUpHeight, WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL, // above the status bar! WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM | WindowManager.LayoutParams.FLAG_SPLIT_TOUCH, PixelFormat.TRANSLUCENT); lp.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED; lp.gravity = Gravity.TOP; lp.setTitle("Heads Up"); lp.packageName = mContext.getPackageName(); lp.windowAnimations = R.style.Animation_StatusBar_HeadsUp; mWindowManager.addView(mHeadsUpNotificationView, lp); } private void removeHeadsUpView() { mWindowManager.removeView(mHeadsUpNotificationView); } public void refreshAllStatusBarIcons() { refreshAllIconsForLayout(mStatusIcons); refreshAllIconsForLayout(mStatusIconsKeyguard); refreshAllIconsForLayout(mNotificationIcons); } private void refreshAllIconsForLayout(LinearLayout ll) { final int count = ll.getChildCount(); for (int n = 0; n < count; n++) { View child = ll.getChildAt(n); if (child instanceof StatusBarIconView) { ((StatusBarIconView) child).updateDrawable(); } } } public void addIcon(String slot, int index, int viewIndex, StatusBarIcon icon) { if (SPEW) Log.d(TAG, "addIcon slot=" + slot + " index=" + index + " viewIndex=" + viewIndex + " icon=" + icon); StatusBarIconView view = new StatusBarIconView(mContext, slot, null); view.set(icon); mStatusIcons.addView(view, viewIndex, new LinearLayout.LayoutParams( LayoutParams.WRAP_CONTENT, mIconSize)); view = new StatusBarIconView(mContext, slot, null); view.set(icon); mStatusIconsKeyguard.addView(view, viewIndex, new LinearLayout.LayoutParams( LayoutParams.WRAP_CONTENT, mIconSize)); } public void updateIcon(String slot, int index, int viewIndex, StatusBarIcon old, StatusBarIcon icon) { if (SPEW) Log.d(TAG, "updateIcon slot=" + slot + " index=" + index + " viewIndex=" + viewIndex + " old=" + old + " icon=" + icon); StatusBarIconView view = (StatusBarIconView) mStatusIcons.getChildAt(viewIndex); view.set(icon); view = (StatusBarIconView) mStatusIconsKeyguard.getChildAt(viewIndex); view.set(icon); } public void removeIcon(String slot, int index, int viewIndex) { if (SPEW) Log.d(TAG, "removeIcon slot=" + slot + " index=" + index + " viewIndex=" + viewIndex); mStatusIcons.removeViewAt(viewIndex); mStatusIconsKeyguard.removeViewAt(viewIndex); } public UserHandle getCurrentUserHandle() { return new UserHandle(mCurrentUserId); } @Override public void addNotification(StatusBarNotification notification, RankingMap ranking) { if (DEBUG) Log.d(TAG, "addNotification key=" + notification.getKey()); if (mUseHeadsUp && shouldInterrupt(notification)) { if (DEBUG) Log.d(TAG, "launching notification in heads up mode"); Entry interruptionCandidate = new Entry(notification, null); ViewGroup holder = mHeadsUpNotificationView.getHolder(); if (inflateViewsForHeadsUp(interruptionCandidate, holder)) { // 1. Populate mHeadsUpNotificationView mHeadsUpNotificationView.showNotification(interruptionCandidate); // do not show the notification in the shade, yet. return; } } Entry shadeEntry = createNotificationViews(notification); if (shadeEntry == null) { return; } if (notification.getNotification().fullScreenIntent != null) { // Stop screensaver if the notification has a full-screen intent. // (like an incoming phone call) awakenDreams(); // not immersive & a full-screen alert should be shown if (DEBUG) Log.d(TAG, "Notification has fullScreenIntent; sending fullScreenIntent"); try { notification.getNotification().fullScreenIntent.send(); } catch (PendingIntent.CanceledException e) { } } else { // usual case: status bar visible & not immersive // show the ticker if there isn't already a heads up if (mHeadsUpNotificationView.getEntry() == null) { tick(notification, true); } } addNotificationViews(shadeEntry, ranking); // Recalculate the position of the sliding windows and the titles. setAreThereNotifications(); updateExpandedViewPos(EXPANDED_LEAVE_ALONE); } public void displayNotificationFromHeadsUp(StatusBarNotification notification) { NotificationData.Entry shadeEntry = createNotificationViews(notification); if (shadeEntry == null) { return; } shadeEntry.setInterruption(); addNotificationViews(shadeEntry, null); // Recalculate the position of the sliding windows and the titles. setAreThereNotifications(); updateExpandedViewPos(EXPANDED_LEAVE_ALONE); } @Override public void resetHeadsUpDecayTimer() { mHandler.removeMessages(MSG_DECAY_HEADS_UP); if (mUseHeadsUp && mHeadsUpNotificationDecay > 0 && mHeadsUpNotificationView.isClearable()) { mHandler.sendEmptyMessageDelayed(MSG_DECAY_HEADS_UP, mHeadsUpNotificationDecay); } } @Override public void scheduleHeadsUpOpen() { mHandler.sendEmptyMessage(MSG_SHOW_HEADS_UP); } @Override public void scheduleHeadsUpClose() { mHandler.sendEmptyMessage(MSG_HIDE_HEADS_UP); } @Override public void scheduleHeadsUpEscalation() { mHandler.sendEmptyMessage(MSG_ESCALATE_HEADS_UP); } @Override protected void updateNotificationRanking(RankingMap ranking) { mNotificationData.updateRanking(ranking); updateNotifications(); } @Override public void removeNotification(String key, RankingMap ranking) { if (ENABLE_HEADS_UP && mHeadsUpNotificationView.getEntry() != null && key.equals(mHeadsUpNotificationView.getEntry().notification.getKey())) { mHeadsUpNotificationView.clear(); } StatusBarNotification old = removeNotificationViews(key, ranking); if (SPEW) Log.d(TAG, "removeNotification key=" + key + " old=" + old); if (old != null) { // Cancel the ticker if it's still running if (mTickerEnabled) { mTicker.removeEntry(old); } // Recalculate the position of the sliding windows and the titles. updateExpandedViewPos(EXPANDED_LEAVE_ALONE); if (CLOSE_PANEL_WHEN_EMPTIED && !hasActiveNotifications() && !mNotificationPanel.isTracking() && !mNotificationPanel.isQsExpanded()) { if (mState == StatusBarState.SHADE) { animateCollapsePanels(); } else if (mState == StatusBarState.SHADE_LOCKED) { goToKeyguard(); } } } setAreThereNotifications(); } @Override protected void refreshLayout(int layoutDirection) { if (mNavigationBarView != null) { mNavigationBarView.setLayoutDirection(layoutDirection); } refreshAllStatusBarIcons(); } private void updateShowSearchHoldoff() { mShowSearchHoldoff = mContext.getResources().getInteger( R.integer.config_show_search_delay); } private void updateNotificationShade() { if (mStackScroller == null) return; // Do not modify the notifications during collapse. if (isCollapsing()) { addPostCollapseAction(new Runnable() { @Override public void run() { updateNotificationShade(); } }); return; } ArrayList activeNotifications = mNotificationData.getActiveNotifications(); ArrayList toShow = new ArrayList<>(activeNotifications.size()); final int N = activeNotifications.size(); for (int i=0; i toRemove = new ArrayList(); for (int i=0; i< mStackScroller.getChildCount(); i++) { View child = mStackScroller.getChildAt(i); if (!toShow.contains(child) && child instanceof ExpandableNotificationRow) { toRemove.add(child); } } for (View remove : toRemove) { mStackScroller.removeView(remove); } for (int i=0; i activeNotifications = mNotificationData.getActiveNotifications(); final int N = activeNotifications.size(); for (int i = 0; i < N; i++) { Entry entry = activeNotifications.get(i); if (entry.row.getVisibility() != View.GONE && mNotificationData.isAmbient(entry.key)) { speedbumpIndex = currentIndex; break; } currentIndex++; } mStackScroller.updateSpeedBumpIndex(speedbumpIndex); } @Override protected void updateNotifications() { // TODO: Move this into updateNotificationIcons()? if (mNotificationIcons == null) return; mNotificationData.filterAndSort(); updateNotificationShade(); updateNotificationIcons(); } private void updateNotificationIcons() { final LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(mIconSize + 2*mIconHPadding, mNaturalBarHeight); ArrayList activeNotifications = mNotificationData.getActiveNotifications(); final int N = activeNotifications.size(); ArrayList toShow = new ArrayList<>(N); // Filter out notifications with low scores. for (int i = 0; i < N; i++) { Entry ent = activeNotifications.get(i); if (ent.notification.getScore() < HIDE_ICONS_BELOW_SCORE && !NotificationData.showNotificationEvenIfUnprovisioned(ent.notification)) { continue; } toShow.add(ent.icon); } if (DEBUG) { Log.d(TAG, "refreshing icons: " + toShow.size() + " notifications, mNotificationIcons=" + mNotificationIcons); } ArrayList toRemove = new ArrayList(); for (int i=0; i 0x%08x (diff: 0x%08x)", old, state, diff)); } StringBuilder flagdbg = new StringBuilder(); flagdbg.append("disable: < "); flagdbg.append(((state & StatusBarManager.DISABLE_EXPAND) != 0) ? "EXPAND" : "expand"); flagdbg.append(((diff & StatusBarManager.DISABLE_EXPAND) != 0) ? "* " : " "); flagdbg.append(((state & StatusBarManager.DISABLE_NOTIFICATION_ICONS) != 0) ? "ICONS" : "icons"); flagdbg.append(((diff & StatusBarManager.DISABLE_NOTIFICATION_ICONS) != 0) ? "* " : " "); flagdbg.append(((state & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) != 0) ? "ALERTS" : "alerts"); flagdbg.append(((diff & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) != 0) ? "* " : " "); flagdbg.append(((state & StatusBarManager.DISABLE_SYSTEM_INFO) != 0) ? "SYSTEM_INFO" : "system_info"); flagdbg.append(((diff & StatusBarManager.DISABLE_SYSTEM_INFO) != 0) ? "* " : " "); flagdbg.append(((state & StatusBarManager.DISABLE_BACK) != 0) ? "BACK" : "back"); flagdbg.append(((diff & StatusBarManager.DISABLE_BACK) != 0) ? "* " : " "); flagdbg.append(((state & StatusBarManager.DISABLE_HOME) != 0) ? "HOME" : "home"); flagdbg.append(((diff & StatusBarManager.DISABLE_HOME) != 0) ? "* " : " "); flagdbg.append(((state & StatusBarManager.DISABLE_RECENT) != 0) ? "RECENT" : "recent"); flagdbg.append(((diff & StatusBarManager.DISABLE_RECENT) != 0) ? "* " : " "); flagdbg.append(((state & StatusBarManager.DISABLE_CLOCK) != 0) ? "CLOCK" : "clock"); flagdbg.append(((diff & StatusBarManager.DISABLE_CLOCK) != 0) ? "* " : " "); flagdbg.append(((state & StatusBarManager.DISABLE_SEARCH) != 0) ? "SEARCH" : "search"); flagdbg.append(((diff & StatusBarManager.DISABLE_SEARCH) != 0) ? "* " : " "); flagdbg.append(">"); Log.d(TAG, flagdbg.toString()); if ((diff & StatusBarManager.DISABLE_SYSTEM_INFO) != 0) { mSystemIconArea.animate().cancel(); if ((state & StatusBarManager.DISABLE_SYSTEM_INFO) != 0) { animateStatusBarHide(mSystemIconArea, animate); } else { animateStatusBarShow(mSystemIconArea, animate); } } if ((diff & StatusBarManager.DISABLE_CLOCK) != 0) { boolean show = (state & StatusBarManager.DISABLE_CLOCK) == 0; showClock(show); } if ((diff & StatusBarManager.DISABLE_EXPAND) != 0) { if ((state & StatusBarManager.DISABLE_EXPAND) != 0) { animateCollapsePanels(); } } if ((diff & (StatusBarManager.DISABLE_HOME | StatusBarManager.DISABLE_RECENT | StatusBarManager.DISABLE_BACK | StatusBarManager.DISABLE_SEARCH)) != 0) { // the nav bar will take care of these if (mNavigationBarView != null) mNavigationBarView.setDisabledFlags(state); if ((state & StatusBarManager.DISABLE_RECENT) != 0) { // close recents if it's visible mHandler.removeMessages(MSG_HIDE_RECENT_APPS); mHandler.sendEmptyMessage(MSG_HIDE_RECENT_APPS); } } if ((diff & StatusBarManager.DISABLE_NOTIFICATION_ICONS) != 0) { if ((state & StatusBarManager.DISABLE_NOTIFICATION_ICONS) != 0) { if (mTicking) { haltTicker(); } animateStatusBarHide(mNotificationIconArea, animate); } else { animateStatusBarShow(mNotificationIconArea, animate); } } if ((diff & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) != 0) { mDisableNotificationAlerts = (state & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) != 0; mHeadsUpObserver.onChange(true); } } /** * Animates {@code v}, a view that is part of the status bar, out. */ private void animateStatusBarHide(final View v, boolean animate) { v.animate().cancel(); if (!animate) { v.setAlpha(0f); v.setVisibility(View.INVISIBLE); return; } v.animate() .alpha(0f) .setDuration(160) .setStartDelay(0) .setInterpolator(ALPHA_OUT) .withEndAction(new Runnable() { @Override public void run() { v.setVisibility(View.INVISIBLE); } }); } /** * Animates {@code v}, a view that is part of the status bar, in. */ private void animateStatusBarShow(View v, boolean animate) { v.animate().cancel(); v.setVisibility(View.VISIBLE); if (!animate) { v.setAlpha(1f); return; } v.animate() .alpha(1f) .setDuration(320) .setInterpolator(ALPHA_IN) .setStartDelay(50) // We need to clean up any pending end action from animateStatusBarHide if we call // both hide and show in the same frame before the animation actually gets started. // cancel() doesn't really remove the end action. .withEndAction(null); // Synchronize the motion with the Keyguard fading if necessary. if (mKeyguardFadingAway) { v.animate() .setDuration(mKeyguardFadingAwayDuration) .setInterpolator(mLinearOutSlowIn) .setStartDelay(mKeyguardFadingAwayDelay) .start(); } } @Override protected BaseStatusBar.H createHandler() { return new PhoneStatusBar.H(); } @Override public void startActivity(Intent intent, boolean dismissShade) { startActivityDismissingKeyguard(intent, false, dismissShade); } public ScrimController getScrimController() { return mScrimController; } public void setQsExpanded(boolean expanded) { mStatusBarWindowManager.setQsExpanded(expanded); } public boolean isGoingToNotificationShade() { return mLeaveOpenOnKeyguardHide; } public boolean isQsExpanded() { return mNotificationPanel.isQsExpanded(); } public boolean isScreenOnComingFromTouch() { return mScreenOnComingFromTouch; } public boolean isFalsingThresholdNeeded() { boolean onKeyguard = getBarState() == StatusBarState.KEYGUARD; boolean isMethodInsecure = mUnlockMethodCache.isMethodInsecure(); return onKeyguard && (isMethodInsecure || mDozing || mScreenOnComingFromTouch); } public boolean isDozing() { return mDozing; } @Override // NotificationData.Environment public String getCurrentMediaNotificationKey() { return mMediaNotificationKey; } public boolean isScrimSrcModeEnabled() { return mScrimSrcModeEnabled; } /** * All changes to the status bar and notifications funnel through here and are batched. */ private class H extends BaseStatusBar.H { public void handleMessage(Message m) { super.handleMessage(m); switch (m.what) { case MSG_OPEN_NOTIFICATION_PANEL: animateExpandNotificationsPanel(); break; case MSG_OPEN_SETTINGS_PANEL: animateExpandSettingsPanel(); break; case MSG_CLOSE_PANELS: animateCollapsePanels(); break; case MSG_SHOW_HEADS_UP: setHeadsUpVisibility(true); break; case MSG_DECAY_HEADS_UP: mHeadsUpNotificationView.release(); setHeadsUpVisibility(false); break; case MSG_HIDE_HEADS_UP: mHeadsUpNotificationView.release(); setHeadsUpVisibility(false); break; case MSG_ESCALATE_HEADS_UP: escalateHeadsUp(); setHeadsUpVisibility(false); break; } } } /** if the interrupting notification had a fullscreen intent, fire it now. */ private void escalateHeadsUp() { if (mHeadsUpNotificationView.getEntry() != null) { final StatusBarNotification sbn = mHeadsUpNotificationView.getEntry().notification; mHeadsUpNotificationView.release(); final Notification notification = sbn.getNotification(); if (notification.fullScreenIntent != null) { if (DEBUG) Log.d(TAG, "converting a heads up to fullScreen"); try { notification.fullScreenIntent.send(); } catch (PendingIntent.CanceledException e) { } } } } View.OnFocusChangeListener mFocusChangeListener = new View.OnFocusChangeListener() { public void onFocusChange(View v, boolean hasFocus) { // Because 'v' is a ViewGroup, all its children will be (un)selected // too, which allows marqueeing to work. v.setSelected(hasFocus); } }; boolean panelsEnabled() { return (mDisabled & StatusBarManager.DISABLE_EXPAND) == 0; } void makeExpandedVisible(boolean force) { if (SPEW) Log.d(TAG, "Make expanded visible: expanded visible=" + mExpandedVisible); if (!force && (mExpandedVisible || !panelsEnabled())) { return; } mExpandedVisible = true; if (mNavigationBarView != null) mNavigationBarView.setSlippery(true); updateCarrierLabelVisibility(true); updateExpandedViewPos(EXPANDED_LEAVE_ALONE); // Expand the window to encompass the full screen in anticipation of the drag. // This is only possible to do atomically because the status bar is at the top of the screen! mStatusBarWindowManager.setStatusBarExpanded(true); mStatusBarView.setFocusable(false); visibilityChanged(true); mWaitingForKeyguardExit = false; disable(mDisabledUnmodified, !force /* animate */); setInteracting(StatusBarManager.WINDOW_STATUS_BAR, true); } public void animateCollapsePanels() { animateCollapsePanels(CommandQueue.FLAG_EXCLUDE_NONE); } private final Runnable mAnimateCollapsePanels = new Runnable() { @Override public void run() { animateCollapsePanels(); } }; public void postAnimateCollapsePanels() { mHandler.post(mAnimateCollapsePanels); } public void animateCollapsePanels(int flags) { animateCollapsePanels(flags, false /* force */); } public void animateCollapsePanels(int flags, boolean force) { if (!force && (mState == StatusBarState.KEYGUARD || mState == StatusBarState.SHADE_LOCKED)) { runPostCollapseRunnables(); return; } if (SPEW) { Log.d(TAG, "animateCollapse():" + " mExpandedVisible=" + mExpandedVisible + " flags=" + flags); } if ((flags & CommandQueue.FLAG_EXCLUDE_RECENTS_PANEL) == 0) { if (!mHandler.hasMessages(MSG_HIDE_RECENT_APPS)) { mHandler.removeMessages(MSG_HIDE_RECENT_APPS); mHandler.sendEmptyMessage(MSG_HIDE_RECENT_APPS); } } if ((flags & CommandQueue.FLAG_EXCLUDE_SEARCH_PANEL) == 0) { mHandler.removeMessages(MSG_CLOSE_SEARCH_PANEL); mHandler.sendEmptyMessage(MSG_CLOSE_SEARCH_PANEL); } if (mStatusBarWindow != null) { // release focus immediately to kick off focus change transition mStatusBarWindowManager.setStatusBarFocusable(false); mStatusBarWindow.cancelExpandHelper(); mStatusBarView.collapseAllPanels(true); } } private void runPostCollapseRunnables() { int size = mPostCollapseRunnables.size(); for (int i = 0; i < size; i++) { mPostCollapseRunnables.get(i).run(); } mPostCollapseRunnables.clear(); } public ViewPropertyAnimator setVisibilityWhenDone( final ViewPropertyAnimator a, final View v, final int vis) { a.setListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { v.setVisibility(vis); a.setListener(null); // oneshot } }); return a; } public Animator setVisibilityWhenDone( final Animator a, final View v, final int vis) { a.addListener(new AnimatorListenerAdapter() { @Override public void onAnimationEnd(Animator animation) { v.setVisibility(vis); } }); return a; } public Animator interpolator(TimeInterpolator ti, Animator a) { a.setInterpolator(ti); return a; } public Animator startDelay(int d, Animator a) { a.setStartDelay(d); return a; } public Animator start(Animator a) { a.start(); return a; } final TimeInterpolator mAccelerateInterpolator = new AccelerateInterpolator(); final TimeInterpolator mDecelerateInterpolator = new DecelerateInterpolator(); final int FLIP_DURATION_OUT = 125; final int FLIP_DURATION_IN = 225; final int FLIP_DURATION = (FLIP_DURATION_IN + FLIP_DURATION_OUT); Animator mScrollViewAnim, mClearButtonAnim; @Override public void animateExpandNotificationsPanel() { if (SPEW) Log.d(TAG, "animateExpand: mExpandedVisible=" + mExpandedVisible); if (!panelsEnabled()) { return ; } mNotificationPanel.expand(); if (false) postStartTracing(); } @Override public void animateExpandSettingsPanel() { if (SPEW) Log.d(TAG, "animateExpand: mExpandedVisible=" + mExpandedVisible); if (!panelsEnabled()) { return; } // Settings are not available in setup if (!mUserSetup) return; mNotificationPanel.expand(); mNotificationPanel.openQs(); if (false) postStartTracing(); } public void animateCollapseQuickSettings() { if (mState == StatusBarState.SHADE) { mStatusBarView.collapseAllPanels(true); } } void makeExpandedInvisible() { if (SPEW) Log.d(TAG, "makeExpandedInvisible: mExpandedVisible=" + mExpandedVisible + " mExpandedVisible=" + mExpandedVisible); if (!mExpandedVisible || mStatusBarWindow == null) { return; } // Ensure the panel is fully collapsed (just in case; bug 6765842, 7260868) mStatusBarView.collapseAllPanels(/*animate=*/ false); // reset things to their proper state if (mScrollViewAnim != null) mScrollViewAnim.cancel(); if (mClearButtonAnim != null) mClearButtonAnim.cancel(); mStackScroller.setVisibility(View.VISIBLE); mNotificationPanel.setVisibility(View.GONE); mNotificationPanel.closeQs(); mExpandedVisible = false; if (mNavigationBarView != null) mNavigationBarView.setSlippery(false); visibilityChanged(false); // Shrink the window to the size of the status bar only mStatusBarWindowManager.setStatusBarExpanded(false); mStatusBarView.setFocusable(true); // Close any "App info" popups that might have snuck on-screen dismissPopups(); runPostCollapseRunnables(); setInteracting(StatusBarManager.WINDOW_STATUS_BAR, false); showBouncer(); disable(mDisabledUnmodified, true /* animate */); } public boolean interceptTouchEvent(MotionEvent event) { if (DEBUG_GESTURES) { if (event.getActionMasked() != MotionEvent.ACTION_MOVE) { EventLog.writeEvent(EventLogTags.SYSUI_STATUSBAR_TOUCH, event.getActionMasked(), (int) event.getX(), (int) event.getY(), mDisabled); } } if (SPEW) { Log.d(TAG, "Touch: rawY=" + event.getRawY() + " event=" + event + " mDisabled=" + mDisabled + " mTracking=" + mTracking); } else if (CHATTY) { if (event.getAction() != MotionEvent.ACTION_MOVE) { Log.d(TAG, String.format( "panel: %s at (%f, %f) mDisabled=0x%08x", MotionEvent.actionToString(event.getAction()), event.getRawX(), event.getRawY(), mDisabled)); } } if (DEBUG_GESTURES) { mGestureRec.add(event); } if (mStatusBarWindowState == WINDOW_STATE_SHOWING) { final boolean upOrCancel = event.getAction() == MotionEvent.ACTION_UP || event.getAction() == MotionEvent.ACTION_CANCEL; if (upOrCancel && !mExpandedVisible) { setInteracting(StatusBarManager.WINDOW_STATUS_BAR, false); } else { setInteracting(StatusBarManager.WINDOW_STATUS_BAR, true); } } return false; } public GestureRecorder getGestureRecorder() { return mGestureRec; } private void setNavigationIconHints(int hints) { if (hints == mNavigationIconHints) return; mNavigationIconHints = hints; if (mNavigationBarView != null) { mNavigationBarView.setNavigationIconHints(hints); } checkBarModes(); } @Override // CommandQueue public void setWindowState(int window, int state) { boolean showing = state == WINDOW_STATE_SHOWING; if (mStatusBarWindow != null && window == StatusBarManager.WINDOW_STATUS_BAR && mStatusBarWindowState != state) { mStatusBarWindowState = state; if (DEBUG_WINDOW_STATE) Log.d(TAG, "Status bar " + windowStateToString(state)); if (!showing && mState == StatusBarState.SHADE) { mStatusBarView.collapseAllPanels(false); } } if (mNavigationBarView != null && window == StatusBarManager.WINDOW_NAVIGATION_BAR && mNavigationBarWindowState != state) { mNavigationBarWindowState = state; if (DEBUG_WINDOW_STATE) Log.d(TAG, "Navigation bar " + windowStateToString(state)); } } @Override // CommandQueue public void buzzBeepBlinked() { if (mDozeServiceHost != null) { mDozeServiceHost.fireBuzzBeepBlinked(); } } @Override public void notificationLightOff() { if (mDozeServiceHost != null) { mDozeServiceHost.fireNotificationLight(false); } } @Override public void notificationLightPulse(int argb, int onMillis, int offMillis) { if (mDozeServiceHost != null) { mDozeServiceHost.fireNotificationLight(true); } } @Override // CommandQueue public void setSystemUiVisibility(int vis, int mask) { final int oldVal = mSystemUiVisibility; final int newVal = (oldVal&~mask) | (vis&mask); final int diff = newVal ^ oldVal; if (DEBUG) Log.d(TAG, String.format( "setSystemUiVisibility vis=%s mask=%s oldVal=%s newVal=%s diff=%s", Integer.toHexString(vis), Integer.toHexString(mask), Integer.toHexString(oldVal), Integer.toHexString(newVal), Integer.toHexString(diff))); if (diff != 0) { // we never set the recents bit via this method, so save the prior state to prevent // clobbering the bit below final boolean wasRecentsVisible = (mSystemUiVisibility & View.RECENT_APPS_VISIBLE) > 0; mSystemUiVisibility = newVal; // update low profile if ((diff & View.SYSTEM_UI_FLAG_LOW_PROFILE) != 0) { final boolean lightsOut = (vis & View.SYSTEM_UI_FLAG_LOW_PROFILE) != 0; if (lightsOut) { animateCollapsePanels(); if (mTicking) { haltTicker(); } } setAreThereNotifications(); } // update status bar mode final int sbMode = computeBarMode(oldVal, newVal, mStatusBarView.getBarTransitions(), View.STATUS_BAR_TRANSIENT, View.STATUS_BAR_TRANSLUCENT); // update navigation bar mode final int nbMode = mNavigationBarView == null ? -1 : computeBarMode( oldVal, newVal, mNavigationBarView.getBarTransitions(), View.NAVIGATION_BAR_TRANSIENT, View.NAVIGATION_BAR_TRANSLUCENT); final boolean sbModeChanged = sbMode != -1; final boolean nbModeChanged = nbMode != -1; boolean checkBarModes = false; if (sbModeChanged && sbMode != mStatusBarMode) { mStatusBarMode = sbMode; checkBarModes = true; } if (nbModeChanged && nbMode != mNavigationBarMode) { mNavigationBarMode = nbMode; checkBarModes = true; } if (checkBarModes) { checkBarModes(); } if (sbModeChanged || nbModeChanged) { // update transient bar autohide if (mStatusBarMode == MODE_SEMI_TRANSPARENT || mNavigationBarMode == MODE_SEMI_TRANSPARENT) { scheduleAutohide(); } else { cancelAutohide(); } } // ready to unhide if ((vis & View.STATUS_BAR_UNHIDE) != 0) { mSystemUiVisibility &= ~View.STATUS_BAR_UNHIDE; } if ((vis & View.NAVIGATION_BAR_UNHIDE) != 0) { mSystemUiVisibility &= ~View.NAVIGATION_BAR_UNHIDE; } // restore the recents bit if (wasRecentsVisible) { mSystemUiVisibility |= View.RECENT_APPS_VISIBLE; } // send updated sysui visibility to window manager notifyUiVisibilityChanged(mSystemUiVisibility); } } private int computeBarMode(int oldVis, int newVis, BarTransitions transitions, int transientFlag, int translucentFlag) { final int oldMode = barMode(oldVis, transientFlag, translucentFlag); final int newMode = barMode(newVis, transientFlag, translucentFlag); if (oldMode == newMode) { return -1; // no mode change } return newMode; } private int barMode(int vis, int transientFlag, int translucentFlag) { return (vis & transientFlag) != 0 ? MODE_SEMI_TRANSPARENT : (vis & translucentFlag) != 0 ? MODE_TRANSLUCENT : (vis & View.SYSTEM_UI_TRANSPARENT) != 0 ? MODE_TRANSPARENT : (vis & View.SYSTEM_UI_FLAG_LOW_PROFILE) != 0 ? MODE_LIGHTS_OUT : MODE_OPAQUE; } private void checkBarModes() { if (mDemoMode) return; checkBarMode(mStatusBarMode, mStatusBarWindowState, mStatusBarView.getBarTransitions()); if (mNavigationBarView != null) { checkBarMode(mNavigationBarMode, mNavigationBarWindowState, mNavigationBarView.getBarTransitions()); } } private void checkBarMode(int mode, int windowState, BarTransitions transitions) { final boolean powerSave = mBatteryController.isPowerSave(); final boolean anim = (mScreenOn == null || mScreenOn) && windowState != WINDOW_STATE_HIDDEN && !powerSave; if (powerSave && getBarState() == StatusBarState.SHADE) { mode = MODE_WARNING; } transitions.transitionTo(mode, anim); } private void finishBarAnimations() { mStatusBarView.getBarTransitions().finishAnimations(); if (mNavigationBarView != null) { mNavigationBarView.getBarTransitions().finishAnimations(); } } private final Runnable mCheckBarModes = new Runnable() { @Override public void run() { checkBarModes(); } }; @Override public void setInteracting(int barWindow, boolean interacting) { mInteractingWindows = interacting ? (mInteractingWindows | barWindow) : (mInteractingWindows & ~barWindow); if (mInteractingWindows != 0) { suspendAutohide(); } else { resumeSuspendedAutohide(); } checkBarModes(); } private void resumeSuspendedAutohide() { if (mAutohideSuspended) { scheduleAutohide(); mHandler.postDelayed(mCheckBarModes, 500); // longer than home -> launcher } } private void suspendAutohide() { mHandler.removeCallbacks(mAutohide); mHandler.removeCallbacks(mCheckBarModes); mAutohideSuspended = (mSystemUiVisibility & STATUS_OR_NAV_TRANSIENT) != 0; } private void cancelAutohide() { mAutohideSuspended = false; mHandler.removeCallbacks(mAutohide); } private void scheduleAutohide() { cancelAutohide(); mHandler.postDelayed(mAutohide, AUTOHIDE_TIMEOUT_MS); } private void checkUserAutohide(View v, MotionEvent event) { if ((mSystemUiVisibility & STATUS_OR_NAV_TRANSIENT) != 0 // a transient bar is revealed && event.getAction() == MotionEvent.ACTION_OUTSIDE // touch outside the source bar && event.getX() == 0 && event.getY() == 0 // a touch outside both bars ) { userAutohide(); } } private void userAutohide() { cancelAutohide(); mHandler.postDelayed(mAutohide, 350); // longer than app gesture -> flag clear } private boolean areLightsOn() { return 0 == (mSystemUiVisibility & View.SYSTEM_UI_FLAG_LOW_PROFILE); } public void setLightsOn(boolean on) { Log.v(TAG, "setLightsOn(" + on + ")"); if (on) { setSystemUiVisibility(0, View.SYSTEM_UI_FLAG_LOW_PROFILE); } else { setSystemUiVisibility(View.SYSTEM_UI_FLAG_LOW_PROFILE, View.SYSTEM_UI_FLAG_LOW_PROFILE); } } private void notifyUiVisibilityChanged(int vis) { try { mWindowManagerService.statusBarVisibilityChanged(vis); } catch (RemoteException ex) { } } public void topAppWindowChanged(boolean showMenu) { if (DEBUG) { Log.d(TAG, (showMenu?"showing":"hiding") + " the MENU button"); } if (mNavigationBarView != null) { mNavigationBarView.setMenuVisibility(showMenu); } // See above re: lights-out policy for legacy apps. if (showMenu) setLightsOn(true); } @Override public void setImeWindowStatus(IBinder token, int vis, int backDisposition, boolean showImeSwitcher) { boolean imeShown = (vis & InputMethodService.IME_VISIBLE) != 0; int flags = mNavigationIconHints; if ((backDisposition == InputMethodService.BACK_DISPOSITION_WILL_DISMISS) || imeShown) { flags |= NAVIGATION_HINT_BACK_ALT; } else { flags &= ~NAVIGATION_HINT_BACK_ALT; } if (showImeSwitcher) { flags |= NAVIGATION_HINT_IME_SHOWN; } else { flags &= ~NAVIGATION_HINT_IME_SHOWN; } setNavigationIconHints(flags); } @Override protected void tick(StatusBarNotification n, boolean firstTime) { if (!mTickerEnabled) return; // no ticking in lights-out mode if (!areLightsOn()) return; // no ticking in Setup if (!isDeviceProvisioned()) return; // not for you if (!isNotificationForCurrentProfiles(n)) return; // Show the ticker if one is requested. Also don't do this // until status bar window is attached to the window manager, // because... well, what's the point otherwise? And trying to // run a ticker without being attached will crash! if (n.getNotification().tickerText != null && mStatusBarWindow != null && mStatusBarWindow.getWindowToken() != null) { if (0 == (mDisabled & (StatusBarManager.DISABLE_NOTIFICATION_ICONS | StatusBarManager.DISABLE_NOTIFICATION_TICKER))) { mTicker.addEntry(n); } } } private class MyTicker extends Ticker { MyTicker(Context context, View sb) { super(context, sb); if (!mTickerEnabled) { Log.w(TAG, "MyTicker instantiated with mTickerEnabled=false", new Throwable()); } } @Override public void tickerStarting() { if (!mTickerEnabled) return; mTicking = true; mStatusBarContents.setVisibility(View.GONE); mTickerView.setVisibility(View.VISIBLE); mTickerView.startAnimation(loadAnim(com.android.internal.R.anim.push_up_in, null)); mStatusBarContents.startAnimation(loadAnim(com.android.internal.R.anim.push_up_out, null)); } @Override public void tickerDone() { if (!mTickerEnabled) return; mStatusBarContents.setVisibility(View.VISIBLE); mTickerView.setVisibility(View.GONE); mStatusBarContents.startAnimation(loadAnim(com.android.internal.R.anim.push_down_in, null)); mTickerView.startAnimation(loadAnim(com.android.internal.R.anim.push_down_out, mTickingDoneListener)); } public void tickerHalting() { if (!mTickerEnabled) return; if (mStatusBarContents.getVisibility() != View.VISIBLE) { mStatusBarContents.setVisibility(View.VISIBLE); mStatusBarContents .startAnimation(loadAnim(com.android.internal.R.anim.fade_in, null)); } mTickerView.setVisibility(View.GONE); // we do not animate the ticker away at this point, just get rid of it (b/6992707) } } Animation.AnimationListener mTickingDoneListener = new Animation.AnimationListener() {; public void onAnimationEnd(Animation animation) { mTicking = false; } public void onAnimationRepeat(Animation animation) { } public void onAnimationStart(Animation animation) { } }; private Animation loadAnim(int id, Animation.AnimationListener listener) { Animation anim = AnimationUtils.loadAnimation(mContext, id); if (listener != null) { anim.setAnimationListener(listener); } return anim; } public static String viewInfo(View v) { return "[(" + v.getLeft() + "," + v.getTop() + ")(" + v.getRight() + "," + v.getBottom() + ") " + v.getWidth() + "x" + v.getHeight() + "]"; } public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { synchronized (mQueueLock) { pw.println("Current Status Bar state:"); pw.println(" mExpandedVisible=" + mExpandedVisible + ", mTrackingPosition=" + mTrackingPosition); pw.println(" mTickerEnabled=" + mTickerEnabled); if (mTickerEnabled) { pw.println(" mTicking=" + mTicking); pw.println(" mTickerView: " + viewInfo(mTickerView)); } pw.println(" mTracking=" + mTracking); pw.println(" mDisplayMetrics=" + mDisplayMetrics); pw.println(" mStackScroller: " + viewInfo(mStackScroller)); pw.println(" mStackScroller: " + viewInfo(mStackScroller) + " scroll " + mStackScroller.getScrollX() + "," + mStackScroller.getScrollY()); } pw.print(" mInteractingWindows="); pw.println(mInteractingWindows); pw.print(" mStatusBarWindowState="); pw.println(windowStateToString(mStatusBarWindowState)); pw.print(" mStatusBarMode="); pw.println(BarTransitions.modeToString(mStatusBarMode)); pw.print(" mDozing="); pw.println(mDozing); pw.print(" mZenMode="); pw.println(Settings.Global.zenModeToString(mZenMode)); pw.print(" mUseHeadsUp="); pw.println(mUseHeadsUp); pw.print(" interrupting package: "); pw.println(hunStateToString(mHeadsUpNotificationView.getEntry())); dumpBarTransitions(pw, "mStatusBarView", mStatusBarView.getBarTransitions()); if (mNavigationBarView != null) { pw.print(" mNavigationBarWindowState="); pw.println(windowStateToString(mNavigationBarWindowState)); pw.print(" mNavigationBarMode="); pw.println(BarTransitions.modeToString(mNavigationBarMode)); dumpBarTransitions(pw, "mNavigationBarView", mNavigationBarView.getBarTransitions()); } pw.print(" mNavigationBarView="); if (mNavigationBarView == null) { pw.println("null"); } else { mNavigationBarView.dump(fd, pw, args); } pw.print(" mMediaSessionManager="); pw.println(mMediaSessionManager); pw.print(" mMediaNotificationKey="); pw.println(mMediaNotificationKey); pw.print(" mMediaController="); pw.print(mMediaController); if (mMediaController != null) { pw.print(" state=" + mMediaController.getPlaybackState()); } pw.println(); pw.print(" mMediaMetadata="); pw.print(mMediaMetadata); if (mMediaMetadata != null) { pw.print(" title=" + mMediaMetadata.getText(MediaMetadata.METADATA_KEY_TITLE)); } pw.println(); pw.println(" Panels: "); if (mNotificationPanel != null) { pw.println(" mNotificationPanel=" + mNotificationPanel + " params=" + mNotificationPanel.getLayoutParams().debug("")); pw.print (" "); mNotificationPanel.dump(fd, pw, args); } DozeLog.dump(pw); if (DUMPTRUCK) { synchronized (mNotificationData) { mNotificationData.dump(pw, " "); } int N = mStatusIcons.getChildCount(); pw.println(" system icons: " + N); for (int i=0; i 0) { try { dispatchDemoCommand(command, bundle); } catch (Throwable t) { Log.w(TAG, "Error running demo command, intent=" + intent, t); } } } } else if ("fake_artwork".equals(action)) { if (DEBUG_MEDIA_FAKE_ARTWORK) { updateMediaMetaData(true); } } } }; private void resetUserExpandedStates() { ArrayList activeNotifications = mNotificationData.getActiveNotifications(); final int notificationCount = activeNotifications.size(); for (int i = 0; i < notificationCount; i++) { NotificationData.Entry entry = activeNotifications.get(i); if (entry.row != null) { entry.row.resetUserExpansion(); } } } @Override protected void dismissKeyguardThenExecute(final OnDismissAction action, boolean afterKeyguardGone) { if (mStatusBarKeyguardViewManager.isShowing()) { if (UnlockMethodCache.getInstance(mContext).isMethodInsecure() && mNotificationPanel.isLaunchTransitionRunning() && !afterKeyguardGone) { action.onDismiss(); mNotificationPanel.setLaunchTransitionEndRunnable(new Runnable() { @Override public void run() { mStatusBarKeyguardViewManager.dismiss(); } }); } else { mStatusBarKeyguardViewManager.dismissWithAction(action, afterKeyguardGone); } } else { action.onDismiss(); } } // SystemUIService notifies SystemBars of configuration changes, which then calls down here @Override protected void onConfigurationChanged(Configuration newConfig) { super.onConfigurationChanged(newConfig); // calls refreshLayout if (DEBUG) { Log.v(TAG, "configuration changed: " + mContext.getResources().getConfiguration()); } updateDisplaySize(); // populates mDisplayMetrics updateResources(); updateClockSize(); repositionNavigationBar(); updateExpandedViewPos(EXPANDED_LEAVE_ALONE); updateShowSearchHoldoff(); updateRowStates(); } @Override public void userSwitched(int newUserId) { if (MULTIUSER_DEBUG) mNotificationPanelDebugText.setText("USER " + newUserId); animateCollapsePanels(); updateNotifications(); resetUserSetupObserver(); setControllerUsers(); } private void setControllerUsers() { if (mZenModeController != null) { mZenModeController.setUserId(mCurrentUserId); } } private void resetUserSetupObserver() { mContext.getContentResolver().unregisterContentObserver(mUserSetupObserver); mUserSetupObserver.onChange(false); mContext.getContentResolver().registerContentObserver( Settings.Secure.getUriFor(Settings.Secure.USER_SETUP_COMPLETE), true, mUserSetupObserver, mCurrentUserId); } private void setHeadsUpVisibility(boolean vis) { if (!ENABLE_HEADS_UP) return; if (DEBUG) Log.v(TAG, (vis ? "showing" : "hiding") + " heads up window"); EventLog.writeEvent(EventLogTags.SYSUI_HEADS_UP_STATUS, vis ? mHeadsUpNotificationView.getKey() : "", vis ? 1 : 0); mHeadsUpNotificationView.setVisibility(vis ? View.VISIBLE : View.GONE); } public void onHeadsUpDismissed() { mHeadsUpNotificationView.dismiss(); } /** * Reload some of our resources when the configuration changes. * * We don't reload everything when the configuration changes -- we probably * should, but getting that smooth is tough. Someday we'll fix that. In the * meantime, just update the things that we know change. */ void updateResources() { // Update the quick setting tiles if (mQSPanel != null) { mQSPanel.updateResources(); } loadDimens(); mLinearOutSlowIn = AnimationUtils.loadInterpolator( mContext, android.R.interpolator.linear_out_slow_in); if (mNotificationPanel != null) { mNotificationPanel.updateResources(); } if (mHeadsUpNotificationView != null) { mHeadsUpNotificationView.updateResources(); } if (mBrightnessMirrorController != null) { mBrightnessMirrorController.updateResources(); } } private void updateClockSize() { if (mStatusBarView == null) return; TextView clock = (TextView) mStatusBarView.findViewById(R.id.clock); if (clock != null) { FontSizeUtils.updateFontSize(clock, R.dimen.status_bar_clock_size); } } protected void loadDimens() { final Resources res = mContext.getResources(); mNaturalBarHeight = res.getDimensionPixelSize( com.android.internal.R.dimen.status_bar_height); int newIconSize = res.getDimensionPixelSize( com.android.internal.R.dimen.status_bar_icon_size); int newIconHPadding = res.getDimensionPixelSize( R.dimen.status_bar_icon_padding); if (newIconHPadding != mIconHPadding || newIconSize != mIconSize) { // Log.d(TAG, "size=" + newIconSize + " padding=" + newIconHPadding); mIconHPadding = newIconHPadding; mIconSize = newIconSize; //reloadAllNotificationIcons(); // reload the tray } mEdgeBorder = res.getDimensionPixelSize(R.dimen.status_bar_edge_ignore); mNotificationPanelGravity = res.getInteger(R.integer.notification_panel_layout_gravity); if (mNotificationPanelGravity <= 0) { mNotificationPanelGravity = Gravity.START | Gravity.TOP; } mCarrierLabelHeight = res.getDimensionPixelSize(R.dimen.carrier_label_height); mStatusBarHeaderHeight = res.getDimensionPixelSize(R.dimen.status_bar_header_height); mNotificationPanelMinHeightFrac = res.getFraction(R.dimen.notification_panel_min_height_frac, 1, 1); if (mNotificationPanelMinHeightFrac < 0f || mNotificationPanelMinHeightFrac > 1f) { mNotificationPanelMinHeightFrac = 0f; } mHeadsUpNotificationDecay = res.getInteger(R.integer.heads_up_notification_decay); mRowMinHeight = res.getDimensionPixelSize(R.dimen.notification_min_height); mRowMaxHeight = res.getDimensionPixelSize(R.dimen.notification_max_height); mKeyguardMaxNotificationCount = res.getInteger(R.integer.keyguard_max_notification_count); if (DEBUG) Log.v(TAG, "updateResources"); } // Visibility reporting @Override protected void visibilityChanged(boolean visible) { mVisible = visible; if (visible) { startNotificationLoggingIfScreenOnAndVisible(); } else { stopNotificationLogging(); } super.visibilityChanged(visible); } private void stopNotificationLogging() { // Report all notifications as invisible and turn down the // reporter. if (!mCurrentlyVisibleNotifications.isEmpty()) { logNotificationVisibilityChanges( Collections.emptyList(), mCurrentlyVisibleNotifications); mCurrentlyVisibleNotifications.clear(); } mHandler.removeCallbacks(mVisibilityReporter); mStackScroller.setChildLocationsChangedListener(null); } private void startNotificationLoggingIfScreenOnAndVisible() { if (mVisible && mScreenOn) { mStackScroller.setChildLocationsChangedListener(mNotificationLocationsChangedListener); // Some transitions like mScreenOn=false -> mScreenOn=true don't // cause the scroller to emit child location events. Hence generate // one ourselves to guarantee that we're reporting visible // notifications. // (Note that in cases where the scroller does emit events, this // additional event doesn't break anything.) mNotificationLocationsChangedListener.onChildLocationsChanged(mStackScroller); } } private void logNotificationVisibilityChanges( Collection newlyVisible, Collection noLongerVisible) { if (newlyVisible.isEmpty() && noLongerVisible.isEmpty()) { return; } String[] newlyVisibleAr = newlyVisible.toArray(new String[newlyVisible.size()]); String[] noLongerVisibleAr = noLongerVisible.toArray(new String[noLongerVisible.size()]); try { mBarService.onNotificationVisibilityChanged(newlyVisibleAr, noLongerVisibleAr); } catch (RemoteException e) { // Ignore. } } // // tracing // void postStartTracing() { mHandler.postDelayed(mStartTracing, 3000); } void vibrate() { android.os.Vibrator vib = (android.os.Vibrator)mContext.getSystemService( Context.VIBRATOR_SERVICE); vib.vibrate(250, VIBRATION_ATTRIBUTES); } Runnable mStartTracing = new Runnable() { public void run() { vibrate(); SystemClock.sleep(250); Log.d(TAG, "startTracing"); android.os.Debug.startMethodTracing("/data/statusbar-traces/trace"); mHandler.postDelayed(mStopTracing, 10000); } }; Runnable mStopTracing = new Runnable() { public void run() { android.os.Debug.stopMethodTracing(); Log.d(TAG, "stopTracing"); vibrate(); } }; @Override protected void haltTicker() { if (mTickerEnabled) { mTicker.halt(); } } @Override protected boolean shouldDisableNavbarGestures() { return !isDeviceProvisioned() || mExpandedVisible || (mDisabled & StatusBarManager.DISABLE_SEARCH) != 0; } public void postStartSettingsActivity(final Intent intent, int delay) { mHandler.postDelayed(new Runnable() { @Override public void run() { handleStartSettingsActivity(intent, true /*onlyProvisioned*/); } }, delay); } private void handleStartSettingsActivity(Intent intent, boolean onlyProvisioned) { startActivityDismissingKeyguard(intent, onlyProvisioned, true /* dismissShade */); } private static class FastColorDrawable extends Drawable { private final int mColor; public FastColorDrawable(int color) { mColor = 0xff000000 | color; } @Override public void draw(Canvas canvas) { canvas.drawColor(mColor, PorterDuff.Mode.SRC); } @Override public void setAlpha(int alpha) { } @Override public void setColorFilter(ColorFilter cf) { } @Override public int getOpacity() { return PixelFormat.OPAQUE; } @Override public void setBounds(int left, int top, int right, int bottom) { } @Override public void setBounds(Rect bounds) { } } @Override public void destroy() { super.destroy(); if (mStatusBarWindow != null) { mWindowManager.removeViewImmediate(mStatusBarWindow); mStatusBarWindow = null; } if (mNavigationBarView != null) { mWindowManager.removeViewImmediate(mNavigationBarView); mNavigationBarView = null; } mContext.unregisterReceiver(mBroadcastReceiver); } private boolean mDemoModeAllowed; private boolean mDemoMode; private DemoStatusIcons mDemoStatusIcons; @Override public void dispatchDemoCommand(String command, Bundle args) { if (!mDemoModeAllowed) { mDemoModeAllowed = Settings.Global.getInt(mContext.getContentResolver(), "sysui_demo_allowed", 0) != 0; } if (!mDemoModeAllowed) return; if (command.equals(COMMAND_ENTER)) { mDemoMode = true; } else if (command.equals(COMMAND_EXIT)) { mDemoMode = false; checkBarModes(); } else if (!mDemoMode) { // automatically enter demo mode on first demo command dispatchDemoCommand(COMMAND_ENTER, new Bundle()); } boolean modeChange = command.equals(COMMAND_ENTER) || command.equals(COMMAND_EXIT); if (modeChange || command.equals(COMMAND_CLOCK)) { dispatchDemoCommandToView(command, args, R.id.clock); } if (modeChange || command.equals(COMMAND_BATTERY)) { dispatchDemoCommandToView(command, args, R.id.battery); } if (modeChange || command.equals(COMMAND_STATUS)) { if (mDemoStatusIcons == null) { mDemoStatusIcons = new DemoStatusIcons(mStatusIcons, mIconSize); } mDemoStatusIcons.dispatchDemoCommand(command, args); } if (mNetworkController != null && (modeChange || command.equals(COMMAND_NETWORK))) { mNetworkController.dispatchDemoCommand(command, args); } if (modeChange || command.equals(COMMAND_NOTIFICATIONS)) { View notifications = mStatusBarView == null ? null : mStatusBarView.findViewById(R.id.notification_icon_area); if (notifications != null) { String visible = args.getString("visible"); int vis = mDemoMode && "false".equals(visible) ? View.INVISIBLE : View.VISIBLE; notifications.setVisibility(vis); } } if (command.equals(COMMAND_BARS)) { String mode = args.getString("mode"); int barMode = "opaque".equals(mode) ? MODE_OPAQUE : "translucent".equals(mode) ? MODE_TRANSLUCENT : "semi-transparent".equals(mode) ? MODE_SEMI_TRANSPARENT : "transparent".equals(mode) ? MODE_TRANSPARENT : "warning".equals(mode) ? MODE_WARNING : -1; if (barMode != -1) { boolean animate = true; if (mStatusBarView != null) { mStatusBarView.getBarTransitions().transitionTo(barMode, animate); } if (mNavigationBarView != null) { mNavigationBarView.getBarTransitions().transitionTo(barMode, animate); } } } } private void dispatchDemoCommandToView(String command, Bundle args, int id) { if (mStatusBarView == null) return; View v = mStatusBarView.findViewById(id); if (v instanceof DemoMode) { ((DemoMode)v).dispatchDemoCommand(command, args); } } /** * @return The {@link StatusBarState} the status bar is in. */ public int getBarState() { return mState; } public void showKeyguard() { if (mLaunchTransitionFadingAway) { mNotificationPanel.animate().cancel(); mNotificationPanel.setAlpha(1f); if (mLaunchTransitionEndRunnable != null) { mLaunchTransitionEndRunnable.run(); } mLaunchTransitionEndRunnable = null; mLaunchTransitionFadingAway = false; } setBarState(StatusBarState.KEYGUARD); updateKeyguardState(false /* goingToFullShade */, false /* fromShadeLocked */); if (!mScreenOnFromKeyguard) { // If the screen is off already, we need to disable touch events because these might // collapse the panel after we expanded it, and thus we would end up with a blank // Keyguard. mNotificationPanel.setTouchDisabled(true); } instantExpandNotificationsPanel(); mLeaveOpenOnKeyguardHide = false; if (mDraggedDownRow != null) { mDraggedDownRow.setUserLocked(false); mDraggedDownRow.notifyHeightChanged(); mDraggedDownRow = null; } } public boolean isCollapsing() { return mNotificationPanel.isCollapsing(); } public void addPostCollapseAction(Runnable r) { mPostCollapseRunnables.add(r); } public boolean isInLaunchTransition() { return mNotificationPanel.isLaunchTransitionRunning() || mNotificationPanel.isLaunchTransitionFinished(); } /** * Fades the content of the keyguard away after the launch transition is done. * * @param beforeFading the runnable to be run when the circle is fully expanded and the fading * starts * @param endRunnable the runnable to be run when the transition is done */ public void fadeKeyguardAfterLaunchTransition(final Runnable beforeFading, Runnable endRunnable) { mLaunchTransitionEndRunnable = endRunnable; Runnable hideRunnable = new Runnable() { @Override public void run() { mLaunchTransitionFadingAway = true; if (beforeFading != null) { beforeFading.run(); } mNotificationPanel.setAlpha(1); mNotificationPanel.animate() .alpha(0) .setStartDelay(FADE_KEYGUARD_START_DELAY) .setDuration(FADE_KEYGUARD_DURATION) .withLayer() .withEndAction(new Runnable() { @Override public void run() { mNotificationPanel.setAlpha(1); if (mLaunchTransitionEndRunnable != null) { mLaunchTransitionEndRunnable.run(); } mLaunchTransitionEndRunnable = null; mLaunchTransitionFadingAway = false; } }); } }; if (mNotificationPanel.isLaunchTransitionRunning()) { mNotificationPanel.setLaunchTransitionEndRunnable(hideRunnable); } else { hideRunnable.run(); } } /** * @return true if we would like to stay in the shade, false if it should go away entirely */ public boolean hideKeyguard() { boolean staying = mLeaveOpenOnKeyguardHide; setBarState(StatusBarState.SHADE); if (mLeaveOpenOnKeyguardHide) { mLeaveOpenOnKeyguardHide = false; mNotificationPanel.animateToFullShade(calculateGoingToFullShadeDelay()); if (mDraggedDownRow != null) { mDraggedDownRow.setUserLocked(false); mDraggedDownRow = null; } } else { instantCollapseNotificationPanel(); } updateKeyguardState(staying, false /* fromShadeLocked */); return staying; } public long calculateGoingToFullShadeDelay() { return mKeyguardFadingAwayDelay + mKeyguardFadingAwayDuration; } /** * Notifies the status bar the Keyguard is fading away with the specified timings. * * @param delay the animation delay in miliseconds * @param fadeoutDuration the duration of the exit animation, in milliseconds */ public void setKeyguardFadingAway(long delay, long fadeoutDuration) { mKeyguardFadingAway = true; mKeyguardFadingAwayDelay = delay; mKeyguardFadingAwayDuration = fadeoutDuration; mWaitingForKeyguardExit = false; disable(mDisabledUnmodified, true /* animate */); } public boolean isKeyguardFadingAway() { return mKeyguardFadingAway; } /** * Notifies that the Keyguard fading away animation is done. */ public void finishKeyguardFadingAway() { mKeyguardFadingAway = false; } private void updatePublicMode() { setLockscreenPublicMode( (mStatusBarKeyguardViewManager.isShowing() || mStatusBarKeyguardViewManager.isOccluded()) && mStatusBarKeyguardViewManager.isSecure()); } private void updateKeyguardState(boolean goingToFullShade, boolean fromShadeLocked) { if (mState == StatusBarState.KEYGUARD) { mKeyguardIndicationController.setVisible(true); mNotificationPanel.resetViews(); mKeyguardUserSwitcher.setKeyguard(true, fromShadeLocked); } else { mKeyguardIndicationController.setVisible(false); mKeyguardUserSwitcher.setKeyguard(false, goingToFullShade || mState == StatusBarState.SHADE_LOCKED || fromShadeLocked); } if (mState == StatusBarState.KEYGUARD || mState == StatusBarState.SHADE_LOCKED) { mScrimController.setKeyguardShowing(true); } else { mScrimController.setKeyguardShowing(false); } mNotificationPanel.setBarState(mState, mKeyguardFadingAway, goingToFullShade); updateDozingState(); updatePublicMode(); updateStackScrollerState(goingToFullShade); updateNotifications(); checkBarModes(); updateCarrierLabelVisibility(false); updateMediaMetaData(false); mKeyguardMonitor.notifyKeyguardState(mStatusBarKeyguardViewManager.isShowing(), mStatusBarKeyguardViewManager.isSecure()); } private void updateDozingState() { if (mState != StatusBarState.KEYGUARD && !mNotificationPanel.isDozing()) { return; } mNotificationPanel.setDozing(mDozing); if (mDozing) { mKeyguardBottomArea.setVisibility(View.INVISIBLE); mStackScroller.setDark(true, false /*animate*/); } else { mKeyguardBottomArea.setVisibility(View.VISIBLE); mStackScroller.setDark(false, false /*animate*/); } mScrimController.setDozing(mDozing); } public void updateStackScrollerState(boolean goingToFullShade) { if (mStackScroller == null) return; boolean onKeyguard = mState == StatusBarState.KEYGUARD; mStackScroller.setHideSensitive(isLockscreenPublicMode(), goingToFullShade); mStackScroller.setDimmed(onKeyguard, false /* animate */); mStackScroller.setExpandingEnabled(!onKeyguard); ActivatableNotificationView activatedChild = mStackScroller.getActivatedChild(); mStackScroller.setActivatedChild(null); if (activatedChild != null) { activatedChild.makeInactive(false /* animate */); } } public void userActivity() { if (mState == StatusBarState.KEYGUARD) { mKeyguardViewMediatorCallback.userActivity(); } } public boolean interceptMediaKey(KeyEvent event) { return mState == StatusBarState.KEYGUARD && mStatusBarKeyguardViewManager.interceptMediaKey(event); } public boolean onMenuPressed() { return mState == StatusBarState.KEYGUARD && mStatusBarKeyguardViewManager.onMenuPressed(); } public boolean onBackPressed() { if (mStatusBarKeyguardViewManager.onBackPressed()) { return true; } if (mNotificationPanel.isQsExpanded()) { if (mNotificationPanel.isQsDetailShowing()) { mNotificationPanel.closeQsDetail(); } else { mNotificationPanel.animateCloseQs(); } return true; } if (mState != StatusBarState.KEYGUARD && mState != StatusBarState.SHADE_LOCKED) { animateCollapsePanels(); return true; } return false; } public boolean onSpacePressed() { if (mScreenOn != null && mScreenOn && (mState == StatusBarState.KEYGUARD || mState == StatusBarState.SHADE_LOCKED)) { animateCollapsePanels(0 /* flags */, true /* force */); return true; } return false; } private void showBouncer() { if (mState == StatusBarState.KEYGUARD || mState == StatusBarState.SHADE_LOCKED) { mWaitingForKeyguardExit = mStatusBarKeyguardViewManager.isShowing(); mStatusBarKeyguardViewManager.dismiss(); } } private void instantExpandNotificationsPanel() { // Make our window larger and the panel expanded. makeExpandedVisible(true); mNotificationPanel.instantExpand(); } private void instantCollapseNotificationPanel() { mNotificationPanel.instantCollapse(); } @Override public void onActivated(ActivatableNotificationView view) { mKeyguardIndicationController.showTransientIndication(R.string.notification_tap_again); ActivatableNotificationView previousView = mStackScroller.getActivatedChild(); if (previousView != null) { previousView.makeInactive(true /* animate */); } mStackScroller.setActivatedChild(view); } /** * @param state The {@link StatusBarState} to set. */ public void setBarState(int state) { mState = state; mStatusBarWindowManager.setStatusBarState(state); } @Override public void onActivationReset(ActivatableNotificationView view) { if (view == mStackScroller.getActivatedChild()) { mKeyguardIndicationController.hideTransientIndication(); mStackScroller.setActivatedChild(null); } } public void onTrackingStarted() { runPostCollapseRunnables(); } public void onUnlockHintStarted() { mKeyguardIndicationController.showTransientIndication(R.string.keyguard_unlock); } public void onHintFinished() { // Delay the reset a bit so the user can read the text. mKeyguardIndicationController.hideTransientIndicationDelayed(HINT_RESET_DELAY_MS); } public void onCameraHintStarted() { mKeyguardIndicationController.showTransientIndication(R.string.camera_hint); } public void onPhoneHintStarted() { mKeyguardIndicationController.showTransientIndication(R.string.phone_hint); } public void onTrackingStopped(boolean expand) { if (mState == StatusBarState.KEYGUARD || mState == StatusBarState.SHADE_LOCKED) { if (!expand && !mUnlockMethodCache.isMethodInsecure()) { showBouncer(); } } } @Override protected int getMaxKeyguardNotifications() { return mKeyguardMaxNotificationCount; } public NavigationBarView getNavigationBarView() { return mNavigationBarView; } // ---------------------- DragDownHelper.OnDragDownListener ------------------------------------ @Override public boolean onDraggedDown(View startingChild) { if (hasActiveNotifications()) { // We have notifications, go to locked shade. goToLockedShade(startingChild); return true; } else { // No notifications - abort gesture. return false; } } @Override public void onDragDownReset() { mStackScroller.setDimmed(true /* dimmed */, true /* animated */); } @Override public void onThresholdReached() { mStackScroller.setDimmed(false /* dimmed */, true /* animate */); } @Override public void onTouchSlopExceeded() { mStackScroller.removeLongPressCallback(); } @Override public void setEmptyDragAmount(float amount) { mNotificationPanel.setEmptyDragAmount(amount); } /** * If secure with redaction: Show bouncer, go to unlocked shade. * *

If secure without redaction or no security: Go to {@link StatusBarState#SHADE_LOCKED}.

* * @param expandView The view to expand after going to the shade. */ public void goToLockedShade(View expandView) { ExpandableNotificationRow row = null; if (expandView instanceof ExpandableNotificationRow) { row = (ExpandableNotificationRow) expandView; row.setUserExpanded(true); } boolean fullShadeNeedsBouncer = !userAllowsPrivateNotificationsInPublic(mCurrentUserId) || !mShowLockscreenNotifications; if (isLockscreenPublicMode() && fullShadeNeedsBouncer) { mLeaveOpenOnKeyguardHide = true; showBouncer(); mDraggedDownRow = row; } else { mNotificationPanel.animateToFullShade(0 /* delay */); setBarState(StatusBarState.SHADE_LOCKED); updateKeyguardState(false /* goingToFullShade */, false /* fromShadeLocked */); if (row != null) { row.setUserLocked(false); } } } /** * Goes back to the keyguard after hanging around in {@link StatusBarState#SHADE_LOCKED}. */ public void goToKeyguard() { if (mState == StatusBarState.SHADE_LOCKED) { mStackScroller.onGoToKeyguard(); setBarState(StatusBarState.KEYGUARD); updateKeyguardState(false /* goingToFullShade */, true /* fromShadeLocked*/); } } /** * @return a ViewGroup that spans the entire panel which contains the quick settings */ public ViewGroup getQuickSettingsOverlayParent() { return mNotificationPanel; } public long getKeyguardFadingAwayDelay() { return mKeyguardFadingAwayDelay; } public long getKeyguardFadingAwayDuration() { return mKeyguardFadingAwayDuration; } public LinearLayout getSystemIcons() { return mSystemIcons; } public LinearLayout getSystemIconArea() { return mSystemIconArea; } @Override public void setBouncerShowing(boolean bouncerShowing) { super.setBouncerShowing(bouncerShowing); disable(mDisabledUnmodified, true /* animate */); } public void onScreenTurnedOff() { mScreenOnFromKeyguard = false; mScreenOnComingFromTouch = false; mStackScroller.setAnimationsEnabled(false); } public void onScreenTurnedOn() { mScreenOnFromKeyguard = true; mStackScroller.setAnimationsEnabled(true); mNotificationPanel.onScreenTurnedOn(); mNotificationPanel.setTouchDisabled(false); } /** * This handles long-press of both back and recents. They are * handled together to capture them both being long-pressed * at the same time to exit screen pinning (lock task). * * When accessibility mode is on, only a long-press from recents * is required to exit. * * In all other circumstances we try to pass through long-press events * for Back, so that apps can still use it. Which can be from two things. * 1) Not currently in screen pinning (lock task). * 2) Back is long-pressed without recents. */ private void handleLongPressBackRecents(View v) { try { boolean sendBackLongPress = false; IActivityManager activityManager = ActivityManagerNative.getDefault(); boolean isAccessiblityEnabled = mAccessibilityManager.isEnabled(); if (activityManager.isInLockTaskMode() && !isAccessiblityEnabled) { long time = System.currentTimeMillis(); // If we recently long-pressed the other button then they were // long-pressed 'together' if ((time - mLastLockToAppLongPress) < LOCK_TO_APP_GESTURE_TOLERENCE) { activityManager.stopLockTaskModeOnCurrent(); } else if ((v.getId() == R.id.back) && !mNavigationBarView.getRecentsButton().isPressed()) { // If we aren't pressing recents right now then they presses // won't be together, so send the standard long-press action. sendBackLongPress = true; } mLastLockToAppLongPress = time; } else { // If this is back still need to handle sending the long-press event. if (v.getId() == R.id.back) { sendBackLongPress = true; } else if (isAccessiblityEnabled && activityManager.isInLockTaskMode()) { // When in accessibility mode a long press that is recents (not back) // should stop lock task. activityManager.stopLockTaskModeOnCurrent(); } } if (sendBackLongPress) { KeyButtonView keyButtonView = (KeyButtonView) v; keyButtonView.sendEvent(KeyEvent.ACTION_DOWN, KeyEvent.FLAG_LONG_PRESS); keyButtonView.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_LONG_CLICKED); } } catch (RemoteException e) { Log.d(TAG, "Unable to reach activity manager", e); } } // Recents @Override protected void showRecents(boolean triggeredFromAltTab) { // Set the recents visibility flag mSystemUiVisibility |= View.RECENT_APPS_VISIBLE; notifyUiVisibilityChanged(mSystemUiVisibility); super.showRecents(triggeredFromAltTab); } @Override protected void hideRecents(boolean triggeredFromAltTab, boolean triggeredFromHomeKey) { // Unset the recents visibility flag mSystemUiVisibility &= ~View.RECENT_APPS_VISIBLE; notifyUiVisibilityChanged(mSystemUiVisibility); super.hideRecents(triggeredFromAltTab, triggeredFromHomeKey); } @Override protected void toggleRecents() { // Toggle the recents visibility flag mSystemUiVisibility ^= View.RECENT_APPS_VISIBLE; notifyUiVisibilityChanged(mSystemUiVisibility); super.toggleRecents(); } @Override public void onVisibilityChanged(boolean visible) { // Update the recents visibility flag if (visible) { mSystemUiVisibility |= View.RECENT_APPS_VISIBLE; } else { mSystemUiVisibility &= ~View.RECENT_APPS_VISIBLE; } notifyUiVisibilityChanged(mSystemUiVisibility); } public boolean hasActiveNotifications() { return !mNotificationData.getActiveNotifications().isEmpty(); } public void wakeUpIfDozing(long time, boolean fromTouch) { if (mDozing && mScrimController.isPulsing()) { PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); pm.wakeUp(time); if (fromTouch) { mScreenOnComingFromTouch = true; } } } private final class ShadeUpdates { private final ArraySet mVisibleNotifications = new ArraySet(); private final ArraySet mNewVisibleNotifications = new ArraySet(); public void check() { mNewVisibleNotifications.clear(); ArrayList activeNotifications = mNotificationData.getActiveNotifications(); for (int i = 0; i < activeNotifications.size(); i++) { final Entry entry = activeNotifications.get(i); final boolean visible = entry.row != null && entry.row.getVisibility() == View.VISIBLE; if (visible) { mNewVisibleNotifications.add(entry.key + entry.notification.getPostTime()); } } final boolean updates = !mVisibleNotifications.containsAll(mNewVisibleNotifications); mVisibleNotifications.clear(); mVisibleNotifications.addAll(mNewVisibleNotifications); // We have new notifications if (updates && mDozeServiceHost != null) { mDozeServiceHost.fireNewNotifications(); } } } private final class DozeServiceHost implements DozeHost { // Amount of time to allow to update the time shown on the screen before releasing // the wakelock. This timeout is design to compensate for the fact that we don't // currently have a way to know when time display contents have actually been // refreshed once we've finished rendering a new frame. private static final long PROCESSING_TIME = 500; private final ArrayList mCallbacks = new ArrayList(); private final H mHandler = new H(); @Override public String toString() { return "PSB.DozeServiceHost[mCallbacks=" + mCallbacks.size() + "]"; } public void firePowerSaveChanged(boolean active) { for (Callback callback : mCallbacks) { callback.onPowerSaveChanged(active); } } public void fireBuzzBeepBlinked() { for (Callback callback : mCallbacks) { callback.onBuzzBeepBlinked(); } } public void fireNotificationLight(boolean on) { for (Callback callback : mCallbacks) { callback.onNotificationLight(on); } } public void fireNewNotifications() { for (Callback callback : mCallbacks) { callback.onNewNotifications(); } } @Override public void addCallback(@NonNull Callback callback) { mCallbacks.add(callback); } @Override public void removeCallback(@NonNull Callback callback) { mCallbacks.remove(callback); } @Override public void startDozing(@NonNull Runnable ready) { mHandler.obtainMessage(H.MSG_START_DOZING, ready).sendToTarget(); } @Override public void pulseWhileDozing(@NonNull PulseCallback callback) { mHandler.obtainMessage(H.MSG_PULSE_WHILE_DOZING, callback).sendToTarget(); } @Override public void stopDozing() { mHandler.obtainMessage(H.MSG_STOP_DOZING).sendToTarget(); } @Override public boolean isPowerSaveActive() { return mBatteryController != null && mBatteryController.isPowerSave(); } private void handleStartDozing(@NonNull Runnable ready) { if (!mDozing) { mDozing = true; DozeLog.traceDozing(mContext, mDozing); updateDozingState(); } ready.run(); } private void handlePulseWhileDozing(@NonNull PulseCallback callback) { mScrimController.pulse(callback); } private void handleStopDozing() { if (mDozing) { mDozing = false; DozeLog.traceDozing(mContext, mDozing); updateDozingState(); } } private final class H extends Handler { private static final int MSG_START_DOZING = 1; private static final int MSG_PULSE_WHILE_DOZING = 2; private static final int MSG_STOP_DOZING = 3; @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_START_DOZING: handleStartDozing((Runnable) msg.obj); break; case MSG_PULSE_WHILE_DOZING: handlePulseWhileDozing((PulseCallback) msg.obj); break; case MSG_STOP_DOZING: handleStopDozing(); break; } } } } }