/*
* Copyright (C) 2007 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.server.status;
import com.android.internal.R;
import com.android.internal.util.CharSequences;
import android.app.ActivityManagerNative;
import android.app.Dialog;
import android.app.IStatusBar;
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.pm.PackageManager;
import android.content.res.Resources;
import android.graphics.PixelFormat;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.Binder;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.provider.Telephony;
import android.util.Log;
import android.view.Display;
import android.view.Gravity;
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.Window;
import android.view.WindowManager;
import android.view.WindowManagerImpl;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.LinearLayout;
import android.widget.RemoteViews;
import android.widget.ScrollView;
import android.widget.TextView;
import android.widget.FrameLayout;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
/**
* The public (ok, semi-public) service for the status bar.
*
* This interesting thing to note about this class is that most of the methods that
* are called from other classes just post a message, and everything else is batched
* and coalesced into a series of calls to methods that all start with "perform."
* There are two reasons for this. The first is that some of the methods (activate/deactivate)
* are on IStatusBar, so they're called from the thread pool and they need to make their
* way onto the UI thread. The second is that the message queue is stopped while animations
* are happening in order to make for smoother transitions.
*
* Each icon is either an icon or an icon and a notification. They're treated mostly
* separately throughout the code, although they both use the same key, which is assigned
* when they are created.
*/
public class StatusBarService extends IStatusBar.Stub
{
static final String TAG = "StatusBar";
static final boolean DEBUG = false;
static final boolean SPEW = false;
static final boolean DBG = false;
static final int EXPANDED_LEAVE_ALONE = -10000;
static final int EXPANDED_FULL_OPEN = -10001;
private static final int MSG_ANIMATE = 1000;
private static final int MSG_ANIMATE_REVEAL = 1001;
private static final int OP_ADD_ICON = 1;
private static final int OP_UPDATE_ICON = 2;
private static final int OP_REMOVE_ICON = 3;
private static final int OP_SET_VISIBLE = 4;
private static final int OP_EXPAND = 5;
private static final int OP_TOGGLE = 6;
private static final int OP_DISABLE = 7;
private class PendingOp {
IBinder key;
int code;
IconData iconData;
NotificationData notificationData;
boolean visible;
int integer;
}
private class DisableRecord implements IBinder.DeathRecipient {
String pkg;
int what;
IBinder token;
public void binderDied() {
Log.i(TAG, "binder died for pkg=" + pkg);
disable(0, token, pkg);
token.unlinkToDeath(this, 0);
}
}
public interface NotificationCallbacks {
void onSetDisabled(int status);
void onClearAll();
void onNotificationClick(String pkg, int id);
void onPanelRevealed();
}
private class ExpandedDialog extends Dialog {
ExpandedDialog(Context context) {
super(context, com.android.internal.R.style.Theme_Light_NoTitleBar);
}
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
boolean down = event.getAction() == KeyEvent.ACTION_DOWN;
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_BACK:
if (down) {
StatusBarService.this.deactivate();
}
return true;
}
return super.dispatchKeyEvent(event);
}
}
final Context mContext;
final Display mDisplay;
StatusBarView mStatusBarView;
int mPixelFormat;
H mHandler = new H();
ArrayList mQueue = new ArrayList();
NotificationCallbacks mNotificationCallbacks;
// All accesses to mIconMap and mNotificationData are syncronized on those objects,
// but this is only so dump() can work correctly. Modifying these outside of the UI
// thread will not work, there are places in the code that unlock and reaquire between
// reads and require them to not be modified.
// icons
HashMap mIconMap = new HashMap();
ArrayList mIconList = new ArrayList();
String[] mRightIconSlots;
StatusBarIcon[] mRightIcons;
LinearLayout mIcons;
IconMerger mNotificationIcons;
LinearLayout mStatusIcons;
StatusBarIcon mMoreIcon;
private UninstallReceiver mUninstallReceiver;
// expanded notifications
NotificationViewList mNotificationData = new NotificationViewList();
Dialog mExpandedDialog;
ExpandedView mExpandedView;
WindowManager.LayoutParams mExpandedParams;
ScrollView mScrollView;
View mNotificationLinearLayout;
TextView mOngoingTitle;
LinearLayout mOngoingItems;
TextView mLatestTitle;
LinearLayout mLatestItems;
TextView mNoNotificationsTitle;
TextView mSpnLabel;
TextView mPlmnLabel;
TextView mClearButton;
CloseDragHandle mCloseView;
int[] mCloseLocation = new int[2];
boolean mExpanded;
boolean mExpandedVisible;
// the date view
DateView mDateView;
// the tracker view
TrackingView mTrackingView;
WindowManager.LayoutParams mTrackingParams;
int mTrackingPosition;
// ticker
private Ticker mTicker;
private View mTickerView;
private boolean mTicking;
// Tracking finger for opening/closing.
boolean mTracking;
VelocityTracker mVelocityTracker;
static final int ANIM_FRAME_DURATION = (1000/60);
boolean mAnimating;
long mCurAnimationTime;
float mDisplayHeight;
float mAnimY;
float mAnimVel;
float mAnimAccel;
long mAnimLastTime;
boolean mAnimatingReveal = false;
int mViewDelta;
int[] mAbsPos = new int[2];
// for disabling the status bar
ArrayList mDisableRecords = new ArrayList();
int mDisabled = 0;
/**
* Construct the service, add the status bar view to the window manager
*/
public StatusBarService(Context context) {
mContext = context;
mDisplay = ((WindowManager)context.getSystemService(
Context.WINDOW_SERVICE)).getDefaultDisplay();
makeStatusBarView(context);
mUninstallReceiver = new UninstallReceiver();
}
public void setNotificationCallbacks(NotificationCallbacks listener) {
mNotificationCallbacks = listener;
}
// ================================================================================
// Constructing the view
// ================================================================================
private void makeStatusBarView(Context context) {
Resources res = context.getResources();
mRightIconSlots = res.getStringArray(com.android.internal.R.array.status_bar_icon_order);
mRightIcons = new StatusBarIcon[mRightIconSlots.length];
ExpandedView expanded = (ExpandedView)View.inflate(context,
com.android.internal.R.layout.status_bar_expanded, null);
expanded.mService = this;
StatusBarView sb = (StatusBarView)View.inflate(context,
com.android.internal.R.layout.status_bar, null);
sb.mService = this;
// figure out which pixel-format to use for the status bar.
mPixelFormat = PixelFormat.TRANSLUCENT;
Drawable bg = sb.getBackground();
if (bg != null) {
mPixelFormat = bg.getOpacity();
}
mStatusBarView = sb;
mStatusIcons = (LinearLayout)sb.findViewById(R.id.statusIcons);
mNotificationIcons = (IconMerger)sb.findViewById(R.id.notificationIcons);
mNotificationIcons.service = this;
mIcons = (LinearLayout)sb.findViewById(R.id.icons);
mTickerView = sb.findViewById(R.id.ticker);
mDateView = (DateView)sb.findViewById(R.id.date);
mExpandedDialog = new ExpandedDialog(context);
mExpandedView = expanded;
mOngoingTitle = (TextView)expanded.findViewById(R.id.ongoingTitle);
mOngoingItems = (LinearLayout)expanded.findViewById(R.id.ongoingItems);
mLatestTitle = (TextView)expanded.findViewById(R.id.latestTitle);
mLatestItems = (LinearLayout)expanded.findViewById(R.id.latestItems);
mNoNotificationsTitle = (TextView)expanded.findViewById(R.id.noNotificationsTitle);
mClearButton = (TextView)expanded.findViewById(R.id.clear_all_button);
mClearButton.setOnClickListener(mClearButtonListener);
mSpnLabel = (TextView)expanded.findViewById(R.id.spnLabel);
mPlmnLabel = (TextView)expanded.findViewById(R.id.plmnLabel);
mScrollView = (ScrollView)expanded.findViewById(R.id.scroll);
mNotificationLinearLayout = expanded.findViewById(R.id.notificationLinearLayout);
mOngoingTitle.setVisibility(View.GONE);
mLatestTitle.setVisibility(View.GONE);
mTicker = new MyTicker(context, sb);
TickerView tickerView = (TickerView)sb.findViewById(R.id.tickerText);
tickerView.mTicker = mTicker;
mTrackingView = (TrackingView)View.inflate(context,
com.android.internal.R.layout.status_bar_tracking, null);
mTrackingView.mService = this;
mCloseView = (CloseDragHandle)mTrackingView.findViewById(R.id.close);
mCloseView.mService = this;
// add the more icon for the notifications
IconData moreData = IconData.makeIcon(null, context.getPackageName(),
R.drawable.stat_notify_more, 0, 42);
mMoreIcon = new StatusBarIcon(context, moreData, mNotificationIcons);
mMoreIcon.view.setId(R.drawable.stat_notify_more);
mNotificationIcons.moreIcon = mMoreIcon;
mNotificationIcons.addView(mMoreIcon.view);
// set the inital view visibility
setAreThereNotifications();
mDateView.setVisibility(View.INVISIBLE);
// before we register for broadcasts
mPlmnLabel.setText(R.string.lockscreen_carrier_default);
mPlmnLabel.setVisibility(View.VISIBLE);
mSpnLabel.setText("");
mSpnLabel.setVisibility(View.GONE);
// receive broadcasts
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);
filter.addAction(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
filter.addAction(Telephony.Intents.SPN_STRINGS_UPDATED_ACTION);
context.registerReceiver(mBroadcastReceiver, filter);
}
public void systemReady() {
final StatusBarView view = mStatusBarView;
WindowManager.LayoutParams lp = new WindowManager.LayoutParams(
ViewGroup.LayoutParams.FILL_PARENT,
view.getContext().getResources().getDimensionPixelSize(
com.android.internal.R.dimen.status_bar_height),
WindowManager.LayoutParams.TYPE_STATUS_BAR,
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|
WindowManager.LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING,
mPixelFormat);
lp.gravity = Gravity.TOP | Gravity.FILL_HORIZONTAL;
lp.setTitle("StatusBar");
lp.windowAnimations = R.style.Animation_StatusBar;
WindowManagerImpl.getDefault().addView(view, lp);
}
// ================================================================================
// From IStatusBar
// ================================================================================
public void activate() {
enforceExpandStatusBar();
addPendingOp(OP_EXPAND, null, true);
}
public void deactivate() {
enforceExpandStatusBar();
addPendingOp(OP_EXPAND, null, false);
}
public void toggle() {
enforceExpandStatusBar();
addPendingOp(OP_TOGGLE, null, false);
}
public void disable(int what, IBinder token, String pkg) {
enforceStatusBar();
synchronized (mNotificationCallbacks) {
// This is a little gross, but I think it's safe as long as nobody else
// synchronizes on mNotificationCallbacks. It's important that the the callback
// and the pending op get done in the correct order and not interleaved with
// other calls, otherwise they'll get out of sync.
int net;
synchronized (mDisableRecords) {
manageDisableListLocked(what, token, pkg);
net = gatherDisableActionsLocked();
mNotificationCallbacks.onSetDisabled(net);
}
addPendingOp(OP_DISABLE, net);
}
}
public IBinder addIcon(String slot, String iconPackage, int iconId, int iconLevel) {
enforceStatusBar();
return addIcon(IconData.makeIcon(slot, iconPackage, iconId, iconLevel, 0), null);
}
public void updateIcon(IBinder key,
String slot, String iconPackage, int iconId, int iconLevel) {
enforceStatusBar();
updateIcon(key, IconData.makeIcon(slot, iconPackage, iconId, iconLevel, 0), null);
}
public void removeIcon(IBinder key) {
enforceStatusBar();
addPendingOp(OP_REMOVE_ICON, key, null, null, -1);
}
private void enforceStatusBar() {
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.STATUS_BAR,
"StatusBarService");
}
private void enforceExpandStatusBar() {
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.EXPAND_STATUS_BAR,
"StatusBarService");
}
// ================================================================================
// Can be called from any thread
// ================================================================================
public IBinder addIcon(IconData data, NotificationData n) {
int slot;
// assert early-on if they using a slot that doesn't exist.
if (data != null && n == null) {
slot = getRightIconIndex(data.slot);
if (slot < 0) {
throw new SecurityException("invalid status bar icon slot: "
+ (data.slot != null ? "'" + data.slot + "'" : "null"));
}
} else {
slot = -1;
}
IBinder key = new Binder();
addPendingOp(OP_ADD_ICON, key, data, n, -1);
return key;
}
public void updateIcon(IBinder key, IconData data, NotificationData n) {
addPendingOp(OP_UPDATE_ICON, key, data, n, -1);
}
public void setIconVisibility(IBinder key, boolean visible) {
addPendingOp(OP_SET_VISIBLE, key, visible);
}
private void addPendingOp(int code, IBinder key, IconData data, NotificationData n, int i) {
synchronized (mQueue) {
PendingOp op = new PendingOp();
op.key = key;
op.code = code;
op.iconData = data == null ? null : data.clone();
op.notificationData = n;
op.integer = i;
mQueue.add(op);
if (mQueue.size() == 1) {
mHandler.sendEmptyMessage(2);
}
}
}
private void addPendingOp(int code, IBinder key, boolean visible) {
synchronized (mQueue) {
PendingOp op = new PendingOp();
op.key = key;
op.code = code;
op.visible = visible;
mQueue.add(op);
if (mQueue.size() == 1) {
mHandler.sendEmptyMessage(1);
}
}
}
private void addPendingOp(int code, int integer) {
synchronized (mQueue) {
PendingOp op = new PendingOp();
op.code = code;
op.integer = integer;
mQueue.add(op);
if (mQueue.size() == 1) {
mHandler.sendEmptyMessage(1);
}
}
}
// lock on mDisableRecords
void manageDisableListLocked(int what, IBinder token, String pkg) {
if (SPEW) {
Log.d(TAG, "manageDisableList what=0x" + Integer.toHexString(what)
+ " pkg=" + pkg);
}
// update the list
synchronized (mDisableRecords) {
final int N = mDisableRecords.size();
DisableRecord tok = null;
int i;
for (i=0; i 0) {
PendingOp op = mQueue.get(0);
boolean doOp = false;
boolean visible = false;
boolean doVisibility = false;
if (op.code == OP_SET_VISIBLE) {
doVisibility = true;
visible = op.visible;
}
else if (op.code == OP_EXPAND) {
doExpand = true;
expand = op.visible;
}
else if (op.code == OP_TOGGLE) {
doExpand = true;
expand = !expand;
}
else {
doOp = true;
}
if (alwaysHandle(op.code)) {
// coalesce these
for (int i=1; i s
final float y = mAnimY;
final float v = mAnimVel; // px/s
final float a = mAnimAccel; // px/s/s
mAnimY = y + (v*t) + (0.5f*a*t*t); // px
mAnimVel = v + (a*t); // px/s
mAnimLastTime = now; // ms
//Log.d(TAG, "y=" + y + " v=" + v + " a=" + a + " t=" + t + " mAnimY=" + mAnimY
// + " mAnimAccel=" + mAnimAccel);
}
void doRevealAnimation() {
final int h = mCloseView.getHeight() + mStatusBarView.getHeight();
if (mAnimatingReveal && mAnimating && mAnimY < h) {
incrementAnim();
if (mAnimY >= h) {
mAnimY = h;
updateExpandedViewPos((int)mAnimY);
} else {
updateExpandedViewPos((int)mAnimY);
mCurAnimationTime += ANIM_FRAME_DURATION;
mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE_REVEAL),
mCurAnimationTime);
}
}
}
void prepareTracking(int y) {
mTracking = true;
mVelocityTracker = VelocityTracker.obtain();
boolean opening = !mExpanded;
if (!mExpanded) {
mAnimAccel = 2000.0f;
mAnimVel = 200;
mAnimY = mStatusBarView.getHeight();
updateExpandedViewPos((int)mAnimY);
mAnimating = true;
mAnimatingReveal = true;
mHandler.removeMessages(MSG_ANIMATE);
mHandler.removeMessages(MSG_ANIMATE_REVEAL);
long now = SystemClock.uptimeMillis();
mAnimLastTime = now;
mCurAnimationTime = now + ANIM_FRAME_DURATION;
mAnimating = true;
mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE_REVEAL),
mCurAnimationTime);
} else {
// it's open, close it?
if (mAnimating) {
mAnimating = false;
mHandler.removeMessages(MSG_ANIMATE);
}
}
if (opening) {
makeExpandedVisible();
} else {
updateExpandedViewPos(y + mViewDelta);
}
}
void performFling(int y, float vel, boolean always) {
mAnimatingReveal = false;
mDisplayHeight = mDisplay.getHeight();
mAnimY = y;
mAnimVel = vel;
//Log.d(TAG, "starting with mAnimY=" + mAnimY + " mAnimVel=" + mAnimVel);
if (mExpanded) {
if (!always && (
vel > 200.0f
|| (y > (mDisplayHeight-25) && vel > -200.0f))) {
// We are expanded, but they didn't move sufficiently to cause
// us to retract. Animate back to the expanded position.
mAnimAccel = 2000.0f;
if (vel < 0) {
mAnimVel = 0;
}
}
else {
// We are expanded and are now going to animate away.
mAnimAccel = -2000.0f;
if (vel > 0) {
mAnimVel = 0;
}
}
} else {
if (always || (
vel > 200.0f
|| (y > (mDisplayHeight/2) && vel > -200.0f))) {
// We are collapsed, and they moved enough to allow us to
// expand. Animate in the notifications.
mAnimAccel = 2000.0f;
if (vel < 0) {
mAnimVel = 0;
}
}
else {
// We are collapsed, but they didn't move sufficiently to cause
// us to retract. Animate back to the collapsed position.
mAnimAccel = -2000.0f;
if (vel > 0) {
mAnimVel = 0;
}
}
}
//Log.d(TAG, "mAnimY=" + mAnimY + " mAnimVel=" + mAnimVel
// + " mAnimAccel=" + mAnimAccel);
long now = SystemClock.uptimeMillis();
mAnimLastTime = now;
mCurAnimationTime = now + ANIM_FRAME_DURATION;
mAnimating = true;
mHandler.removeMessages(MSG_ANIMATE);
mHandler.removeMessages(MSG_ANIMATE_REVEAL);
mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE), mCurAnimationTime);
stopTracking();
}
boolean interceptTouchEvent(MotionEvent event) {
if (SPEW) Log.d(TAG, "Touch: rawY=" + event.getRawY() + " event=" + event);
if ((mDisabled & StatusBarManager.DISABLE_EXPAND) != 0) {
return true;
}
final int statusBarSize = mStatusBarView.getHeight();
final int hitSize = statusBarSize*2;
if (event.getAction() == MotionEvent.ACTION_DOWN) {
int y = (int)event.getRawY();
if (!mExpanded) {
mViewDelta = statusBarSize - y;
} else {
mTrackingView.getLocationOnScreen(mAbsPos);
mViewDelta = mAbsPos[1] + mTrackingView.getHeight() - y;
}
if ((!mExpanded && y < hitSize) ||
(mExpanded && y > (mDisplay.getHeight()-hitSize))) {
prepareTracking(y);
mVelocityTracker.addMovement(event);
}
} else if (mTracking) {
mVelocityTracker.addMovement(event);
final int minY = statusBarSize + mCloseView.getHeight();
if (event.getAction() == MotionEvent.ACTION_MOVE) {
int y = (int)event.getRawY();
if (mAnimatingReveal && y < minY) {
// nothing
} else {
mAnimatingReveal = false;
updateExpandedViewPos(y + mViewDelta);
}
} else if (event.getAction() == MotionEvent.ACTION_UP) {
mVelocityTracker.computeCurrentVelocity(1000);
float yVel = mVelocityTracker.getYVelocity();
boolean negative = yVel < 0;
float xVel = mVelocityTracker.getXVelocity();
if (xVel < 0) {
xVel = -xVel;
}
if (xVel > 150.0f) {
xVel = 150.0f; // limit how much we care about the x axis
}
float vel = (float)Math.hypot(yVel, xVel);
if (negative) {
vel = -vel;
}
performFling((int)event.getRawY(), vel, false);
}
}
return false;
}
private class Launcher implements View.OnClickListener {
private PendingIntent mIntent;
private String mPkg;
private int mId;
Launcher(PendingIntent intent, String pkg, int id) {
mIntent = intent;
mPkg = pkg;
mId = id;
}
public void onClick(View v) {
try {
// The intent we are sending is for the application, which
// won't have permission to immediately start an activity after
// the user switches to home. We know it is safe to do at this
// point, so make sure new activity switches are now allowed.
ActivityManagerNative.getDefault().resumeAppSwitches();
} catch (RemoteException e) {
}
try {
mIntent.send();
mNotificationCallbacks.onNotificationClick(mPkg, mId);
} catch (PendingIntent.CanceledException e) {
// the stack trace isn't very helpful here. Just log the exception message.
Log.w(TAG, "Sending contentIntent failed: " + e);
}
deactivate();
}
}
private class MyTicker extends Ticker {
MyTicker(Context context, StatusBarView sb) {
super(context, sb);
}
@Override
void tickerStarting() {
mTicking = true;
mIcons.setVisibility(View.GONE);
mTickerView.setVisibility(View.VISIBLE);
mTickerView.startAnimation(loadAnim(com.android.internal.R.anim.push_up_in, null));
mIcons.startAnimation(loadAnim(com.android.internal.R.anim.push_up_out, null));
if (mExpandedVisible) {
setDateViewVisibility(false, com.android.internal.R.anim.push_up_out);
}
}
@Override
void tickerDone() {
mIcons.setVisibility(View.VISIBLE);
mTickerView.setVisibility(View.GONE);
mIcons.startAnimation(loadAnim(com.android.internal.R.anim.push_down_in, null));
mTickerView.startAnimation(loadAnim(com.android.internal.R.anim.push_down_out,
mTickingDoneListener));
if (mExpandedVisible) {
setDateViewVisibility(true, com.android.internal.R.anim.push_down_in);
}
}
void tickerHalting() {
mIcons.setVisibility(View.VISIBLE);
mTickerView.setVisibility(View.GONE);
mIcons.startAnimation(loadAnim(com.android.internal.R.anim.fade_in, null));
mTickerView.startAnimation(loadAnim(com.android.internal.R.anim.fade_out,
mTickingDoneListener));
if (mExpandedVisible) {
setDateViewVisibility(true, com.android.internal.R.anim.fade_in);
}
}
}
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 String viewInfo(View v) {
return "(" + v.getLeft() + "," + v.getTop() + ")(" + v.getRight() + "," + v.getBottom()
+ " " + v.getWidth() + "x" + v.getHeight() + ")";
}
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
!= PackageManager.PERMISSION_GRANTED) {
pw.println("Permission Denial: can't dump StatusBar from from pid="
+ Binder.getCallingPid()
+ ", uid=" + Binder.getCallingUid());
return;
}
synchronized (mQueue) {
pw.println("Current Status Bar state:");
pw.println(" mExpanded=" + mExpanded
+ ", mExpandedVisible=" + mExpandedVisible);
pw.println(" mTicking=" + mTicking);
pw.println(" mTracking=" + mTracking);
pw.println(" mAnimating=" + mAnimating
+ ", mAnimY=" + mAnimY + ", mAnimVel=" + mAnimVel
+ ", mAnimAccel=" + mAnimAccel);
pw.println(" mCurAnimationTime=" + mCurAnimationTime
+ " mAnimLastTime=" + mAnimLastTime);
pw.println(" mDisplayHeight=" + mDisplayHeight
+ " mAnimatingReveal=" + mAnimatingReveal
+ " mViewDelta=" + mViewDelta);
pw.println(" mDisplayHeight=" + mDisplayHeight);
final int N = mQueue.size();
pw.println(" mQueue.size=" + N);
for (int i=0; i list = null;
synchronized (StatusBarService.this) {
Uri data = intent.getData();
if (data != null) {
String pkg = data.getSchemeSpecificPart();
list = mNotificationData.notificationsForPackage(pkg);
}
}
if (list != null) {
final int N = list.size();
for (int i=0; i