auto import from //branches/cupcake/...@132276
diff --git a/services/java/com/android/server/BatteryService.java b/services/java/com/android/server/BatteryService.java
index e4fdd0c1..9c9a580 100644
--- a/services/java/com/android/server/BatteryService.java
+++ b/services/java/com/android/server/BatteryService.java
@@ -121,9 +121,10 @@
}
int plugTypeBit = 0;
if (mAcOnline) {
- plugTypeBit = BatteryManager.BATTERY_PLUGGED_AC;
- } else if (mUsbOnline) {
- plugTypeBit = BatteryManager.BATTERY_PLUGGED_USB;
+ plugTypeBit |= BatteryManager.BATTERY_PLUGGED_AC;
+ }
+ if (mUsbOnline) {
+ plugTypeBit |= BatteryManager.BATTERY_PLUGGED_USB;
}
return (plugTypeSet & plugTypeBit) != 0;
}
diff --git a/services/java/com/android/server/DeviceStorageMonitorService.java b/services/java/com/android/server/DeviceStorageMonitorService.java
index 44f70f0d..85861bb 100644
--- a/services/java/com/android/server/DeviceStorageMonitorService.java
+++ b/services/java/com/android/server/DeviceStorageMonitorService.java
@@ -67,6 +67,7 @@
private static final int EVENT_LOG_LOW_STORAGE_NOTIFICATION = 2745;
private static final int EVENT_LOG_FREE_STORAGE_LEFT = 2746;
private static final long DEFAULT_DISK_FREE_CHANGE_REPORTING_THRESHOLD = 2 * 1024 * 1024; // 2MB
+ private static final long DEFAULT_CHECK_INTERVAL = MONITOR_INTERVAL*60*1000;
private long mFreeMem;
private long mLastReportedFreeMem;
private long mLastReportedFreeMemTime;
@@ -82,6 +83,9 @@
boolean mClearingCache;
private Intent mStorageLowIntent;
private Intent mStorageOkIntent;
+ private CachePackageDataObserver mClearCacheObserver;
+ private static final int _TRUE = 1;
+ private static final int _FALSE = 0;
/**
* This string is used for ServiceManager access to this class.
@@ -100,7 +104,7 @@
Log.e(TAG, "Will not process invalid message");
return;
}
- checkMemory();
+ checkMemory(msg.arg1 == _TRUE);
}
};
@@ -109,7 +113,8 @@
mClearSucceeded = succeeded;
mClearingCache = false;
if(localLOGV) Log.i(TAG, " Clear succeeded:"+mClearSucceeded
- +", mClearingCache:"+mClearingCache);
+ +", mClearingCache:"+mClearingCache+" Forcing memory check");
+ postCheckMemoryMsg(false, 0);
}
}
@@ -145,11 +150,15 @@
}
private final void clearCache() {
- CachePackageDataObserver observer = new CachePackageDataObserver();
+ if (mClearCacheObserver == null) {
+ // Lazy instantiation
+ mClearCacheObserver = new CachePackageDataObserver();
+ }
mClearingCache = true;
try {
+ if (localLOGV) Log.i(TAG, "Clearing cache");
IPackageManager.Stub.asInterface(ServiceManager.getService("package")).
- freeStorageAndNotify(getMemThreshold(), observer);
+ freeStorageAndNotify(getMemThreshold(), mClearCacheObserver);
} catch (RemoteException e) {
Log.w(TAG, "Failed to get handle for PackageManger Exception: "+e);
mClearingCache = false;
@@ -157,7 +166,7 @@
}
}
- private final void checkMemory() {
+ private final void checkMemory(boolean checkCache) {
//if the thread that was started to clear cache is still running do nothing till its
//finished clearing cache. Ideally this flag could be modified by clearCache
// and should be accessed via a lock but even if it does this test will fail now and
@@ -172,16 +181,23 @@
} else {
restatDataDir();
if (localLOGV) Log.v(TAG, "freeMemory="+mFreeMem);
+
//post intent to NotificationManager to display icon if necessary
long memThreshold = getMemThreshold();
if (mFreeMem < memThreshold) {
if (!mLowMemFlag) {
- //see if clearing cache helps
- mThreadStartTime = System.currentTimeMillis();
- clearCache();
- Log.i(TAG, "Running low on memory. Sending notification");
- sendNotification();
- mLowMemFlag = true;
+ if (checkCache) {
+ // See if clearing cache helps
+ // Note that clearing cache is asynchronous and so we do a
+ // memory check again once the cache has been cleared.
+ mThreadStartTime = System.currentTimeMillis();
+ mClearSucceeded = false;
+ clearCache();
+ } else {
+ Log.i(TAG, "Running low on memory. Sending notification");
+ sendNotification();
+ mLowMemFlag = true;
+ }
} else {
if (localLOGV) Log.v(TAG, "Running low on memory " +
"notification already sent. do nothing");
@@ -196,8 +212,15 @@
}
if(localLOGV) Log.i(TAG, "Posting Message again");
//keep posting messages to itself periodically
- mHandler.sendMessageDelayed(mHandler.obtainMessage(DEVICE_MEMORY_WHAT),
- MONITOR_INTERVAL*60*1000);
+ postCheckMemoryMsg(true, DEFAULT_CHECK_INTERVAL);
+ }
+
+ private void postCheckMemoryMsg(boolean clearCache, long delay) {
+ // Remove queued messages
+ mHandler.removeMessages(DEVICE_MEMORY_WHAT);
+ mHandler.sendMessageDelayed(mHandler.obtainMessage(DEVICE_MEMORY_WHAT,
+ clearCache ?_TRUE : _FALSE, 0),
+ delay);
}
/*
@@ -231,7 +254,7 @@
mTotalMemory = (mFileStats.getBlockCount()*mBlkSize)/100;
mStorageLowIntent = new Intent(Intent.ACTION_DEVICE_STORAGE_LOW);
mStorageOkIntent = new Intent(Intent.ACTION_DEVICE_STORAGE_OK);
- checkMemory();
+ checkMemory(true);
}
@@ -281,14 +304,11 @@
}
public void updateMemory() {
- ActivityManagerService ams = (ActivityManagerService)ServiceManager.getService("activity");
int callingUid = getCallingUid();
if(callingUid != Process.SYSTEM_UID) {
return;
}
- //remove queued messages
- mHandler.removeMessages(DEVICE_MEMORY_WHAT);
- //force an early check
- checkMemory();
+ // force an early check
+ postCheckMemoryMsg(true, 0);
}
}
diff --git a/services/java/com/android/server/GadgetService.java b/services/java/com/android/server/GadgetService.java
index ddf3afe..4a430e0 100644
--- a/services/java/com/android/server/GadgetService.java
+++ b/services/java/com/android/server/GadgetService.java
@@ -38,7 +38,6 @@
import android.os.RemoteException;
import android.os.SystemClock;
import android.util.AttributeSet;
-import android.util.Config;
import android.util.Log;
import android.util.Xml;
import android.widget.RemoteViews;
@@ -66,7 +65,6 @@
class GadgetService extends IGadgetService.Stub
{
private static final String TAG = "GadgetService";
- private static final boolean LOGD = Config.LOGD || false;
private static final String SETTINGS_FILENAME = "gadgets.xml";
private static final String SETTINGS_TMP_FILENAME = SETTINGS_FILENAME + ".tmp";
@@ -82,6 +80,7 @@
GadgetProviderInfo info;
ArrayList<GadgetId> instances = new ArrayList();
PendingIntent broadcast;
+ boolean zombie; // if we're in safe mode, don't prune this just because nobody references it
int tag; // for use while saving state (the index)
}
@@ -92,6 +91,7 @@
String packageName;
ArrayList<GadgetId> instances = new ArrayList();
IGadgetHost callbacks;
+ boolean zombie; // if we're in safe mode, don't prune this just because nobody references it
int tag; // for use while saving state (the index)
}
@@ -110,13 +110,18 @@
int mNextGadgetId = GadgetManager.INVALID_GADGET_ID + 1;
ArrayList<GadgetId> mGadgetIds = new ArrayList();
ArrayList<Host> mHosts = new ArrayList();
+ boolean mSafeMode;
GadgetService(Context context) {
mContext = context;
mPackageManager = context.getPackageManager();
mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);
-
- getGadgetList();
+ }
+
+ public void systemReady(boolean safeMode) {
+ mSafeMode = safeMode;
+
+ loadGadgetList();
loadStateLocked();
// Register for the boot completed broadcast, so we can send the
@@ -148,11 +153,12 @@
int N = mInstalledProviders.size();
pw.println("Providers: (size=" + N + ")");
for (int i=0; i<N; i++) {
- GadgetProviderInfo info = mInstalledProviders.get(i).info;
+ Provider p = mInstalledProviders.get(i);
+ GadgetProviderInfo info = p.info;
pw.println(" [" + i + "] provder=" + info.provider
+ " min=(" + info.minWidth + "x" + info.minHeight + ")"
+ " updatePeriodMillis=" + info.updatePeriodMillis
- + " initialLayout=" + info.initialLayout);
+ + " initialLayout=" + info.initialLayout + " zombie=" + p.zombie);
}
N = mGadgetIds.size();
@@ -172,7 +178,7 @@
Host host = mHosts.get(i);
pw.println(" [" + i + "] packageName=" + host.packageName + " uid=" + host.uid
+ " hostId=" + host.hostId + " callbacks=" + host.callbacks
- + " instances.size=" + host.instances.size());
+ + " instances.size=" + host.instances.size() + " zombie=" + host.zombie);
}
}
}
@@ -199,16 +205,10 @@
public void deleteGadgetId(int gadgetId) {
synchronized (mGadgetIds) {
- int callingUid = getCallingUid();
- final int N = mGadgetIds.size();
- for (int i=0; i<N; i++) {
- GadgetId id = mGadgetIds.get(i);
- if (id.provider != null && canAccessGadgetId(id, callingUid)) {
- deleteGadgetLocked(id);
-
- saveStateLocked();
- return;
- }
+ GadgetId id = lookupGadgetIdLocked(gadgetId);
+ if (id != null) {
+ deleteGadgetLocked(id);
+ saveStateLocked();
}
}
}
@@ -264,19 +264,21 @@
Provider p = id.provider;
if (p != null) {
p.instances.remove(id);
- // send the broacast saying that this gadgetId has been deleted
- Intent intent = new Intent(GadgetManager.ACTION_GADGET_DELETED);
- intent.setComponent(p.info.provider);
- intent.putExtra(GadgetManager.EXTRA_GADGET_ID, id.gadgetId);
- mContext.sendBroadcast(intent);
- if (p.instances.size() == 0) {
- // cancel the future updates
- cancelBroadcasts(p);
-
- // send the broacast saying that the provider is not in use any more
- intent = new Intent(GadgetManager.ACTION_GADGET_DISABLED);
+ if (!p.zombie) {
+ // send the broacast saying that this gadgetId has been deleted
+ Intent intent = new Intent(GadgetManager.ACTION_GADGET_DELETED);
intent.setComponent(p.info.provider);
+ intent.putExtra(GadgetManager.EXTRA_GADGET_ID, id.gadgetId);
mContext.sendBroadcast(intent);
+ if (p.instances.size() == 0) {
+ // cancel the future updates
+ cancelBroadcasts(p);
+
+ // send the broacast saying that the provider is not in use any more
+ intent = new Intent(GadgetManager.ACTION_GADGET_DISABLED);
+ intent.setComponent(p.info.provider);
+ mContext.sendBroadcast(intent);
+ }
}
}
}
@@ -310,6 +312,10 @@
if (p == null) {
throw new IllegalArgumentException("not a gadget provider: " + provider);
}
+ if (p.zombie) {
+ throw new IllegalArgumentException("can't bind to a 3rd party provider in"
+ + " safe mode: " + provider);
+ }
id.provider = p;
p.instances.add(id);
@@ -334,7 +340,7 @@
public GadgetProviderInfo getGadgetInfo(int gadgetId) {
synchronized (mGadgetIds) {
GadgetId id = lookupGadgetIdLocked(gadgetId);
- if (id != null) {
+ if (id != null && id.provider != null && !id.provider.zombie) {
return id.provider.info;
}
return null;
@@ -356,7 +362,10 @@
final int N = mInstalledProviders.size();
ArrayList<GadgetProviderInfo> result = new ArrayList(N);
for (int i=0; i<N; i++) {
- result.add(mInstalledProviders.get(i).info);
+ Provider p = mInstalledProviders.get(i);
+ if (!p.zombie) {
+ result.add(p.info);
+ }
}
return result;
}
@@ -399,7 +408,7 @@
// allow for stale gadgetIds and other badness
// lookup also checks that the calling process can access the gadget id
// drop unbound gadget ids (shouldn't be possible under normal circumstances)
- if (id != null && id.provider != null) {
+ if (id != null && id.provider != null && !id.provider.zombie && !id.host.zombie) {
id.views = views;
// is anyone listening?
@@ -460,9 +469,7 @@
return true;
}
// Nobody else can access it.
- // TODO: convert callingPackage over to use UID-based checking instead
- // TODO: our temp solution is to short-circuit this security check
- return true;
+ return false;
}
GadgetId lookupGadgetIdLocked(int gadgetId) {
@@ -521,7 +528,7 @@
}
}
- void getGadgetList() {
+ void loadGadgetList() {
PackageManager pm = mPackageManager;
Intent intent = new Intent(GadgetManager.ACTION_GADGET_UPDATE);
@@ -854,8 +861,16 @@
String pkg = parser.getAttributeValue(null, "pkg");
String cl = parser.getAttributeValue(null, "cl");
Provider p = lookupProviderLocked(new ComponentName(pkg, cl));
- // if it wasn't uninstalled or something
+ if (p == null && mSafeMode) {
+ // if we're in safe mode, make a temporary one
+ p = new Provider();
+ p.info = new GadgetProviderInfo();
+ p.info.provider = new ComponentName(pkg, cl);
+ p.zombie = true;
+ mInstalledProviders.add(p);
+ }
if (p != null) {
+ // if it wasn't uninstalled or something
loadedProviders.put(providerIndex, p);
}
providerIndex++;
@@ -868,13 +883,15 @@
host.packageName = parser.getAttributeValue(null, "pkg");
try {
host.uid = getUidForPackage(host.packageName);
+ } catch (PackageManager.NameNotFoundException ex) {
+ host.zombie = true;
+ }
+ if (!host.zombie || mSafeMode) {
+ // In safe mode, we don't discard the hosts we don't recognize
+ // so that they're not pruned from our list. Otherwise, we do.
host.hostId = Integer.parseInt(
parser.getAttributeValue(null, "id"), 16);
mHosts.add(host);
- } catch (PackageManager.NameNotFoundException ex) {
- // Just ignore drop this entry, as if it has been uninstalled.
- // We need to deal with this case because of safe mode, but there's
- // a bug filed about it.
}
}
else if ("g".equals(tag)) {
diff --git a/services/java/com/android/server/InputMethodManagerService.java b/services/java/com/android/server/InputMethodManagerService.java
index 7588129..4b45828 100644
--- a/services/java/com/android/server/InputMethodManagerService.java
+++ b/services/java/com/android/server/InputMethodManagerService.java
@@ -1062,6 +1062,13 @@
// Do nothing.
break;
case WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN:
+ if ((softInputMode &
+ WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) {
+ if (DEBUG) Log.v(TAG, "Window asks to hide input going forward");
+ hideCurrentInputLocked(0);
+ }
+ break;
+ case WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN:
if (DEBUG) Log.v(TAG, "Window asks to hide input");
hideCurrentInputLocked(0);
break;
diff --git a/services/java/com/android/server/LocationManagerService.java b/services/java/com/android/server/LocationManagerService.java
index db4daa5..bc8da93 100644
--- a/services/java/com/android/server/LocationManagerService.java
+++ b/services/java/com/android/server/LocationManagerService.java
@@ -18,14 +18,16 @@
import java.io.BufferedReader;
import java.io.File;
+import java.io.FileDescriptor;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
+import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
-import java.util.Locale;
+import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
@@ -46,6 +48,7 @@
import android.location.LocationProvider;
import android.location.LocationProviderImpl;
import android.net.ConnectivityManager;
+import android.net.Uri;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;
import android.os.Binder;
@@ -57,12 +60,13 @@
import android.os.RemoteException;
import android.os.SystemClock;
import android.provider.Settings;
-import android.provider.Settings.SettingNotFoundException;
import android.telephony.CellLocation;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.util.Config;
import android.util.Log;
+import android.util.PrintWriterPrinter;
+import android.util.SparseIntArray;
import com.android.internal.app.IBatteryStats;
import com.android.internal.location.CellState;
@@ -124,6 +128,7 @@
private final Context mContext;
private GpsLocationProvider mGpsLocationProvider;
+ private boolean mGpsNavigating;
private LocationProviderImpl mNetworkLocationProvider;
private INetworkLocationProvider mNetworkLocationInterface;
private LocationWorkerHandler mLocationHandler;
@@ -151,35 +156,38 @@
private final IBatteryStats mBatteryStats;
- // The calling UID when we are in a clearCallingIdentity/restoreCallingIdentity block, or -1
- private int mCallingUid = -1;
-
/**
* Mapping from listener IBinder/PendingIntent to local Listener wrappers.
*/
- private final HashMap<Object,Receiver> mListeners =
- new HashMap<Object,Receiver>();
+ private final ArrayList<Receiver> mListeners = new ArrayList<Receiver>();
/**
- * Mapping from listener IBinder/PendingIntent to a map from provider name to UpdateRecord.
+ * Used for reporting which UIDs are causing the GPS to run.
*/
- private final HashMap<Object,HashMap<String,UpdateRecord>> mLocationListeners =
- new HashMap<Object,HashMap<String,UpdateRecord>>();
+ private final SparseIntArray mReportedGpsUids = new SparseIntArray();
+ private int mReportedGpsSeq = 0;
+
+ /**
+ * Mapping from listener IBinder/PendingIntent to a map from provider name to UpdateRecord.
+ * This also serves as the lock for our state.
+ */
+ private final HashMap<Receiver,HashMap<String,UpdateRecord>> mLocationListeners =
+ new HashMap<Receiver,HashMap<String,UpdateRecord>>();
/**
* Mapping from listener IBinder/PendingIntent to a map from provider name to last broadcast
* location.
*/
- private final HashMap<Object,HashMap<String,Location>> mLastFixBroadcast =
- new HashMap<Object,HashMap<String,Location>>();
- private final HashMap<Object,HashMap<String,Long>> mLastStatusBroadcast =
- new HashMap<Object,HashMap<String,Long>>();
+ private final HashMap<Receiver,HashMap<String,Location>> mLastFixBroadcast =
+ new HashMap<Receiver,HashMap<String,Location>>();
+ private final HashMap<Receiver,HashMap<String,Long>> mLastStatusBroadcast =
+ new HashMap<Receiver,HashMap<String,Long>>();
/**
* Mapping from provider name to all its UpdateRecords
*/
- private final HashMap<String,HashSet<UpdateRecord>> mRecordsByProvider =
- new HashMap<String,HashSet<UpdateRecord>>();
+ private final HashMap<String,ArrayList<UpdateRecord>> mRecordsByProvider =
+ new HashMap<String,ArrayList<UpdateRecord>>();
/**
* Mappings from provider name to object to use for current location. Locations
@@ -221,22 +229,48 @@
private final class Receiver implements IBinder.DeathRecipient {
final ILocationListener mListener;
final PendingIntent mPendingIntent;
+ final int mUid;
+ final Object mKey;
- Receiver(ILocationListener listener) {
+ Receiver(ILocationListener listener, int uid) {
mListener = listener;
mPendingIntent = null;
+ mUid = uid;
+ mKey = listener.asBinder();
}
- Receiver(PendingIntent intent) {
+ Receiver(PendingIntent intent, int uid) {
mPendingIntent = intent;
mListener = null;
+ mUid = uid;
+ mKey = intent;
}
- public Object getKey() {
+ @Override
+ public boolean equals(Object otherObj) {
+ if (otherObj instanceof Receiver) {
+ return mKey.equals(
+ ((Receiver)otherObj).mKey);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return mKey.hashCode();
+ }
+
+
+ @Override
+ public String toString() {
if (mListener != null) {
- return mListener.asBinder();
+ return "Receiver{"
+ + Integer.toHexString(System.identityHashCode(this))
+ + " uid " + mUid + " Listener " + mKey + "}";
} else {
- return mPendingIntent;
+ return "Receiver{"
+ + Integer.toHexString(System.identityHashCode(this))
+ + " uid " + mUid + " Intent " + mKey + "}";
}
}
@@ -262,10 +296,13 @@
throw new IllegalStateException("Request for non-existent intent");
}
- public void onStatusChanged(String provider, int status, Bundle extras)
- throws RemoteException {
+ public boolean callStatusChangedLocked(String provider, int status, Bundle extras) {
if (mListener != null) {
- mListener.onStatusChanged(provider, status, extras);
+ try {
+ mListener.onStatusChanged(provider, status, extras);
+ } catch (RemoteException e) {
+ return false;
+ }
} else {
Intent statusChanged = new Intent();
statusChanged.putExtras(extras);
@@ -273,23 +310,29 @@
try {
mPendingIntent.send(mContext, 0, statusChanged, null, null);
} catch (PendingIntent.CanceledException e) {
- _removeUpdates(this);
+ return false;
}
}
+ return true;
}
- public void onLocationChanged(Location location) throws RemoteException {
+ public boolean callLocationChangedLocked(Location location) {
if (mListener != null) {
- mListener.onLocationChanged(location);
+ try {
+ mListener.onLocationChanged(location);
+ } catch (RemoteException e) {
+ return false;
+ }
} else {
Intent locationChanged = new Intent();
locationChanged.putExtra(LocationManager.KEY_LOCATION_CHANGED, location);
try {
mPendingIntent.send(mContext, 0, locationChanged, null, null);
} catch (PendingIntent.CanceledException e) {
- _removeUpdates(this);
+ return false;
}
}
+ return true;
}
public void binderDied() {
@@ -297,12 +340,12 @@
Log.d(TAG, "Location listener died");
}
synchronized (mLocationListeners) {
- _removeUpdates(this);
+ removeUpdatesLocked(this);
}
}
}
- private Location readLastKnownLocation(String provider) {
+ private Location readLastKnownLocationLocked(String provider) {
Location location = null;
String s = null;
try {
@@ -345,7 +388,7 @@
return location;
}
- private void writeLastKnownLocation(String provider,
+ private void writeLastKnownLocationLocked(String provider,
Location location) {
long now = SystemClock.elapsedRealtime();
Long last = mLastWriteTime.get(provider);
@@ -403,26 +446,26 @@
* properties
*/
private void loadProviders() {
- synchronized (LocationManagerService.class) {
+ synchronized (mLocationListeners) {
if (sProvidersLoaded) {
return;
}
// Load providers
- loadProvidersNoSync();
+ loadProvidersLocked();
sProvidersLoaded = true;
}
}
- private void loadProvidersNoSync() {
+ private void loadProvidersLocked() {
try {
- _loadProvidersNoSync();
+ _loadProvidersLocked();
} catch (Exception e) {
Log.e(TAG, "Exception loading providers:", e);
}
}
- private void _loadProvidersNoSync() {
+ private void _loadProvidersLocked() {
// Attempt to load "real" providers first
if (GpsLocationProvider.isSupported()) {
// Create a gps location provider
@@ -495,7 +538,7 @@
}
}
- updateProviders();
+ updateProvidersLocked();
}
/**
@@ -546,13 +589,15 @@
intentFilter.addAction(Intent.ACTION_SCREEN_OFF);
intentFilter.addAction(Intent.ACTION_SCREEN_ON);
intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
+ intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
+ intentFilter.addAction(Intent.ACTION_PACKAGE_RESTARTED);
context.registerReceiver(powerStateReceiver, intentFilter);
// Get the wifi manager
mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
// Create a wifi lock for future use
- mWifiLock = getWifiWakelock();
+ mWifiLock = getWifiWakelockLocked();
// There might be an existing wifi scan available
if (mWifiManager != null) {
@@ -566,28 +611,34 @@
}
public void setInstallCallback(InstallCallback callback) {
- mLocationHandler.removeMessages(MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER);
- Message m = Message.obtain(mLocationHandler,
- MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER, callback);
- mLocationHandler.sendMessageAtFrontOfQueue(m);
- }
-
- public void setNetworkLocationProvider(INetworkLocationProvider provider) {
- mNetworkLocationInterface = provider;
- provider.addListener(getPackageNames());
- mNetworkLocationProvider = (LocationProviderImpl)provider;
- LocationProviderImpl.addProvider(mNetworkLocationProvider);
- updateProviders();
- }
-
- public void setLocationCollector(ILocationCollector collector) {
- mCollector = collector;
- if (mGpsLocationProvider != null) {
- mGpsLocationProvider.setLocationCollector(mCollector);
+ synchronized (mLocationListeners) {
+ mLocationHandler.removeMessages(MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER);
+ Message m = Message.obtain(mLocationHandler,
+ MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER, callback);
+ mLocationHandler.sendMessageAtFrontOfQueue(m);
}
}
- private WifiManager.WifiLock getWifiWakelock() {
+ public void setNetworkLocationProvider(INetworkLocationProvider provider) {
+ synchronized (mLocationListeners) {
+ mNetworkLocationInterface = provider;
+ provider.addListener(getPackageNames());
+ mNetworkLocationProvider = (LocationProviderImpl)provider;
+ LocationProviderImpl.addProvider(mNetworkLocationProvider);
+ updateProvidersLocked();
+ }
+ }
+
+ public void setLocationCollector(ILocationCollector collector) {
+ synchronized (mLocationListeners) {
+ mCollector = collector;
+ if (mGpsLocationProvider != null) {
+ mGpsLocationProvider.setLocationCollector(mCollector);
+ }
+ }
+ }
+
+ private WifiManager.WifiLock getWifiWakelockLocked() {
if (mWifiLock == null && mWifiManager != null) {
mWifiLock = mWifiManager.createWifiLock(WifiManager.WIFI_MODE_SCAN_ONLY, WIFILOCK_KEY);
mWifiLock.setReferenceCounted(false);
@@ -595,7 +646,7 @@
return mWifiLock;
}
- private boolean isAllowedBySettings(String provider) {
+ private boolean isAllowedBySettingsLocked(String provider) {
if (mEnabledProviders.contains(provider)) {
return true;
}
@@ -610,7 +661,7 @@
return ((allowedProviders != null) && (allowedProviders.contains(provider)));
}
- private void checkPermissions(String provider) {
+ private void checkPermissionsSafe(String provider) {
if (LocationManager.GPS_PROVIDER.equals(provider)
&& (mContext.checkCallingPermission(ACCESS_FINE_LOCATION)
!= PackageManager.PERMISSION_GRANTED)) {
@@ -626,7 +677,7 @@
}
}
- private boolean isAllowedProvider(String provider) {
+ private boolean isAllowedProviderSafe(String provider) {
if (LocationManager.GPS_PROVIDER.equals(provider)
&& (mContext.checkCallingPermission(ACCESS_FINE_LOCATION)
!= PackageManager.PERMISSION_GRANTED)) {
@@ -651,7 +702,9 @@
public List<String> getAllProviders() {
try {
- return _getAllProviders();
+ synchronized (mLocationListeners) {
+ return _getAllProvidersLocked();
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -660,7 +713,7 @@
}
}
- private List<String> _getAllProviders() {
+ private List<String> _getAllProvidersLocked() {
if (Config.LOGD) {
Log.d(TAG, "getAllProviders");
}
@@ -675,7 +728,9 @@
public List<String> getProviders(boolean enabledOnly) {
try {
- return _getProviders(enabledOnly);
+ synchronized (mLocationListeners) {
+ return _getProvidersLocked(enabledOnly);
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -684,7 +739,7 @@
}
}
- private List<String> _getProviders(boolean enabledOnly) {
+ private List<String> _getProvidersLocked(boolean enabledOnly) {
if (Config.LOGD) {
Log.d(TAG, "getProviders");
}
@@ -693,8 +748,8 @@
for (LocationProviderImpl p : providers) {
String name = p.getName();
- if (isAllowedProvider(name)) {
- if (enabledOnly && !isAllowedBySettings(name)) {
+ if (isAllowedProviderSafe(name)) {
+ if (enabledOnly && !isAllowedBySettingsLocked(name)) {
continue;
}
out.add(name);
@@ -704,10 +759,16 @@
}
public void updateProviders() {
+ synchronized (mLocationListeners) {
+ updateProvidersLocked();
+ }
+ }
+
+ private void updateProvidersLocked() {
for (LocationProviderImpl p : LocationProviderImpl.getProviders()) {
boolean isEnabled = p.isEnabled();
String name = p.getName();
- boolean shouldBeEnabled = isAllowedBySettings(name);
+ boolean shouldBeEnabled = isAllowedBySettingsLocked(name);
// Collection is only allowed when network provider is being used
if (mCollector != null &&
@@ -716,15 +777,15 @@
}
if (isEnabled && !shouldBeEnabled) {
- updateProviderListeners(name, false);
+ updateProviderListenersLocked(name, false);
} else if (!isEnabled && shouldBeEnabled) {
- updateProviderListeners(name, true);
+ updateProviderListenersLocked(name, true);
}
}
}
- private void updateProviderListeners(String provider, boolean enabled) {
+ private void updateProviderListenersLocked(String provider, boolean enabled) {
int listeners = 0;
LocationProviderImpl p = LocationProviderImpl.getProvider(provider);
@@ -732,49 +793,63 @@
return;
}
- synchronized (mRecordsByProvider) {
- HashSet<UpdateRecord> records = mRecordsByProvider.get(provider);
- if (records != null) {
- for (UpdateRecord record : records) {
- // Sends a notification message to the receiver
- try {
- Receiver receiver = record.mReceiver;
- if (receiver.isListener()) {
- if (enabled) {
- receiver.getListener().onProviderEnabled(provider);
- } else {
- receiver.getListener().onProviderDisabled(provider);
- }
+ ArrayList<Receiver> deadReceivers = null;
+
+ ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);
+ if (records != null) {
+ final int N = records.size();
+ for (int i=0; i<N; i++) {
+ UpdateRecord record = records.get(i);
+ // Sends a notification message to the receiver
+ try {
+ Receiver receiver = record.mReceiver;
+ if (receiver.isListener()) {
+ if (enabled) {
+ receiver.getListener().onProviderEnabled(provider);
} else {
- PendingIntent intent = receiver.getPendingIntent();
- Intent providerIntent = new Intent();
- providerIntent.putExtra(LocationManager.KEY_PROVIDER_ENABLED, enabled);
- try {
- receiver.getPendingIntent().send(mContext, 0,
- providerIntent, null, null);
- } catch (PendingIntent.CanceledException e) {
- _removeUpdates(receiver);
+ receiver.getListener().onProviderDisabled(provider);
+ }
+ } else {
+ Intent providerIntent = new Intent();
+ providerIntent.putExtra(LocationManager.KEY_PROVIDER_ENABLED, enabled);
+ try {
+ receiver.getPendingIntent().send(mContext, 0,
+ providerIntent, null, null);
+ } catch (PendingIntent.CanceledException e) {
+ if (deadReceivers == null) {
+ deadReceivers = new ArrayList<Receiver>();
+ deadReceivers.add(receiver);
}
}
- } catch (RemoteException e) {
- // The death link will clean this up.
}
- listeners++;
+ } catch (RemoteException e) {
+ // The death link will clean this up.
}
+ listeners++;
}
}
+ if (deadReceivers != null) {
+ for (int i=deadReceivers.size()-1; i>=0; i--) {
+ removeUpdatesLocked(deadReceivers.get(i));
+ }
+ }
+
if (enabled) {
p.enable();
if (listeners > 0) {
- p.setMinTime(getMinTime(provider));
+ p.setMinTime(getMinTimeLocked(provider));
p.enableLocationTracking(true);
- updateWakelockStatus(mScreenOn);
+ updateWakelockStatusLocked(mScreenOn);
}
} else {
p.enableLocationTracking(false);
+ if (p == mGpsLocationProvider) {
+ mGpsNavigating = false;
+ reportStopGpsLocked();
+ }
p.disable();
- updateWakelockStatus(mScreenOn);
+ updateWakelockStatusLocked(mScreenOn);
}
if (enabled && listeners > 0) {
@@ -786,40 +861,43 @@
}
}
- private long getMinTime(String provider) {
+ private long getMinTimeLocked(String provider) {
long minTime = Long.MAX_VALUE;
- synchronized (mRecordsByProvider) {
- HashSet<UpdateRecord> records = mRecordsByProvider.get(provider);
- if (records != null) {
- for (UpdateRecord r : records) {
- minTime = Math.min(minTime, r.mMinTime);
- }
+ ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);
+ if (records != null) {
+ for (int i=records.size()-1; i>=0; i--) {
+ minTime = Math.min(minTime, records.get(i).mMinTime);
}
}
return minTime;
}
private class UpdateRecord {
- String mProvider;
- Receiver mReceiver;
- long mMinTime;
- float mMinDistance;
- String[] mPackages;
+ final String mProvider;
+ final Receiver mReceiver;
+ final long mMinTime;
+ final float mMinDistance;
+ final int mUid;
+ final String[] mPackages;
+ /**
+ * Note: must be constructed with lock held.
+ */
UpdateRecord(String provider, long minTime, float minDistance,
- Receiver receiver, String[] packages) {
+ Receiver receiver, int uid, String[] packages) {
mProvider = provider;
mReceiver = receiver;
mMinTime = minTime;
mMinDistance = minDistance;
+ mUid = uid;
mPackages = packages;
- synchronized (mRecordsByProvider) {
- HashSet<UpdateRecord> records = mRecordsByProvider.get(provider);
- if (records == null) {
- records = new HashSet<UpdateRecord>();
- mRecordsByProvider.put(provider, records);
- }
+ ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);
+ if (records == null) {
+ records = new ArrayList<UpdateRecord>();
+ mRecordsByProvider.put(provider, records);
+ }
+ if (!records.contains(this)) {
records.add(this);
}
}
@@ -828,18 +906,39 @@
* Method to be called when a record will no longer be used. Calling this multiple times
* must have the same effect as calling it once.
*/
- public void dispose() {
- synchronized (mRecordsByProvider) {
- HashSet<UpdateRecord> records = mRecordsByProvider.get(this.mProvider);
- records.remove(this);
- }
+ void disposeLocked() {
+ ArrayList<UpdateRecord> records = mRecordsByProvider.get(this.mProvider);
+ records.remove(this);
}
+ @Override
+ public String toString() {
+ return "UpdateRecord{"
+ + Integer.toHexString(System.identityHashCode(this))
+ + " " + mProvider + " " + mReceiver + "}";
+ }
+
+ void dump(PrintWriter pw, String prefix) {
+ pw.println(prefix + this);
+ pw.println(prefix + "mProvider=" + mProvider + " mReceiver=" + mReceiver);
+ pw.println(prefix + "mMinTime=" + mMinTime + " mMinDistance=" + mMinDistance);
+ StringBuilder sb = new StringBuilder();
+ if (mPackages != null) {
+ for (int i=0; i<mPackages.length; i++) {
+ if (i > 0) sb.append(", ");
+ sb.append(mPackages[i]);
+ }
+ }
+ pw.println(prefix + "mUid=" + mUid + " mPackages=" + sb);
+ }
+
/**
* Calls dispose().
*/
@Override protected void finalize() {
- dispose();
+ synchronized (mLocationListeners) {
+ disposeLocked();
+ }
}
}
@@ -847,8 +946,10 @@
long minTime, float minDistance, ILocationListener listener) {
try {
- _requestLocationUpdates(provider, minTime, minDistance,
- new Receiver(listener));
+ synchronized (mLocationListeners) {
+ requestLocationUpdatesLocked(provider, minTime, minDistance,
+ new Receiver(listener, Binder.getCallingUid()));
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -859,8 +960,10 @@
public void requestLocationUpdatesPI(String provider,
long minTime, float minDistance, PendingIntent intent) {
try {
- _requestLocationUpdates(provider, minTime, minDistance,
- new Receiver(intent));
+ synchronized (mLocationListeners) {
+ requestLocationUpdatesLocked(provider, minTime, minDistance,
+ new Receiver(intent, Binder.getCallingUid()));
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -868,11 +971,10 @@
}
}
- private synchronized void _requestLocationUpdates(String provider,
+ private void requestLocationUpdatesLocked(String provider,
long minTime, float minDistance, Receiver receiver) {
- Object key = receiver.getKey();
if (Config.LOGD) {
- Log.d(TAG, "_requestLocationUpdates: listener = " + key);
+ Log.d(TAG, "_requestLocationUpdates: listener = " + receiver);
}
LocationProviderImpl impl = LocationProviderImpl.getProvider(provider);
@@ -880,77 +982,75 @@
throw new IllegalArgumentException("provider=" + provider);
}
- checkPermissions(provider);
+ checkPermissionsSafe(provider);
String[] packages = getPackageNames();
// so wakelock calls will succeed
- mCallingUid = getCallingUid();
+ final int callingUid = Binder.getCallingUid();
long identity = Binder.clearCallingIdentity();
try {
- UpdateRecord r = new UpdateRecord(provider, minTime, minDistance, receiver, packages);
- synchronized (mLocationListeners) {
- if (mListeners.get(key) == null) {
- try {
- if (receiver.isListener()) {
- receiver.getListener().asBinder().linkToDeath(receiver, 0);
- }
- mListeners.put(key, receiver);
- } catch (RemoteException e) {
- return;
+ UpdateRecord r = new UpdateRecord(provider, minTime, minDistance,
+ receiver, callingUid, packages);
+ if (!mListeners.contains(receiver)) {
+ try {
+ if (receiver.isListener()) {
+ receiver.getListener().asBinder().linkToDeath(receiver, 0);
+ }
+ mListeners.add(receiver);
+ } catch (RemoteException e) {
+ return;
+ }
+ }
+
+ HashMap<String,UpdateRecord> records = mLocationListeners.get(receiver);
+ if (records == null) {
+ records = new HashMap<String,UpdateRecord>();
+ mLocationListeners.put(receiver, records);
+ }
+ UpdateRecord oldRecord = records.put(provider, r);
+ if (oldRecord != null) {
+ oldRecord.disposeLocked();
+ }
+
+ boolean isProviderEnabled = isAllowedBySettingsLocked(provider);
+ if (isProviderEnabled) {
+ long minTimeForProvider = getMinTimeLocked(provider);
+ impl.setMinTime(minTimeForProvider);
+ impl.enableLocationTracking(true);
+ updateWakelockStatusLocked(mScreenOn);
+
+ if (provider.equals(LocationManager.GPS_PROVIDER)) {
+ if (mGpsNavigating) {
+ updateReportedGpsLocked();
}
}
-
- HashMap<String,UpdateRecord> records = mLocationListeners.get(key);
- if (records == null) {
- records = new HashMap<String,UpdateRecord>();
- mLocationListeners.put(key, records);
- }
- UpdateRecord oldRecord = records.put(provider, r);
- if (oldRecord != null) {
- oldRecord.dispose();
- }
-
- boolean isProviderEnabled = isAllowedBySettings(provider);
- if (isProviderEnabled) {
- if (provider.equals(LocationManager.GPS_PROVIDER)) {
- try {
- mBatteryStats.noteRequestGpsOn(mCallingUid);
- } catch (RemoteException e) {
- Log.w(TAG, "Got RemoteException calling noteRequestGpsOff", e);
- }
+
+ // Clear heartbeats if any before starting a new one
+ mLocationHandler.removeMessages(MESSAGE_HEARTBEAT, provider);
+ Message m = Message.obtain(mLocationHandler, MESSAGE_HEARTBEAT, provider);
+ mLocationHandler.sendMessageAtTime(m, SystemClock.uptimeMillis() + 1000);
+ } else {
+ try {
+ // Notify the listener that updates are currently disabled
+ if (receiver.isListener()) {
+ receiver.getListener().onProviderDisabled(provider);
}
-
- long minTimeForProvider = getMinTime(provider);
- impl.setMinTime(minTimeForProvider);
- impl.enableLocationTracking(true);
- updateWakelockStatus(mScreenOn);
-
- // Clear heartbeats if any before starting a new one
- mLocationHandler.removeMessages(MESSAGE_HEARTBEAT, provider);
- Message m = Message.obtain(mLocationHandler, MESSAGE_HEARTBEAT, provider);
- mLocationHandler.sendMessageAtTime(m, SystemClock.uptimeMillis() + 1000);
- } else {
- try {
- // Notify the listener that updates are currently disabled
- if (receiver.isListener()) {
- receiver.getListener().onProviderDisabled(provider);
- }
- } catch(RemoteException e) {
- Log.w(TAG, "RemoteException calling onProviderDisabled on " +
- receiver.getListener());
- }
+ } catch(RemoteException e) {
+ Log.w(TAG, "RemoteException calling onProviderDisabled on " +
+ receiver.getListener());
}
}
} finally {
Binder.restoreCallingIdentity(identity);
- mCallingUid = -1;
}
}
public void removeUpdates(ILocationListener listener) {
try {
- _removeUpdates(new Receiver(listener));
+ synchronized (mLocationListeners) {
+ removeUpdatesLocked(new Receiver(listener, Binder.getCallingUid()));
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -960,7 +1060,9 @@
public void removeUpdatesPI(PendingIntent intent) {
try {
- _removeUpdates(new Receiver(intent));
+ synchronized (mLocationListeners) {
+ removeUpdatesLocked(new Receiver(intent, Binder.getCallingUid()));
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -968,84 +1070,77 @@
}
}
- private synchronized void _removeUpdates(Receiver receiver) {
- Object key = receiver.getKey();
+ private void removeUpdatesLocked(Receiver receiver) {
if (Config.LOGD) {
- Log.d(TAG, "_removeUpdates: listener = " + key);
+ Log.d(TAG, "_removeUpdates: listener = " + receiver);
}
// so wakelock calls will succeed
- mCallingUid = getCallingUid();
+ final int callingUid = Binder.getCallingUid();
long identity = Binder.clearCallingIdentity();
try {
- synchronized (mLocationListeners) {
- Receiver myReceiver = mListeners.remove(key);
- if ((myReceiver != null) && (myReceiver.isListener())) {
+ int idx = mListeners.indexOf(receiver);
+ if (idx >= 0) {
+ Receiver myReceiver = mListeners.remove(idx);
+ if (myReceiver.isListener()) {
myReceiver.getListener().asBinder().unlinkToDeath(myReceiver, 0);
}
-
- // Record which providers were associated with this listener
- HashSet<String> providers = new HashSet<String>();
- HashMap<String,UpdateRecord> oldRecords = mLocationListeners.get(key);
- if (oldRecords != null) {
- // Call dispose() on the obsolete update records.
- for (UpdateRecord record : oldRecords.values()) {
- if (record.mProvider.equals(LocationManager.NETWORK_PROVIDER)) {
- if (mNetworkLocationInterface != null) {
- mNetworkLocationInterface.removeListener(record.mPackages);
- }
- }
- record.dispose();
- }
- // Accumulate providers
- providers.addAll(oldRecords.keySet());
- }
-
- if (providers.contains("gps")) {
- try {
- mBatteryStats.noteRequestGpsOff(mCallingUid);
- } catch (RemoteException e) {
- Log.w(TAG, "Got RemoteException calling noteRequestGpsOff", e);
- }
- }
-
- mLocationListeners.remove(key);
- mLastFixBroadcast.remove(key);
- mLastStatusBroadcast.remove(key);
-
- // See if the providers associated with this listener have any
- // other listeners; if one does, inform it of the new smallest minTime
- // value; if one does not, disable location tracking for it
- for (String provider : providers) {
- // If provider is already disabled, don't need to do anything
- if (!isAllowedBySettings(provider)) {
- continue;
- }
-
- boolean hasOtherListener = false;
- synchronized (mRecordsByProvider) {
- HashSet<UpdateRecord> recordsForProvider = mRecordsByProvider.get(provider);
- if (recordsForProvider != null && recordsForProvider.size() > 0) {
- hasOtherListener = true;
- }
- }
-
- LocationProviderImpl p = LocationProviderImpl.getProvider(provider);
- if (p != null) {
- if (hasOtherListener) {
- p.setMinTime(getMinTime(provider));
- } else {
- mLocationHandler.removeMessages(MESSAGE_HEARTBEAT, provider);
- p.enableLocationTracking(false);
- }
- }
- }
-
- updateWakelockStatus(mScreenOn);
}
+
+ // Record which providers were associated with this listener
+ HashSet<String> providers = new HashSet<String>();
+ HashMap<String,UpdateRecord> oldRecords = mLocationListeners.get(receiver);
+ if (oldRecords != null) {
+ // Call dispose() on the obsolete update records.
+ for (UpdateRecord record : oldRecords.values()) {
+ if (record.mProvider.equals(LocationManager.NETWORK_PROVIDER)) {
+ if (mNetworkLocationInterface != null) {
+ mNetworkLocationInterface.removeListener(record.mPackages);
+ }
+ }
+ record.disposeLocked();
+ }
+ // Accumulate providers
+ providers.addAll(oldRecords.keySet());
+ }
+
+ mLocationListeners.remove(receiver);
+ mLastFixBroadcast.remove(receiver);
+ mLastStatusBroadcast.remove(receiver);
+
+ // See if the providers associated with this listener have any
+ // other listeners; if one does, inform it of the new smallest minTime
+ // value; if one does not, disable location tracking for it
+ for (String provider : providers) {
+ // If provider is already disabled, don't need to do anything
+ if (!isAllowedBySettingsLocked(provider)) {
+ continue;
+ }
+
+ boolean hasOtherListener = false;
+ ArrayList<UpdateRecord> recordsForProvider = mRecordsByProvider.get(provider);
+ if (recordsForProvider != null && recordsForProvider.size() > 0) {
+ hasOtherListener = true;
+ }
+
+ LocationProviderImpl p = LocationProviderImpl.getProvider(provider);
+ if (p != null) {
+ if (hasOtherListener) {
+ p.setMinTime(getMinTimeLocked(provider));
+ } else {
+ mLocationHandler.removeMessages(MESSAGE_HEARTBEAT, provider);
+ p.enableLocationTracking(false);
+ }
+
+ if (p == mGpsLocationProvider && mGpsNavigating) {
+ updateReportedGpsLocked();
+ }
+ }
+ }
+
+ updateWakelockStatusLocked(mScreenOn);
} finally {
Binder.restoreCallingIdentity(identity);
- mCallingUid = -1;
}
}
@@ -1054,7 +1149,7 @@
return false;
}
if (mContext.checkCallingPermission(ACCESS_FINE_LOCATION) !=
- PackageManager.PERMISSION_GRANTED) {
+ PackageManager.PERMISSION_GRANTED) {
throw new SecurityException("Requires ACCESS_FINE_LOCATION permission");
}
@@ -1068,36 +1163,42 @@
}
public void removeGpsStatusListener(IGpsStatusListener listener) {
- mGpsLocationProvider.removeGpsStatusListener(listener);
+ synchronized (mLocationListeners) {
+ mGpsLocationProvider.removeGpsStatusListener(listener);
+ }
}
public boolean sendExtraCommand(String provider, String command, Bundle extras) {
// first check for permission to the provider
- checkPermissions(provider);
+ checkPermissionsSafe(provider);
// and check for ACCESS_LOCATION_EXTRA_COMMANDS
if ((mContext.checkCallingPermission(ACCESS_LOCATION_EXTRA_COMMANDS)
!= PackageManager.PERMISSION_GRANTED)) {
throw new SecurityException("Requires ACCESS_LOCATION_EXTRA_COMMANDS permission");
}
- LocationProviderImpl impl = LocationProviderImpl.getProvider(provider);
- if (provider == null) {
- return false;
+ synchronized (mLocationListeners) {
+ LocationProviderImpl impl = LocationProviderImpl.getProvider(provider);
+ if (provider == null) {
+ return false;
+ }
+
+ return impl.sendExtraCommand(command, extras);
}
-
- return impl.sendExtraCommand(command, extras);
}
class ProximityAlert {
- double mLatitude;
- double mLongitude;
- float mRadius;
- long mExpiration;
- PendingIntent mIntent;
- Location mLocation;
+ final int mUid;
+ final double mLatitude;
+ final double mLongitude;
+ final float mRadius;
+ final long mExpiration;
+ final PendingIntent mIntent;
+ final Location mLocation;
- public ProximityAlert(double latitude, double longitude,
+ public ProximityAlert(int uid, double latitude, double longitude,
float radius, long expiration, PendingIntent intent) {
+ mUid = uid;
mLatitude = latitude;
mLongitude = longitude;
mRadius = radius;
@@ -1109,15 +1210,15 @@
mLocation.setLongitude(longitude);
}
- public long getExpiration() {
+ long getExpiration() {
return mExpiration;
}
- public PendingIntent getIntent() {
+ PendingIntent getIntent() {
return mIntent;
}
- public boolean isInProximity(double latitude, double longitude) {
+ boolean isInProximity(double latitude, double longitude) {
Location loc = new Location("");
loc.setLatitude(latitude);
loc.setLongitude(longitude);
@@ -1125,6 +1226,22 @@
double radius = loc.distanceTo(mLocation);
return radius <= mRadius;
}
+
+ @Override
+ public String toString() {
+ return "ProximityAlert{"
+ + Integer.toHexString(System.identityHashCode(this))
+ + " uid " + mUid + mIntent + "}";
+ }
+
+ void dump(PrintWriter pw, String prefix) {
+ pw.println(prefix + this);
+ pw.println(prefix + "mLatitude=" + mLatitude + " mLongitude=" + mLongitude);
+ pw.println(prefix + "mRadius=" + mRadius + " mExpiration=" + mExpiration);
+ pw.println(prefix + "mIntent=" + mIntent);
+ pw.println(prefix + "mLocation:");
+ mLocation.dump(new PrintWriterPrinter(pw), prefix + " ");
+ }
}
// Listener for receiving locations to trigger proximity alerts
@@ -1132,6 +1249,7 @@
boolean isGpsAvailable = false;
+ // Note: this is called with the lock held.
public void onLocationChanged(Location loc) {
// If Gps is available, then ignore updates from NetworkLocationProvider
@@ -1216,16 +1334,19 @@
}
+ // Note: this is called with the lock held.
public void onProviderDisabled(String provider) {
if (provider.equals(LocationManager.GPS_PROVIDER)) {
isGpsAvailable = false;
}
}
+ // Note: this is called with the lock held.
public void onProviderEnabled(String provider) {
// ignore
}
+ // Note: this is called with the lock held.
public void onStatusChanged(String provider, int status, Bundle extras) {
if ((provider.equals(LocationManager.GPS_PROVIDER)) &&
(status != LocationProvider.AVAILABLE)) {
@@ -1237,7 +1358,9 @@
public void addProximityAlert(double latitude, double longitude,
float radius, long expiration, PendingIntent intent) {
try {
- _addProximityAlert(latitude, longitude, radius, expiration, intent);
+ synchronized (mLocationListeners) {
+ addProximityAlertLocked(latitude, longitude, radius, expiration, intent);
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -1245,7 +1368,7 @@
}
}
- private void _addProximityAlert(double latitude, double longitude,
+ private void addProximityAlertLocked(double latitude, double longitude,
float radius, long expiration, PendingIntent intent) {
if (Config.LOGD) {
Log.d(TAG, "addProximityAlert: latitude = " + latitude +
@@ -1255,37 +1378,42 @@
}
// Require ability to access all providers for now
- if (!isAllowedProvider(LocationManager.GPS_PROVIDER) ||
- !isAllowedProvider(LocationManager.NETWORK_PROVIDER)) {
+ if (!isAllowedProviderSafe(LocationManager.GPS_PROVIDER) ||
+ !isAllowedProviderSafe(LocationManager.NETWORK_PROVIDER)) {
throw new SecurityException("Requires ACCESS_FINE_LOCATION permission");
}
if (expiration != -1) {
expiration += System.currentTimeMillis();
}
- ProximityAlert alert = new ProximityAlert(latitude, longitude, radius, expiration, intent);
+ ProximityAlert alert = new ProximityAlert(Binder.getCallingUid(),
+ latitude, longitude, radius, expiration, intent);
mProximityAlerts.put(intent, alert);
if (mProximityListener == null) {
- mProximityListener = new Receiver(new ProximityListener());
+ mProximityListener = new Receiver(new ProximityListener(), -1);
LocationProvider provider = LocationProviderImpl.getProvider(
LocationManager.GPS_PROVIDER);
if (provider != null) {
- _requestLocationUpdates(provider.getName(), 1000L, 1.0f, mProximityListener);
+ requestLocationUpdatesLocked(provider.getName(), 1000L, 1.0f, mProximityListener);
}
provider =
LocationProviderImpl.getProvider(LocationManager.NETWORK_PROVIDER);
if (provider != null) {
- _requestLocationUpdates(provider.getName(), 1000L, 1.0f, mProximityListener);
+ requestLocationUpdatesLocked(provider.getName(), 1000L, 1.0f, mProximityListener);
}
+ } else if (mGpsNavigating) {
+ updateReportedGpsLocked();
}
}
public void removeProximityAlert(PendingIntent intent) {
try {
- _removeProximityAlert(intent);
+ synchronized (mLocationListeners) {
+ removeProximityAlertLocked(intent);
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -1293,15 +1421,17 @@
}
}
- private void _removeProximityAlert(PendingIntent intent) {
+ private void removeProximityAlertLocked(PendingIntent intent) {
if (Config.LOGD) {
Log.d(TAG, "removeProximityAlert: intent = " + intent);
}
mProximityAlerts.remove(intent);
if (mProximityAlerts.size() == 0) {
- _removeUpdates(mProximityListener);
+ removeUpdatesLocked(mProximityListener);
mProximityListener = null;
+ } else if (mGpsNavigating) {
+ updateReportedGpsLocked();
}
}
@@ -1312,7 +1442,9 @@
*/
public Bundle getProviderInfo(String provider) {
try {
- return _getProviderInfo(provider);
+ synchronized (mLocationListeners) {
+ return _getProviderInfoLocked(provider);
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -1321,13 +1453,13 @@
}
}
- private Bundle _getProviderInfo(String provider) {
+ private Bundle _getProviderInfoLocked(String provider) {
LocationProviderImpl p = LocationProviderImpl.getProvider(provider);
if (p == null) {
return null;
}
- checkPermissions(provider);
+ checkPermissionsSafe(provider);
Bundle b = new Bundle();
b.putBoolean("network", p.requiresNetwork());
@@ -1345,7 +1477,9 @@
public boolean isProviderEnabled(String provider) {
try {
- return _isProviderEnabled(provider);
+ synchronized (mLocationListeners) {
+ return _isProviderEnabledLocked(provider);
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -1354,19 +1488,21 @@
}
}
- private boolean _isProviderEnabled(String provider) {
- checkPermissions(provider);
+ private boolean _isProviderEnabledLocked(String provider) {
+ checkPermissionsSafe(provider);
LocationProviderImpl p = LocationProviderImpl.getProvider(provider);
if (p == null) {
throw new IllegalArgumentException("provider=" + provider);
}
- return isAllowedBySettings(provider);
+ return isAllowedBySettingsLocked(provider);
}
public Location getLastKnownLocation(String provider) {
try {
- return _getLastKnownLocation(provider);
+ synchronized (mLocationListeners) {
+ return _getLastKnownLocationLocked(provider);
+ }
} catch (SecurityException se) {
throw se;
} catch (Exception e) {
@@ -1375,22 +1511,22 @@
}
}
- private Location _getLastKnownLocation(String provider) {
- checkPermissions(provider);
+ private Location _getLastKnownLocationLocked(String provider) {
+ checkPermissionsSafe(provider);
LocationProviderImpl p = LocationProviderImpl.getProvider(provider);
if (p == null) {
throw new IllegalArgumentException("provider=" + provider);
}
- if (!isAllowedBySettings(provider)) {
+ if (!isAllowedBySettingsLocked(provider)) {
return null;
}
Location location = mLastKnownLocation.get(provider);
if (location == null) {
// Get the persistent last known location for the provider
- location = readLastKnownLocation(provider);
+ location = readLastKnownLocationLocked(provider);
if (location != null) {
mLastKnownLocation.put(provider, location);
}
@@ -1399,7 +1535,7 @@
return location;
}
- private boolean shouldBroadcast(Location loc, Location lastLoc, UpdateRecord record) {
+ private static boolean shouldBroadcastSafe(Location loc, Location lastLoc, UpdateRecord record) {
// Always broadcast the first update
if (lastLoc == null) {
return true;
@@ -1422,8 +1558,8 @@
return true;
}
- private void handleLocationChanged(String provider) {
- HashSet<UpdateRecord> records = mRecordsByProvider.get(provider);
+ private void handleLocationChangedLocked(String provider) {
+ ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);
if (records == null || records.size() == 0) {
return;
}
@@ -1460,7 +1596,7 @@
} else {
location.set(loc);
}
- writeLastKnownLocation(provider, loc);
+ writeLastKnownLocationLocked(provider, loc);
if (p instanceof INetworkLocationProvider) {
mWakeLockNetworkReceived = true;
@@ -1495,40 +1631,44 @@
extras.putAll(mockExtras);
}
+ ArrayList<Receiver> deadReceivers = null;
+
// Broadcast location or status to all listeners
- for (UpdateRecord r : records) {
+ final int N = records.size();
+ for (int i=0; i<N; i++) {
+ UpdateRecord r = records.get(i);
Receiver receiver = r.mReceiver;
- Object key = receiver.getKey();
// Broadcast location only if it is valid
if (locationValid) {
- HashMap<String,Location> map = mLastFixBroadcast.get(key);
+ HashMap<String,Location> map = mLastFixBroadcast.get(receiver);
if (map == null) {
map = new HashMap<String,Location>();
- mLastFixBroadcast.put(key, map);
+ mLastFixBroadcast.put(receiver, map);
}
Location lastLoc = map.get(provider);
- if ((lastLoc == null) || shouldBroadcast(loc, lastLoc, r)) {
+ if ((lastLoc == null) || shouldBroadcastSafe(loc, lastLoc, r)) {
if (lastLoc == null) {
lastLoc = new Location(loc);
map.put(provider, lastLoc);
} else {
lastLoc.set(loc);
}
- try {
- receiver.onLocationChanged(loc);
- } catch (RemoteException doe) {
+ if (!receiver.callLocationChangedLocked(loc)) {
Log.w(TAG, "RemoteException calling onLocationChanged on " + receiver);
- _removeUpdates(receiver);
+ if (deadReceivers == null) {
+ deadReceivers = new ArrayList<Receiver>();
+ }
+ deadReceivers.add(receiver);
}
}
}
// Broadcast status message
- HashMap<String,Long> statusMap = mLastStatusBroadcast.get(key);
+ HashMap<String,Long> statusMap = mLastStatusBroadcast.get(receiver);
if (statusMap == null) {
statusMap = new HashMap<String,Long>();
- mLastStatusBroadcast.put(key, statusMap);
+ mLastStatusBroadcast.put(receiver, statusMap);
}
long prevStatusUpdateTime =
(statusMap.get(provider) != null) ? statusMap.get(provider) : 0;
@@ -1537,14 +1677,23 @@
(prevStatusUpdateTime != 0 || status != LocationProvider.AVAILABLE)) {
statusMap.put(provider, newStatusUpdateTime);
- try {
- receiver.onStatusChanged(provider, status, extras);
- } catch (RemoteException doe) {
+ if (!receiver.callStatusChangedLocked(provider, status, extras)) {
Log.w(TAG, "RemoteException calling onStatusChanged on " + receiver);
- _removeUpdates(receiver);
+ if (deadReceivers == null) {
+ deadReceivers = new ArrayList<Receiver>();
+ }
+ if (!deadReceivers.contains(receiver)) {
+ deadReceivers.add(receiver);
+ }
}
}
}
+
+ if (deadReceivers != null) {
+ for (int i=deadReceivers.size()-1; i>=0; i--) {
+ removeUpdatesLocked(deadReceivers.get(i));
+ }
+ }
}
private class LocationWorkerHandler extends Handler {
@@ -1555,59 +1704,63 @@
if (msg.what == MESSAGE_HEARTBEAT) {
// log("LocationWorkerHandler: Heartbeat!");
- synchronized (mRecordsByProvider) {
+ synchronized (mLocationListeners) {
String provider = (String) msg.obj;
- if (!isAllowedBySettings(provider)) {
+ if (!isAllowedBySettingsLocked(provider)) {
return;
}
// Process the location fix if the screen is on or we're holding a wakelock
if (mScreenOn || (mWakeLockAcquireTime != 0)) {
- handleLocationChanged(provider);
+ handleLocationChangedLocked(provider);
}
// If it continues to have listeners
- HashSet<UpdateRecord> records = mRecordsByProvider.get(provider);
+ ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider);
if (records != null && records.size() > 0) {
Message m = Message.obtain(this, MESSAGE_HEARTBEAT, provider);
sendMessageAtTime(m, SystemClock.uptimeMillis() + 1000);
}
- }
- if ((mWakeLockAcquireTime != 0) &&
- (SystemClock.elapsedRealtime() - mWakeLockAcquireTime
- > MAX_TIME_FOR_WAKE_LOCK)) {
-
- removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK);
- removeMessages(MESSAGE_RELEASE_WAKE_LOCK);
-
- log("LocationWorkerHandler: Exceeded max time for wake lock");
- Message m = Message.obtain(this, MESSAGE_RELEASE_WAKE_LOCK);
- sendMessageAtFrontOfQueue(m);
-
- } else if (mWakeLockAcquireTime != 0 &&
- mWakeLockGpsReceived && mWakeLockNetworkReceived) {
-
- removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK);
- removeMessages(MESSAGE_RELEASE_WAKE_LOCK);
-
- log("LocationWorkerHandler: Locations received.");
- mWakeLockAcquireTime = 0;
- Message m = Message.obtain(this, MESSAGE_RELEASE_WAKE_LOCK);
- sendMessageDelayed(m, TIME_AFTER_WAKE_LOCK);
+ if ((mWakeLockAcquireTime != 0) &&
+ (SystemClock.elapsedRealtime() - mWakeLockAcquireTime
+ > MAX_TIME_FOR_WAKE_LOCK)) {
+
+ removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK);
+ removeMessages(MESSAGE_RELEASE_WAKE_LOCK);
+
+ log("LocationWorkerHandler: Exceeded max time for wake lock");
+ Message m = Message.obtain(this, MESSAGE_RELEASE_WAKE_LOCK);
+ sendMessageAtFrontOfQueue(m);
+
+ } else if (mWakeLockAcquireTime != 0 &&
+ mWakeLockGpsReceived && mWakeLockNetworkReceived) {
+
+ removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK);
+ removeMessages(MESSAGE_RELEASE_WAKE_LOCK);
+
+ log("LocationWorkerHandler: Locations received.");
+ mWakeLockAcquireTime = 0;
+ Message m = Message.obtain(this, MESSAGE_RELEASE_WAKE_LOCK);
+ sendMessageDelayed(m, TIME_AFTER_WAKE_LOCK);
+ }
}
} else if (msg.what == MESSAGE_ACQUIRE_WAKE_LOCK) {
log("LocationWorkerHandler: Acquire");
- acquireWakeLock();
+ synchronized (mLocationListeners) {
+ acquireWakeLockLocked();
+ }
} else if (msg.what == MESSAGE_RELEASE_WAKE_LOCK) {
log("LocationWorkerHandler: Release");
// Update wakelock status so the next alarm is set before releasing wakelock
- updateWakelockStatus(mScreenOn);
- releaseWakeLock();
+ synchronized (mLocationListeners) {
+ updateWakelockStatusLocked(mScreenOn);
+ releaseWakeLockLocked();
+ }
} else if (msg.what == MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER) {
- synchronized (LocationManagerService.class) {
+ synchronized (mLocationListeners) {
Log.d(TAG, "installing network location provider");
INetworkLocationManager.InstallCallback callback =
(INetworkLocationManager.InstallCallback)msg.obj;
@@ -1627,21 +1780,23 @@
@Override
public void onCellLocationChanged(CellLocation cellLocation) {
try {
- int asu = mSignalStrength;
-
- // Gets cell state
- mLastCellState = new CellState(mTelephonyManager, cellLocation, asu);
-
- // Notify collector
- if (mCollector != null) {
- mCollector.updateCellState(mLastCellState);
- }
-
- // Updates providers
- List<LocationProviderImpl> providers = LocationProviderImpl.getProviders();
- for (LocationProviderImpl provider : providers) {
- if (provider.requiresCell()) {
- provider.updateCellState(mLastCellState);
+ synchronized (mLocationListeners) {
+ int asu = mSignalStrength;
+
+ // Gets cell state
+ mLastCellState = new CellState(mTelephonyManager, cellLocation, asu);
+
+ // Notify collector
+ if (mCollector != null) {
+ mCollector.updateCellState(mLastCellState);
+ }
+
+ // Updates providers
+ List<LocationProviderImpl> providers = LocationProviderImpl.getProviders();
+ for (LocationProviderImpl provider : providers) {
+ if (provider.requiresCell()) {
+ provider.updateCellState(mLastCellState);
+ }
}
}
} catch (Exception e) {
@@ -1651,17 +1806,21 @@
@Override
public void onSignalStrengthChanged(int asu) {
- mSignalStrength = asu;
-
- if (mLastCellState != null) {
- mLastCellState.updateSignalStrength(asu);
+ synchronized (mLocationListeners) {
+ mSignalStrength = asu;
+
+ if (mLastCellState != null) {
+ mLastCellState.updateSignalStrength(asu);
+ }
}
}
@Override
public void onDataConnectionStateChanged(int state) {
- if (mLastCellState != null) {
- mLastCellState.updateRadioType(mTelephonyManager);
+ synchronized (mLocationListeners) {
+ if (mLastCellState != null) {
+ mLastCellState.updateRadioType(mTelephonyManager);
+ }
}
}
};
@@ -1671,30 +1830,81 @@
String action = intent.getAction();
if (action.equals(ALARM_INTENT)) {
- mLocationHandler.removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK);
- mLocationHandler.removeMessages(MESSAGE_RELEASE_WAKE_LOCK);
-
- log("PowerStateBroadcastReceiver: Alarm received");
- Message m = mLocationHandler.obtainMessage(MESSAGE_ACQUIRE_WAKE_LOCK);
- mLocationHandler.sendMessageAtFrontOfQueue(m);
+ synchronized (mLocationListeners) {
+ log("PowerStateBroadcastReceiver: Alarm received");
+ mLocationHandler.removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK);
+ // Have to do this immediately, rather than posting a
+ // message, so we execute our code while the system
+ // is holding a wake lock until the alarm broadcast
+ // is finished.
+ acquireWakeLockLocked();
+ }
} else if (action.equals(Intent.ACTION_SCREEN_OFF)) {
log("PowerStateBroadcastReceiver: Screen off");
- updateWakelockStatus(false);
+ synchronized (mLocationListeners) {
+ updateWakelockStatusLocked(false);
+ }
} else if (action.equals(Intent.ACTION_SCREEN_ON)) {
log("PowerStateBroadcastReceiver: Screen on");
- updateWakelockStatus(true);
+ synchronized (mLocationListeners) {
+ updateWakelockStatusLocked(true);
+ }
} else if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {
log("PowerStateBroadcastReceiver: Battery changed");
- int scale = intent.getIntExtra(BATTERY_EXTRA_SCALE, 100);
- int level = intent.getIntExtra(BATTERY_EXTRA_LEVEL, 0);
- boolean plugged = intent.getIntExtra(BATTERY_EXTRA_PLUGGED, 0) != 0;
-
- // Notify collector battery state
- if (mCollector != null) {
- mCollector.updateBatteryState(scale, level, plugged);
+ synchronized (mLocationListeners) {
+ int scale = intent.getIntExtra(BATTERY_EXTRA_SCALE, 100);
+ int level = intent.getIntExtra(BATTERY_EXTRA_LEVEL, 0);
+ boolean plugged = intent.getIntExtra(BATTERY_EXTRA_PLUGGED, 0) != 0;
+
+ // Notify collector battery state
+ if (mCollector != null) {
+ mCollector.updateBatteryState(scale, level, plugged);
+ }
+ }
+ } else if (action.equals(Intent.ACTION_PACKAGE_REMOVED)
+ || action.equals(Intent.ACTION_PACKAGE_RESTARTED)) {
+ synchronized (mLocationListeners) {
+ int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
+ if (uid >= 0) {
+ ArrayList<Receiver> removedRecs = null;
+ for (ArrayList<UpdateRecord> i : mRecordsByProvider.values()) {
+ for (int j=i.size()-1; j>=0; j--) {
+ UpdateRecord ur = i.get(j);
+ if (ur.mReceiver.isPendingIntent() && ur.mUid == uid) {
+ if (removedRecs == null) {
+ removedRecs = new ArrayList<Receiver>();
+ }
+ if (!removedRecs.contains(ur.mReceiver)) {
+ removedRecs.add(ur.mReceiver);
+ }
+ }
+ }
+ }
+ ArrayList<ProximityAlert> removedAlerts = null;
+ for (ProximityAlert i : mProximityAlerts.values()) {
+ if (i.mUid == uid) {
+ if (removedAlerts == null) {
+ removedAlerts = new ArrayList<ProximityAlert>();
+ }
+ if (!removedAlerts.contains(i)) {
+ removedAlerts.add(i);
+ }
+ }
+ }
+ if (removedRecs != null) {
+ for (int i=removedRecs.size()-1; i>=0; i--) {
+ removeUpdatesLocked(removedRecs.get(i));
+ }
+ }
+ if (removedAlerts != null) {
+ for (int i=removedAlerts.size()-1; i>=0; i--) {
+ removeProximityAlertLocked(removedAlerts.get(i).mIntent);
+ }
+ }
+ }
}
}
}
@@ -1713,11 +1923,13 @@
}
// Notify provider and collector of Wifi scan results
- if (mCollector != null) {
- mCollector.updateWifiScanResults(wifiScanResults);
- }
- if (mNetworkLocationInterface != null) {
- mNetworkLocationInterface.updateWifiScanResults(wifiScanResults);
+ synchronized (mLocationListeners) {
+ if (mCollector != null) {
+ mCollector.updateWifiScanResults(wifiScanResults);
+ }
+ if (mNetworkLocationInterface != null) {
+ mNetworkLocationInterface.updateWifiScanResults(wifiScanResults);
+ }
}
} else if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
@@ -1730,10 +1942,12 @@
}
// Notify location providers of current network state
- List<LocationProviderImpl> providers = LocationProviderImpl.getProviders();
- for (LocationProviderImpl provider : providers) {
- if (provider.requiresNetwork()) {
- provider.updateNetworkState(networkState);
+ synchronized (mLocationListeners) {
+ List<LocationProviderImpl> providers = LocationProviderImpl.getProviders();
+ for (LocationProviderImpl provider : providers) {
+ if (provider.requiresNetwork()) {
+ provider.updateNetworkState(networkState);
+ }
}
}
@@ -1751,8 +1965,10 @@
}
// Notify network provider of current wifi enabled state
- if (mNetworkLocationInterface != null) {
- mNetworkLocationInterface.updateWifiEnabledState(enabled);
+ synchronized (mLocationListeners) {
+ if (mNetworkLocationInterface != null) {
+ mNetworkLocationInterface.updateWifiEnabledState(enabled);
+ }
}
} else if (action.equals(GpsLocationProvider.GPS_ENABLED_CHANGE_ACTION)) {
@@ -1760,9 +1976,16 @@
final boolean enabled = intent.getBooleanExtra(GpsLocationProvider.EXTRA_ENABLED,
false);
- if (!enabled) {
- // When GPS is disabled, we are OK to release wake-lock
- mWakeLockGpsReceived = true;
+ synchronized (mLocationListeners) {
+ if (enabled) {
+ updateReportedGpsLocked();
+ mGpsNavigating = true;
+ } else {
+ reportStopGpsLocked();
+ mGpsNavigating = false;
+ // When GPS is disabled, we are OK to release wake-lock
+ mWakeLockGpsReceived = true;
+ }
}
}
@@ -1771,7 +1994,7 @@
// Wake locks
- private void updateWakelockStatus(boolean screenOn) {
+ private void updateWakelockStatusLocked(boolean screenOn) {
log("updateWakelockStatus(): " + screenOn);
boolean needsLock = false;
@@ -1786,11 +2009,10 @@
needsLock = true;
minTime = Math.min(mGpsLocationProvider.getMinTime(), minTime);
if (screenOn) {
- startGps();
+ startGpsLocked();
} else if (mScreenOn && !screenOn) {
-
// We just turned the screen off so stop navigating
- stopGps();
+ stopGpsLocked();
}
}
@@ -1816,13 +2038,13 @@
// Clear out existing wakelocks
mLocationHandler.removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK);
mLocationHandler.removeMessages(MESSAGE_RELEASE_WAKE_LOCK);
- releaseWakeLock();
+ releaseWakeLockLocked();
}
}
- private void acquireWakeLock() {
+ private void acquireWakeLockLocked() {
try {
- acquireWakeLockX();
+ acquireWakeLockXLocked();
} catch (Exception e) {
// This is to catch a runtime exception thrown when we try to release an
// already released lock.
@@ -1830,7 +2052,7 @@
}
}
- private void acquireWakeLockX() {
+ private void acquireWakeLockXLocked() {
if (mWakeLock.isHeld()) {
log("Must release wakelock before acquiring");
mWakeLockAcquireTime = 0;
@@ -1857,7 +2079,7 @@
log("Acquired wakelock");
// Start the gps provider
- startGps();
+ startGpsLocked();
// Acquire cell lock
if (mCellWakeLockAcquired) {
@@ -1875,7 +2097,7 @@
}
// Acquire wifi lock
- WifiManager.WifiLock wifiLock = getWifiWakelock();
+ WifiManager.WifiLock wifiLock = getWifiWakelockLocked();
if (wifiLock != null) {
if (mWifiWakeLockAcquired) {
// Lock is already acquired
@@ -1889,41 +2111,104 @@
}
}
- private void startGps() {
+ private boolean reportGpsUidLocked(int curSeq, int nextSeq, int uid) {
+ int seq = mReportedGpsUids.get(uid, -1);
+ if (seq == curSeq) {
+ // Already reported; propagate to next sequence.
+ mReportedGpsUids.put(uid, nextSeq);
+ return true;
+ } else if (seq != nextSeq) {
+ try {
+ // New UID; report it.
+ mBatteryStats.noteStartGps(uid);
+ mReportedGpsUids.put(uid, nextSeq);
+ return true;
+ } catch (RemoteException e) {
+ }
+ }
+ return false;
+ }
+
+ private void updateReportedGpsLocked() {
+ if (mGpsLocationProvider == null) {
+ return;
+ }
+
+ final String name = mGpsLocationProvider.getName();
+ final int curSeq = mReportedGpsSeq;
+ final int nextSeq = (curSeq+1) >= 0 ? (curSeq+1) : 0;
+ mReportedGpsSeq = nextSeq;
+
+ ArrayList<UpdateRecord> urs = mRecordsByProvider.get(name);
+ int num = 0;
+ final int N = urs.size();
+ for (int i=0; i<N; i++) {
+ UpdateRecord ur = urs.get(i);
+ if (ur.mReceiver == mProximityListener) {
+ // We don't want the system to take the blame for this one.
+ continue;
+ }
+ if (reportGpsUidLocked(curSeq, nextSeq, ur.mUid)) {
+ num++;
+ }
+ }
+
+ for (ProximityAlert pe : mProximityAlerts.values()) {
+ if (reportGpsUidLocked(curSeq, nextSeq, pe.mUid)) {
+ num++;
+ }
+ }
+
+ if (num != mReportedGpsUids.size()) {
+ // The number of uids is processed is different than the
+ // array; report any that are no longer active.
+ for (int i=mReportedGpsUids.size()-1; i>=0; i--) {
+ if (mReportedGpsUids.valueAt(i) != nextSeq) {
+ try {
+ mBatteryStats.noteStopGps(mReportedGpsUids.keyAt(i));
+ } catch (RemoteException e) {
+ }
+ mReportedGpsUids.removeAt(i);
+ }
+ }
+ }
+ }
+
+ private void reportStopGpsLocked() {
+ int curSeq = mReportedGpsSeq;
+ for (int i=mReportedGpsUids.size()-1; i>=0; i--) {
+ if (mReportedGpsUids.valueAt(i) == curSeq) {
+ try {
+ mBatteryStats.noteStopGps(mReportedGpsUids.keyAt(i));
+ } catch (RemoteException e) {
+ }
+ }
+ }
+ curSeq++;
+ if (curSeq < 0) curSeq = 0;
+ mReportedGpsSeq = curSeq;
+ mReportedGpsUids.clear();
+ }
+
+ private void startGpsLocked() {
boolean gpsActive = (mGpsLocationProvider != null)
&& mGpsLocationProvider.isLocationTracking();
if (gpsActive) {
mGpsLocationProvider.startNavigating();
- long identity = Binder.clearCallingIdentity();
- try {
- mBatteryStats.noteStartGps(mCallingUid == -1 ? getCallingUid() : mCallingUid);
- } catch (RemoteException e) {
- Log.w(TAG, "RemoteException calling noteStartGps on BatteryStatsService", e);
- } finally {
- Binder.restoreCallingIdentity(identity);
- }
}
}
- private void stopGps() {
+ private void stopGpsLocked() {
boolean gpsActive = mGpsLocationProvider != null
&& mGpsLocationProvider.isLocationTracking();
if (gpsActive) {
mGpsLocationProvider.stopNavigating();
- long identity = Binder.clearCallingIdentity();
- try {
- mBatteryStats.noteStopGps(mCallingUid == -1 ? getCallingUid() : mCallingUid);
- } catch (RemoteException e) {
- Log.w(TAG, "RemoteException calling noteStopGps on BatteryStatsService", e);
- } finally {
- Binder.restoreCallingIdentity(identity);
- }
}
}
- private void releaseWakeLock() {
+ private void releaseWakeLockLocked() {
try {
- releaseWakeLockX();
+ releaseWakeLockXLocked();
} catch (Exception e) {
// This is to catch a runtime exception thrown when we try to release an
// already released lock.
@@ -1931,9 +2216,9 @@
}
}
- private void releaseWakeLockX() {
+ private void releaseWakeLockXLocked() {
// Release wifi lock
- WifiManager.WifiLock wifiLock = getWifiWakelock();
+ WifiManager.WifiLock wifiLock = getWifiWakelockLocked();
if (wifiLock != null) {
if (mWifiWakeLockAcquired) {
wifiLock.release();
@@ -1943,7 +2228,7 @@
if (!mScreenOn) {
// Stop the gps
- stopGps();
+ stopGpsLocked();
}
// Release cell lock
@@ -1971,11 +2256,13 @@
public String getFromLocation(double latitude, double longitude, int maxResults,
String language, String country, String variant, String appName, List<Address> addrs) {
- if (mNetworkLocationInterface != null) {
- return mNetworkLocationInterface.getFromLocation(latitude, longitude, maxResults,
- language, country, variant, appName, addrs);
- } else {
- return null;
+ synchronized (mLocationListeners) {
+ if (mNetworkLocationInterface != null) {
+ return mNetworkLocationInterface.getFromLocation(latitude, longitude, maxResults,
+ language, country, variant, appName, addrs);
+ } else {
+ return null;
+ }
}
}
@@ -1983,12 +2270,14 @@
double lowerLeftLatitude, double lowerLeftLongitude,
double upperRightLatitude, double upperRightLongitude, int maxResults,
String language, String country, String variant, String appName, List<Address> addrs) {
- if (mNetworkLocationInterface != null) {
- return mNetworkLocationInterface.getFromLocationName(locationName, lowerLeftLatitude,
- lowerLeftLongitude, upperRightLatitude, upperRightLongitude, maxResults,
- language, country, variant, appName, addrs);
- } else {
- return null;
+ synchronized (mLocationListeners) {
+ if (mNetworkLocationInterface != null) {
+ return mNetworkLocationInterface.getFromLocationName(locationName, lowerLeftLatitude,
+ lowerLeftLongitude, upperRightLatitude, upperRightLongitude, maxResults,
+ language, country, variant, appName, addrs);
+ } else {
+ return null;
+ }
}
}
@@ -2024,43 +2313,63 @@
@Override
public void disable() {
String name = getName();
- mEnabledProviders.remove(name);
- mDisabledProviders.add(name);
+ // We shouldn't normally need to lock, since this should only be called
+ // by the service with the lock held, but let's be paranid.
+ synchronized (mLocationListeners) {
+ mEnabledProviders.remove(name);
+ mDisabledProviders.add(name);
+ }
}
@Override
public void enable() {
String name = getName();
- mEnabledProviders.add(name);
- mDisabledProviders.remove(name);
+ // We shouldn't normally need to lock, since this should only be called
+ // by the service with the lock held, but let's be paranid.
+ synchronized (mLocationListeners) {
+ mEnabledProviders.add(name);
+ mDisabledProviders.remove(name);
+ }
}
@Override
public boolean getLocation(Location l) {
- Location loc = mMockProviderLocation.get(getName());
- if (loc == null) {
- return false;
+ // We shouldn't normally need to lock, since this should only be called
+ // by the service with the lock held, but let's be paranid.
+ synchronized (mLocationListeners) {
+ Location loc = mMockProviderLocation.get(getName());
+ if (loc == null) {
+ return false;
+ }
+ l.set(loc);
+ return true;
}
- l.set(loc);
- return true;
}
@Override
public int getStatus(Bundle extras) {
- String name = getName();
- Integer s = mMockProviderStatus.get(name);
- int status = (s == null) ? AVAILABLE : s.intValue();
- Bundle newExtras = mMockProviderStatusExtras.get(name);
- if (newExtras != null) {
- extras.clear();
- extras.putAll(newExtras);
+ // We shouldn't normally need to lock, since this should only be called
+ // by the service with the lock held, but let's be paranid.
+ synchronized (mLocationListeners) {
+ String name = getName();
+ Integer s = mMockProviderStatus.get(name);
+ int status = (s == null) ? AVAILABLE : s.intValue();
+ Bundle newExtras = mMockProviderStatusExtras.get(name);
+ if (newExtras != null) {
+ extras.clear();
+ extras.putAll(newExtras);
+ }
+ return status;
}
- return status;
}
@Override
public boolean isEnabled() {
- return mEnabledProviders.contains(getName());
+ // We shouldn't normally need to lock, since this should only be called
+ // by the service with the lock held, but let's be paranid.
+ synchronized (mLocationListeners) {
+ return mEnabledProviders.contains(getName());
+ }
}
@Override
@@ -2109,14 +2418,9 @@
}
}
- private void checkMockPermissions() {
- boolean allowMocks = false;
- try {
- allowMocks = Settings.Secure.getInt(mContext.getContentResolver(),
- Settings.Secure.ALLOW_MOCK_LOCATION) == 1;
- } catch (SettingNotFoundException e) {
- // Do nothing
- }
+ private void checkMockPermissionsSafe() {
+ boolean allowMocks = Settings.Secure.getInt(mContext.getContentResolver(),
+ Settings.Secure.ALLOW_MOCK_LOCATION, 0) == 1;
if (!allowMocks) {
throw new SecurityException("Requires ACCESS_MOCK_LOCATION secure setting");
}
@@ -2130,87 +2434,103 @@
public void addTestProvider(String name, boolean requiresNetwork, boolean requiresSatellite,
boolean requiresCell, boolean hasMonetaryCost, boolean supportsAltitude,
boolean supportsSpeed, boolean supportsBearing, int powerRequirement, int accuracy) {
- checkMockPermissions();
+ checkMockPermissionsSafe();
- MockProvider provider = new MockProvider(name, requiresNetwork, requiresSatellite,
- requiresCell, hasMonetaryCost, supportsAltitude,
- supportsSpeed, supportsBearing, powerRequirement, accuracy);
- if (LocationProviderImpl.getProvider(name) != null) {
- throw new IllegalArgumentException("Provider \"" + name + "\" already exists");
+ synchronized (mLocationListeners) {
+ MockProvider provider = new MockProvider(name, requiresNetwork, requiresSatellite,
+ requiresCell, hasMonetaryCost, supportsAltitude,
+ supportsSpeed, supportsBearing, powerRequirement, accuracy);
+ if (LocationProviderImpl.getProvider(name) != null) {
+ throw new IllegalArgumentException("Provider \"" + name + "\" already exists");
+ }
+ LocationProviderImpl.addProvider(provider);
+ updateProvidersLocked();
}
- LocationProviderImpl.addProvider(provider);
- updateProviders();
}
public void removeTestProvider(String provider) {
- checkMockPermissions();
- LocationProviderImpl p = LocationProviderImpl.getProvider(provider);
- if (p == null) {
- throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ checkMockPermissionsSafe();
+ synchronized (mLocationListeners) {
+ LocationProviderImpl p = LocationProviderImpl.getProvider(provider);
+ if (p == null) {
+ throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ }
+ LocationProviderImpl.removeProvider(p);
+ updateProvidersLocked();
}
- LocationProviderImpl.removeProvider(p);
- updateProviders();
}
public void setTestProviderLocation(String provider, Location loc) {
- checkMockPermissions();
- if (LocationProviderImpl.getProvider(provider) == null) {
- throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ checkMockPermissionsSafe();
+ synchronized (mLocationListeners) {
+ if (LocationProviderImpl.getProvider(provider) == null) {
+ throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ }
+ mMockProviderLocation.put(provider, loc);
}
- mMockProviderLocation.put(provider, loc);
}
public void clearTestProviderLocation(String provider) {
- checkMockPermissions();
- if (LocationProviderImpl.getProvider(provider) == null) {
- throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ checkMockPermissionsSafe();
+ synchronized (mLocationListeners) {
+ if (LocationProviderImpl.getProvider(provider) == null) {
+ throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ }
+ mMockProviderLocation.remove(provider);
}
- mMockProviderLocation.remove(provider);
}
public void setTestProviderEnabled(String provider, boolean enabled) {
- checkMockPermissions();
- if (LocationProviderImpl.getProvider(provider) == null) {
- throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ checkMockPermissionsSafe();
+ synchronized (mLocationListeners) {
+ if (LocationProviderImpl.getProvider(provider) == null) {
+ throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ }
+ if (enabled) {
+ mEnabledProviders.add(provider);
+ mDisabledProviders.remove(provider);
+ } else {
+ mEnabledProviders.remove(provider);
+ mDisabledProviders.add(provider);
+ }
+ updateProvidersLocked();
}
- if (enabled) {
- mEnabledProviders.add(provider);
- mDisabledProviders.remove(provider);
- } else {
- mEnabledProviders.remove(provider);
- mDisabledProviders.add(provider);
- }
- updateProviders();
}
public void clearTestProviderEnabled(String provider) {
- checkMockPermissions();
- if (LocationProviderImpl.getProvider(provider) == null) {
- throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ checkMockPermissionsSafe();
+ synchronized (mLocationListeners) {
+ if (LocationProviderImpl.getProvider(provider) == null) {
+ throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ }
+ mEnabledProviders.remove(provider);
+ mDisabledProviders.remove(provider);
+ updateProvidersLocked();
}
- mEnabledProviders.remove(provider);
- mDisabledProviders.remove(provider);
- updateProviders();
}
public void setTestProviderStatus(String provider, int status, Bundle extras, long updateTime) {
- checkMockPermissions();
- if (LocationProviderImpl.getProvider(provider) == null) {
- throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ checkMockPermissionsSafe();
+ synchronized (mLocationListeners) {
+ if (LocationProviderImpl.getProvider(provider) == null) {
+ throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ }
+ mMockProviderStatus.put(provider, new Integer(status));
+ mMockProviderStatusExtras.put(provider, extras);
+ mMockProviderStatusUpdateTime.put(provider, new Long(updateTime));
}
- mMockProviderStatus.put(provider, new Integer(status));
- mMockProviderStatusExtras.put(provider, extras);
- mMockProviderStatusUpdateTime.put(provider, new Long(updateTime));
}
public void clearTestProviderStatus(String provider) {
- checkMockPermissions();
- if (LocationProviderImpl.getProvider(provider) == null) {
- throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ checkMockPermissionsSafe();
+ synchronized (mLocationListeners) {
+ if (LocationProviderImpl.getProvider(provider) == null) {
+ throw new IllegalArgumentException("Provider \"" + provider + "\" unknown");
+ }
+ mMockProviderStatus.remove(provider);
+ mMockProviderStatusExtras.remove(provider);
+ mMockProviderStatusUpdateTime.remove(provider);
}
- mMockProviderStatus.remove(provider);
- mMockProviderStatusExtras.remove(provider);
- mMockProviderStatusUpdateTime.remove(provider);
}
private void log(String log) {
@@ -2218,5 +2538,154 @@
Log.d(TAG, log);
}
}
+
+ 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 AlarmManager from from pid="
+ + Binder.getCallingPid()
+ + ", uid=" + Binder.getCallingUid());
+ return;
+ }
+
+ synchronized (mLocationListeners) {
+ pw.println("Current Location Manager state:");
+ pw.println(" sProvidersLoaded=" + sProvidersLoaded);
+ pw.println(" mGpsLocationProvider=" + mGpsLocationProvider);
+ pw.println(" mGpsNavigating=" + mGpsNavigating);
+ pw.println(" mNetworkLocationProvider=" + mNetworkLocationProvider);
+ pw.println(" mNetworkLocationInterface=" + mNetworkLocationInterface);
+ pw.println(" mCollector=" + mCollector);
+ pw.println(" mSignalStrength=" + mSignalStrength);
+ pw.println(" mAlarmInterval=" + mAlarmInterval
+ + " mScreenOn=" + mScreenOn
+ + " mWakeLockAcquireTime=" + mWakeLockAcquireTime);
+ pw.println(" mWakeLockGpsReceived=" + mWakeLockGpsReceived
+ + " mWakeLockNetworkReceived=" + mWakeLockNetworkReceived);
+ pw.println(" mWifiWakeLockAcquired=" + mWifiWakeLockAcquired
+ + " mCellWakeLockAcquired=" + mCellWakeLockAcquired);
+ pw.println(" Listeners:");
+ int N = mListeners.size();
+ for (int i=0; i<N; i++) {
+ pw.println(" " + mListeners.get(i));
+ }
+ pw.println(" Location Listeners:");
+ for (Map.Entry<Receiver, HashMap<String,UpdateRecord>> i
+ : mLocationListeners.entrySet()) {
+ pw.println(" " + i.getKey() + ":");
+ for (Map.Entry<String,UpdateRecord> j : i.getValue().entrySet()) {
+ pw.println(" " + j.getKey() + ":");
+ j.getValue().dump(pw, " ");
+ }
+ }
+ pw.println(" Last Fix Broadcasts:");
+ for (Map.Entry<Receiver, HashMap<String,Location>> i
+ : mLastFixBroadcast.entrySet()) {
+ pw.println(" " + i.getKey() + ":");
+ for (Map.Entry<String,Location> j : i.getValue().entrySet()) {
+ pw.println(" " + j.getKey() + ":");
+ j.getValue().dump(new PrintWriterPrinter(pw), " ");
+ }
+ }
+ pw.println(" Last Status Broadcasts:");
+ for (Map.Entry<Receiver, HashMap<String,Long>> i
+ : mLastStatusBroadcast.entrySet()) {
+ pw.println(" " + i.getKey() + ":");
+ for (Map.Entry<String,Long> j : i.getValue().entrySet()) {
+ pw.println(" " + j.getKey() + " -> 0x"
+ + Long.toHexString(j.getValue()));
+ }
+ }
+ pw.println(" Records by Provider:");
+ for (Map.Entry<String, ArrayList<UpdateRecord>> i
+ : mRecordsByProvider.entrySet()) {
+ pw.println(" " + i.getKey() + ":");
+ for (UpdateRecord j : i.getValue()) {
+ pw.println(" " + j + ":");
+ j.dump(pw, " ");
+ }
+ }
+ pw.println(" Locations by Provider:");
+ for (Map.Entry<String, Location> i
+ : mLocationsByProvider.entrySet()) {
+ pw.println(" " + i.getKey() + ":");
+ i.getValue().dump(new PrintWriterPrinter(pw), " ");
+ }
+ pw.println(" Last Known Locations:");
+ for (Map.Entry<String, Location> i
+ : mLastKnownLocation.entrySet()) {
+ pw.println(" " + i.getKey() + ":");
+ i.getValue().dump(new PrintWriterPrinter(pw), " ");
+ }
+ if (mProximityAlerts.size() > 0) {
+ pw.println(" Proximity Alerts:");
+ for (Map.Entry<PendingIntent, ProximityAlert> i
+ : mProximityAlerts.entrySet()) {
+ pw.println(" " + i.getKey() + ":");
+ i.getValue().dump(pw, " ");
+ }
+ }
+ if (mProximitiesEntered.size() > 0) {
+ pw.println(" Proximities Entered:");
+ for (ProximityAlert i : mProximitiesEntered) {
+ pw.println(" " + i + ":");
+ i.dump(pw, " ");
+ }
+ }
+ pw.println(" mProximityListener=" + mProximityListener);
+ if (mEnabledProviders.size() > 0) {
+ pw.println(" Enabled Providers:");
+ for (String i : mEnabledProviders) {
+ pw.println(" " + i);
+ }
+
+ }
+ if (mDisabledProviders.size() > 0) {
+ pw.println(" Disabled Providers:");
+ for (String i : mDisabledProviders) {
+ pw.println(" " + i);
+ }
+
+ }
+ if (mMockProviders.size() > 0) {
+ pw.println(" Mock Providers:");
+ for (Map.Entry<String, MockProvider> i : mMockProviders.entrySet()) {
+ pw.println(" " + i.getKey() + " -> " + i.getValue());
+ }
+ }
+ if (mMockProviderLocation.size() > 0) {
+ pw.println(" Mock Provider Location:");
+ for (Map.Entry<String, Location> i : mMockProviderLocation.entrySet()) {
+ pw.println(" " + i.getKey() + ":");
+ i.getValue().dump(new PrintWriterPrinter(pw), " ");
+ }
+ }
+ if (mMockProviderStatus.size() > 0) {
+ pw.println(" Mock Provider Status:");
+ for (Map.Entry<String, Integer> i : mMockProviderStatus.entrySet()) {
+ pw.println(" " + i.getKey() + " -> 0x"
+ + Integer.toHexString(i.getValue()));
+ }
+ }
+ if (mMockProviderStatusExtras.size() > 0) {
+ pw.println(" Mock Provider Status Extras:");
+ for (Map.Entry<String, Bundle> i : mMockProviderStatusExtras.entrySet()) {
+ pw.println(" " + i.getKey() + " -> " + i.getValue());
+ }
+ }
+ if (mMockProviderStatusUpdateTime.size() > 0) {
+ pw.println(" Mock Provider Status Update Time:");
+ for (Map.Entry<String, Long> i : mMockProviderStatusUpdateTime.entrySet()) {
+ pw.println(" " + i.getKey() + " -> " + i.getValue());
+ }
+ }
+ pw.println(" Reported GPS UIDs @ seq " + mReportedGpsSeq + ":");
+ N = mReportedGpsUids.size();
+ for (int i=0; i<N; i++) {
+ pw.println(" UID " + mReportedGpsUids.keyAt(i)
+ + " seq=" + mReportedGpsUids.valueAt(i));
+ }
+ }
+ }
}
diff --git a/services/java/com/android/server/PowerManagerService.java b/services/java/com/android/server/PowerManagerService.java
index 6974b5e..16b5819 100644
--- a/services/java/com/android/server/PowerManagerService.java
+++ b/services/java/com/android/server/PowerManagerService.java
@@ -182,6 +182,7 @@
private long mScreenOnTime;
private long mScreenOnStartTime;
private boolean mPreventScreenOn;
+ private int mScreenBrightnessOverride = -1;
// Used when logging number and duration of touch-down cycles
private long mTotalTouchDownTime;
@@ -245,7 +246,8 @@
public void acquire() {
if (!mRefCounted || mCount++ == 0) {
- PowerManagerService.this.acquireWakeLockLocked(mFlags, mToken, mTag);
+ PowerManagerService.this.acquireWakeLockLocked(mFlags, mToken,
+ MY_UID, mTag);
}
}
@@ -486,17 +488,18 @@
public void acquireWakeLock(int flags, IBinder lock, String tag) {
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null);
+ int uid = Binder.getCallingUid();
long ident = Binder.clearCallingIdentity();
try {
synchronized (mLocks) {
- acquireWakeLockLocked(flags, lock, tag);
+ acquireWakeLockLocked(flags, lock, uid, tag);
}
} finally {
Binder.restoreCallingIdentity(ident);
}
}
- public void acquireWakeLockLocked(int flags, IBinder lock, String tag) {
+ public void acquireWakeLockLocked(int flags, IBinder lock, int uid, String tag) {
int acquireUid = -1;
String acquireName = null;
int acquireType = -1;
@@ -509,7 +512,7 @@
WakeLock wl;
boolean newlock;
if (index < 0) {
- wl = new WakeLock(flags, lock, tag, Binder.getCallingUid());
+ wl = new WakeLock(flags, lock, tag, uid);
switch (wl.flags & LOCK_MASK)
{
case PowerManager.FULL_WAKE_LOCK:
@@ -577,13 +580,10 @@
}
if (acquireType >= 0) {
- long origId = Binder.clearCallingIdentity();
try {
mBatteryStats.noteStartWakelock(acquireUid, acquireName, acquireType);
} catch (RemoteException e) {
// Ignore
- } finally {
- Binder.restoreCallingIdentity(origId);
}
}
}
@@ -797,6 +797,8 @@
+ " mUserActivityAllowed=" + mUserActivityAllowed);
pw.println(" mKeylightDelay=" + mKeylightDelay + " mDimDelay=" + mDimDelay
+ " mScreenOffDelay=" + mScreenOffDelay);
+ pw.println(" mPreventScreenOn=" + mPreventScreenOn
+ + " mScreenBrightnessOverride=" + mScreenBrightnessOverride);
pw.println(" mTotalDelaySetting=" + mTotalDelaySetting);
pw.println(" mBroadcastWakeLock=" + mBroadcastWakeLock);
pw.println(" mStayOnWhilePluggedInScreenDimLock=" + mStayOnWhilePluggedInScreenDimLock);
@@ -1077,7 +1079,6 @@
* lock (rather than an IPowerManager call).
*/
public void preventScreenOn(boolean prevent) {
- // TODO: use a totally new permission (separate from DEVICE_POWER) for this?
mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null);
synchronized (mLocks) {
@@ -1126,6 +1127,17 @@
}
}
+ public void setScreenBrightnessOverride(int brightness) {
+ mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null);
+
+ synchronized (mLocks) {
+ if (mScreenBrightnessOverride != brightness) {
+ mScreenBrightnessOverride = brightness;
+ updateLightsLocked(mPowerState, SCREEN_ON_BIT);
+ }
+ }
+ }
+
/**
* Sanity-check that gets called 5 seconds after any call to
* preventScreenOn(true). This ensures that the original call
@@ -1211,7 +1223,7 @@
}
if (mPowerState != newState) {
- err = updateLightsLocked(newState, becauseOfUser);
+ err = updateLightsLocked(newState, 0);
if (err != 0) {
return;
}
@@ -1294,6 +1306,15 @@
mScreenOnTime += SystemClock.elapsedRealtime() - mScreenOnStartTime;
mScreenOnStartTime = 0;
if (err == 0) {
+ //
+ // FIXME(joeo)
+ //
+ // The problem that causes the screen not to come on is that this isn't
+ // called until after the animation is done. It needs to be set right
+ // away, and the anmiation's state needs to be recorded separately.
+ //
+ //
+
mPowerState &= ~SCREEN_ON_BIT;
int why = becauseOfUser
? WindowManagerPolicy.OFF_BECAUSE_OF_USER
@@ -1310,9 +1331,9 @@
mBatteryService.getBatteryLevel() <= Power.LOW_BATTERY_THRESHOLD);
}
- private int updateLightsLocked(int newState, boolean becauseOfUser) {
+ private int updateLightsLocked(int newState, int forceState) {
int oldState = mPowerState;
- int difference = newState ^ oldState;
+ int difference = (newState ^ oldState) | forceState;
if (difference == 0) {
return 0;
}
@@ -1544,6 +1565,9 @@
private int getPreferredBrightness() {
try {
+ if (mScreenBrightnessOverride >= 0) {
+ return mScreenBrightnessOverride;
+ }
final int brightness = Settings.System.getInt(mContext.getContentResolver(),
SCREEN_BRIGHTNESS);
// Don't let applications turn the screen all the way off
diff --git a/services/java/com/android/server/SensorService.java b/services/java/com/android/server/SensorService.java
index 461b006..29b45ab 100644
--- a/services/java/com/android/server/SensorService.java
+++ b/services/java/com/android/server/SensorService.java
@@ -113,9 +113,9 @@
int uid = Binder.getCallingUid();
long identity = Binder.clearCallingIdentity();
if (enable == SENSOR_DISABLE) {
- mBatteryStats.noteStopSensor(uid, name, sensor);
+ mBatteryStats.noteStopSensor(uid, sensor);
} else {
- mBatteryStats.noteStartSensor(uid, name, sensor);
+ mBatteryStats.noteStartSensor(uid, sensor);
}
Binder.restoreCallingIdentity(identity);
diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java
index d624573..fc25e38 100644
--- a/services/java/com/android/server/SystemServer.java
+++ b/services/java/com/android/server/SystemServer.java
@@ -181,6 +181,7 @@
StatusBarService statusBar = null;
InputMethodManagerService imm = null;
+ GadgetService gadget = null;
if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
try {
@@ -309,7 +310,8 @@
try {
Log.i(TAG, "Starting Gadget Service");
- ServiceManager.addService(Context.GADGET_SERVICE, new GadgetService(context));
+ gadget = new GadgetService(context);
+ ServiceManager.addService(Context.GADGET_SERVICE, gadget);
} catch (Throwable e) {
Log.e(TAG, "Failure starting Gadget Service", e);
}
@@ -337,6 +339,9 @@
pm.systemReady();
} catch (RemoteException e) {
}
+ if (gadget != null) {
+ gadget.systemReady(safeMode);
+ }
// After making the following code, third party code may be running...
try {
diff --git a/services/java/com/android/server/WindowManagerService.java b/services/java/com/android/server/WindowManagerService.java
index fed6d12..fc22bad 100644
--- a/services/java/com/android/server/WindowManagerService.java
+++ b/services/java/com/android/server/WindowManagerService.java
@@ -66,6 +66,7 @@
import android.os.Message;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
+import android.os.Power;
import android.os.PowerManager;
import android.os.Process;
import android.os.RemoteException;
@@ -326,6 +327,11 @@
long mFreezeGcPending = 0;
int mAppsFreezingScreen = 0;
+ // This is held as long as we have the screen frozen, to give us time to
+ // perform a rotation animation when turning off shows the lock screen which
+ // changes the orientation.
+ PowerManager.WakeLock mScreenFrozenLock;
+
// State management of app transitions. When we are preparing for a
// transition, mNextAppTransition will be the kind of transition to
// perform or TRANSIT_NONE if we are not waiting. If we are waiting,
@@ -351,6 +357,7 @@
// This just indicates the window the input method is on top of, not
// necessarily the window its input is going to.
WindowState mInputMethodTarget = null;
+ WindowState mUpcomingInputMethodTarget = null;
boolean mInputMethodTargetWaitingAnim;
int mInputMethodAnimLayerAdjustment;
@@ -472,6 +479,10 @@
mPowerManager = pm;
mPowerManager.setPolicy(mPolicy);
+ PowerManager pmc = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
+ mScreenFrozenLock = pmc.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
+ "SCREEN_FROZEN");
+ mScreenFrozenLock.setReferenceCounted(false);
mActivityManager = ActivityManagerNative.getDefault();
mBatteryStats = BatteryStatsService.getService();
@@ -742,6 +753,15 @@
}
}
+ static boolean canBeImeTarget(WindowState w) {
+ final int fl = w.mAttrs.flags
+ & (FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM);
+ if (fl == 0 || fl == (FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM)) {
+ return w.isVisibleOrAdding();
+ }
+ return false;
+ }
+
int findDesiredInputMethodWindowIndexLocked(boolean willMove) {
final ArrayList localmWindows = mWindows;
final int N = localmWindows.size();
@@ -750,18 +770,32 @@
while (i > 0) {
i--;
w = (WindowState)localmWindows.get(i);
- final int fl = w.mAttrs.flags
- & (FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM);
+
//Log.i(TAG, "Checking window @" + i + " " + w + " fl=0x"
- // + Integer.toHexString(fl));
- if (fl == 0 || fl == (FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM)) {
+ // + Integer.toHexString(w.mAttrs.flags));
+ if (canBeImeTarget(w)) {
//Log.i(TAG, "Putting input method here!");
- if (w.isVisibleOrAdding()) {
- break;
+
+ // Yet more tricksyness! If this window is a "starting"
+ // window, we do actually want to be on top of it, but
+ // it is not -really- where input will go. So if the caller
+ // is not actually looking to move the IME, look down below
+ // for a real window to target...
+ if (!willMove
+ && w.mAttrs.type == WindowManager.LayoutParams.TYPE_APPLICATION_STARTING
+ && i > 0) {
+ WindowState wb = (WindowState)localmWindows.get(i-1);
+ if (wb.mAppToken == w.mAppToken && canBeImeTarget(wb)) {
+ i--;
+ w = wb;
+ }
}
+ break;
}
}
+ mUpcomingInputMethodTarget = w;
+
if (DEBUG_INPUT_METHOD) Log.v(TAG, "Desired input method target="
+ w + " willMove=" + willMove);
@@ -1209,8 +1243,6 @@
addWindowToListInOrderLocked(win, true);
}
- Binder.restoreCallingIdentity(origId);
-
win.mEnterAnimationPending = true;
mPolicy.getContentInsetHintLw(attrs, outContentInsets);
@@ -1542,6 +1574,11 @@
&& !win.mCommitDrawPending && !mDisplayFrozen) {
applyEnterAnimationLocked(win);
}
+ if ((attrChanges&WindowManager.LayoutParams.FORMAT_CHANGED) != 0) {
+ // To change the format, we need to re-build the surface.
+ win.destroySurfaceLocked();
+ displayed = true;
+ }
try {
Surface surface = win.createSurfaceLocked();
if (surface != null) {
@@ -7169,11 +7206,14 @@
// The focus for the client is the window immediately below
// where we would place the input method window.
int idx = findDesiredInputMethodWindowIndexLocked(false);
+ WindowState imFocus;
if (idx > 0) {
- WindowState imFocus = (WindowState)mWindows.get(idx-1);
- if (imFocus != null && imFocus.mSession.mClient != null &&
- imFocus.mSession.mClient.asBinder() == client.asBinder()) {
- return true;
+ imFocus = (WindowState)mWindows.get(idx-1);
+ if (imFocus != null) {
+ if (imFocus.mSession.mClient != null &&
+ imFocus.mSession.mClient.asBinder() == client.asBinder()) {
+ return true;
+ }
}
}
}
@@ -7393,6 +7433,7 @@
boolean orientationChangeComplete = true;
Session holdScreen = null;
+ float screenBrightness = -1;
boolean focusDisplayed = false;
boolean animating = false;
@@ -7622,7 +7663,6 @@
boolean blurring = false;
boolean dimming = false;
boolean covered = false;
- int tint = 0;
for (i=N-1; i>=0; i--) {
WindowState w = (WindowState)mWindows.get(i);
@@ -7878,9 +7918,13 @@
// Update effect.
if (!obscured) {
- if (w.mSurface != null &&
- (attrFlags&FLAG_KEEP_SCREEN_ON) != 0) {
- holdScreen = w.mSession;
+ if (w.mSurface != null) {
+ if ((attrFlags&FLAG_KEEP_SCREEN_ON) != 0) {
+ holdScreen = w.mSession;
+ }
+ if (w.mAttrs.screenBrightness >= 0 && screenBrightness < 0) {
+ screenBrightness = w.mAttrs.screenBrightness;
+ }
}
if (w.isFullscreenOpaque(dw, dh)) {
// This window completely covers everything behind it,
@@ -8122,6 +8166,12 @@
requestAnimationLocked(currentTime+(1000/60)-SystemClock.uptimeMillis());
}
mQueue.setHoldScreenLocked(holdScreen != null);
+ if (screenBrightness < 0 || screenBrightness > 1.0f) {
+ mPowerManager.setScreenBrightnessOverride(-1);
+ } else {
+ mPowerManager.setScreenBrightnessOverride((int)
+ (screenBrightness * Power.BRIGHTNESS_ON));
+ }
if (holdScreen != mHoldingScreenOn) {
mHoldingScreenOn = holdScreen;
Message m = mH.obtainMessage(H.HOLD_SCREEN_CHANGED, holdScreen);
@@ -8354,6 +8404,8 @@
return;
}
+ mScreenFrozenLock.acquire();
+
long now = SystemClock.uptimeMillis();
//Log.i(TAG, "Freezing, gc pending: " + mFreezeGcPending + ", now " + now);
if (mFreezeGcPending != 0) {
@@ -8409,6 +8461,8 @@
mH.removeMessages(H.FORCE_GC);
mH.sendMessageDelayed(mH.obtainMessage(H.FORCE_GC),
2000);
+
+ mScreenFrozenLock.release();
}
@Override
diff --git a/services/java/com/android/server/am/ActivityManagerService.java b/services/java/com/android/server/am/ActivityManagerService.java
index e391da3..6443d53 100644
--- a/services/java/com/android/server/am/ActivityManagerService.java
+++ b/services/java/com/android/server/am/ActivityManagerService.java
@@ -204,6 +204,10 @@
*/
static final int LAUNCH_TIMEOUT = 10*1000;
+ // How long we wait for a launched process to attach to the activity manager
+ // before we decide it's never going to come up for real.
+ static final int PROC_START_TIMEOUT = 10*1000;
+
// How long we wait until giving up on the last activity telling us it
// is idle.
static final int IDLE_TIMEOUT = 10*1000;
@@ -811,6 +815,7 @@
static final int DESTROY_TIMEOUT_MSG = 17;
static final int SERVICE_ERROR_MSG = 18;
static final int RESUME_TOP_ACTIVITY_MSG = 19;
+ static final int PROC_START_TIMEOUT_MSG = 20;
AlertDialog mUidAlert;
@@ -852,12 +857,8 @@
}
} break;
case SHOW_NOT_RESPONDING_MSG: {
- HashMap data = (HashMap) msg.obj;
- // This needs to be *un*synchronized to avoid deadlock.
- Checkin.logEvent(mContext.getContentResolver(),
- Checkin.Events.Tag.SYSTEM_APP_NOT_RESPONDING,
- (String)data.get("info"));
synchronized (ActivityManagerService.this) {
+ HashMap data = (HashMap) msg.obj;
ProcessRecord proc = (ProcessRecord)data.get("app");
if (proc != null && proc.anrDialog != null) {
Log.e(TAG, "App already has anr dialog: " + proc);
@@ -993,6 +994,12 @@
resumeTopActivityLocked(null);
}
}
+ case PROC_START_TIMEOUT_MSG: {
+ ProcessRecord app = (ProcessRecord)msg.obj;
+ synchronized (ActivityManagerService.this) {
+ processStartTimedOutLocked(app);
+ }
+ }
}
}
};
@@ -1685,6 +1692,7 @@
if (app.pid > 0 && app.pid != MY_PID) {
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.remove(app.pid);
+ mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
}
app.pid = 0;
}
@@ -1777,6 +1785,9 @@
app.removed = false;
synchronized (mPidsSelfLocked) {
this.mPidsSelfLocked.put(pid, app);
+ Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG);
+ msg.obj = app;
+ mHandler.sendMessageDelayed(msg, PROC_START_TIMEOUT);
}
} else {
app.pid = 0;
@@ -4033,9 +4044,6 @@
info.append("\nCPU usage:\n");
info.append(processInfo);
}
- info.append("\n/proc/meminfo:\n");
- info.append(readFile("/proc/meminfo"));
-
Log.i(TAG, info.toString());
// The application is not responding. Dump as many thread traces as we can.
@@ -4087,7 +4095,6 @@
msg.what = SHOW_NOT_RESPONDING_MSG;
msg.obj = map;
map.put("app", app);
- map.put("info", info.toString());
if (activity != null) {
map.put("activity", activity);
}
@@ -4390,6 +4397,7 @@
int pid = app.pid;
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.remove(pid);
+ mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
}
handleAppDiedLocked(app, true);
mLRUProcesses.remove(app);
@@ -4409,6 +4417,31 @@
return needRestart;
}
+ private final void processStartTimedOutLocked(ProcessRecord app) {
+ final int pid = app.pid;
+ boolean gone = false;
+ synchronized (mPidsSelfLocked) {
+ ProcessRecord knownApp = mPidsSelfLocked.get(pid);
+ if (knownApp != null && knownApp.thread == null) {
+ mPidsSelfLocked.remove(pid);
+ gone = true;
+ }
+ }
+
+ if (gone) {
+ Log.w(TAG, "Process " + app + " failed to attach");
+ mProcessNames.remove(app.processName, app.info.uid);
+ Process.killProcess(pid);
+ if (mPendingBroadcast.curApp.pid == pid) {
+ Log.w(TAG, "Unattached app died before broadcast acknowledged, skipping");
+ mPendingBroadcast = null;
+ scheduleBroadcastsLocked();
+ }
+ } else {
+ Log.w(TAG, "Spurious process start timeout - pid not known for " + app);
+ }
+ }
+
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
@@ -4472,6 +4505,8 @@
app.foregroundServices = false;
app.debugging = false;
+ mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
+
List providers = generateApplicationProvidersLocked(app);
if (localLOGV) Log.v(
@@ -8630,6 +8665,7 @@
// Goodbye!
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.remove(app.pid);
+ mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
}
app.pid = 0;
}
diff --git a/services/java/com/android/server/am/BatteryStatsService.java b/services/java/com/android/server/am/BatteryStatsService.java
index 1cd6298..9ba1198 100644
--- a/services/java/com/android/server/am/BatteryStatsService.java
+++ b/services/java/com/android/server/am/BatteryStatsService.java
@@ -22,8 +22,10 @@
import android.content.Context;
import android.os.Binder;
import android.os.IBinder;
+import android.os.Parcel;
import android.os.Process;
import android.os.ServiceManager;
+import android.util.PrintWriterPrinter;
import java.io.FileDescriptor;
import java.io.PrintWriter;
@@ -58,16 +60,25 @@
/**
* @return the current statistics object, which may be modified
- * to reflect events that affect battery usage.
+ * to reflect events that affect battery usage. You must lock the
+ * stats object before doing anything with it.
*/
public BatteryStatsImpl getActiveStatistics() {
return mStats;
}
- public BatteryStatsImpl getStatistics() {
+ public byte[] getStatistics() {
mContext.enforceCallingPermission(
android.Manifest.permission.BATTERY_STATS, null);
- return mStats;
+ synchronized (mStats) {
+ //Log.i("foo", "SENDING BATTERY INFO:");
+ //mStats.dumpLocked(new LogPrinter(Log.INFO, "foo"));
+ Parcel out = Parcel.obtain();
+ mStats.writeToParcel(out, 0);
+ byte[] data = out.marshall();
+ out.recycle();
+ return data;
+ }
}
public void noteStartWakelock(int uid, String name, int type) {
@@ -84,17 +95,17 @@
}
}
- public void noteStartSensor(int uid, String name, int sensor) {
+ public void noteStartSensor(int uid, int sensor) {
enforceCallingPermission();
synchronized (mStats) {
- mStats.getUidStatsLocked(uid).noteStartSensor(name, sensor);
+ mStats.getUidStatsLocked(uid).noteStartSensor(sensor);
}
}
- public void noteStopSensor(int uid, String name, int sensor) {
+ public void noteStopSensor(int uid, int sensor) {
enforceCallingPermission();
synchronized (mStats) {
- mStats.getUidStatsLocked(uid).noteStopSensor(name, sensor);
+ mStats.getUidStatsLocked(uid).noteStopSensor(sensor);
}
}
@@ -111,32 +122,18 @@
mStats.noteStopGps(uid);
}
}
-
- public void noteRequestGpsOn(int uid) {
- enforceCallingPermission();
- synchronized (mStats) {
- mStats.noteRequestGpsOn(uid);
- }
- }
-
- public void noteRequestGpsOff(int uid) {
- enforceCallingPermission();
- synchronized (mStats) {
- mStats.noteRequestGpsOff(uid);
- }
- }
-
+
public void noteScreenOn() {
enforceCallingPermission();
synchronized (mStats) {
- mStats.noteScreenOn();
+ mStats.noteScreenOnLocked();
}
}
public void noteScreenOff() {
enforceCallingPermission();
synchronized (mStats) {
- mStats.noteScreenOff();
+ mStats.noteScreenOffLocked();
}
}
@@ -171,8 +168,18 @@
@Override
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
- synchronized (this) {
- mStats.dumpLocked(fd, pw, args);
+ synchronized (mStats) {
+ boolean isCheckin = false;
+ if (args != null) {
+ for (String arg : args) {
+ if ("-c".equals(arg)) {
+ isCheckin = true;
+ break;
+ }
+ }
+ }
+ if (isCheckin) mStats.dumpCheckinLocked(pw, args);
+ else mStats.dumpLocked(new PrintWriterPrinter(pw));
}
}
}
diff --git a/services/java/com/android/server/status/AnimatedImageView.java b/services/java/com/android/server/status/AnimatedImageView.java
index 36492da..cd581c4 100644
--- a/services/java/com/android/server/status/AnimatedImageView.java
+++ b/services/java/com/android/server/status/AnimatedImageView.java
@@ -42,6 +42,7 @@
}
@Override
+ @android.view.RemotableViewMethod
public void setImageResource(int resid) {
super.setImageResource(resid);
updateAnim();
diff --git a/services/java/com/android/server/status/StatusBarService.java b/services/java/com/android/server/status/StatusBarService.java
index a4844b1..4748389 100644
--- a/services/java/com/android/server/status/StatusBarService.java
+++ b/services/java/com/android/server/status/StatusBarService.java
@@ -27,6 +27,7 @@
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;
@@ -1326,80 +1327,89 @@
}
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("mExpanded=" + mExpanded
+ pw.println("Current Status Bar state:");
+ pw.println(" mExpanded=" + mExpanded
+ ", mExpandedVisible=" + mExpandedVisible);
- pw.println("mTicking=" + mTicking);
- pw.println("mTracking=" + mTracking);
- pw.println("mAnimating=" + mAnimating
+ pw.println(" mTicking=" + mTicking);
+ pw.println(" mTracking=" + mTracking);
+ pw.println(" mAnimating=" + mAnimating
+ ", mAnimY=" + mAnimY + ", mAnimVel=" + mAnimVel
+ ", mAnimAccel=" + mAnimAccel);
- pw.println("mCurAnimationTime=" + mCurAnimationTime
+ pw.println(" mCurAnimationTime=" + mCurAnimationTime
+ " mAnimLastTime=" + mAnimLastTime);
- pw.println("mDisplayHeight=" + mDisplayHeight
+ pw.println(" mDisplayHeight=" + mDisplayHeight
+ " mAnimatingReveal=" + mAnimatingReveal
+ " mViewDelta=" + mViewDelta);
- pw.println("mDisplayHeight=" + mDisplayHeight);
+ pw.println(" mDisplayHeight=" + mDisplayHeight);
final int N = mQueue.size();
- pw.println("mQueue.size=" + N);
+ pw.println(" mQueue.size=" + N);
for (int i=0; i<N; i++) {
PendingOp op = mQueue.get(i);
- pw.println(" [" + i + "] key=" + op.key + " code=" + op.code + " visible="
+ pw.println(" [" + i + "] key=" + op.key + " code=" + op.code + " visible="
+ op.visible);
- pw.println(" iconData=" + op.iconData);
- pw.println(" notificationData=" + op.notificationData);
+ pw.println(" iconData=" + op.iconData);
+ pw.println(" notificationData=" + op.notificationData);
}
- pw.println("mExpandedParams: " + mExpandedParams);
- pw.println("mExpandedView: " + viewInfo(mExpandedView));
- pw.println("mExpandedDialog: " + mExpandedDialog);
- pw.println("mTrackingParams: " + mTrackingParams);
- pw.println("mTrackingView: " + viewInfo(mTrackingView));
- pw.println("mOngoingTitle: " + viewInfo(mOngoingTitle));
- pw.println("mOngoingItems: " + viewInfo(mOngoingItems));
- pw.println("mLatestTitle: " + viewInfo(mLatestTitle));
- pw.println("mLatestItems: " + viewInfo(mLatestItems));
- pw.println("mNoNotificationsTitle: " + viewInfo(mNoNotificationsTitle));
- pw.println("mCloseView: " + viewInfo(mCloseView));
- pw.println("mTickerView: " + viewInfo(mTickerView));
- pw.println("mScrollView: " + viewInfo(mScrollView)
+ pw.println(" mExpandedParams: " + mExpandedParams);
+ pw.println(" mExpandedView: " + viewInfo(mExpandedView));
+ pw.println(" mExpandedDialog: " + mExpandedDialog);
+ pw.println(" mTrackingParams: " + mTrackingParams);
+ pw.println(" mTrackingView: " + viewInfo(mTrackingView));
+ pw.println(" mOngoingTitle: " + viewInfo(mOngoingTitle));
+ pw.println(" mOngoingItems: " + viewInfo(mOngoingItems));
+ pw.println(" mLatestTitle: " + viewInfo(mLatestTitle));
+ pw.println(" mLatestItems: " + viewInfo(mLatestItems));
+ pw.println(" mNoNotificationsTitle: " + viewInfo(mNoNotificationsTitle));
+ pw.println(" mCloseView: " + viewInfo(mCloseView));
+ pw.println(" mTickerView: " + viewInfo(mTickerView));
+ pw.println(" mScrollView: " + viewInfo(mScrollView)
+ " scroll " + mScrollView.getScrollX() + "," + mScrollView.getScrollY());
pw.println("mNotificationLinearLayout: " + viewInfo(mNotificationLinearLayout));
}
synchronized (mIconMap) {
final int N = mIconMap.size();
- pw.println("mIconMap.size=" + N);
+ pw.println(" mIconMap.size=" + N);
Set<IBinder> keys = mIconMap.keySet();
int i=0;
for (IBinder key: keys) {
StatusBarIcon icon = mIconMap.get(key);
- pw.println(" [" + i + "] key=" + key);
- pw.println(" data=" + icon.mData);
+ pw.println(" [" + i + "] key=" + key);
+ pw.println(" data=" + icon.mData);
i++;
}
}
synchronized (mNotificationData) {
int N = mNotificationData.ongoingCount();
- pw.println("ongoingCount.size=" + N);
+ pw.println(" ongoingCount.size=" + N);
for (int i=0; i<N; i++) {
StatusBarNotification n = mNotificationData.getOngoing(i);
- pw.println(" [" + i + "] key=" + n.key + " view=" + n.view);
- pw.println(" data=" + n.data);
+ pw.println(" [" + i + "] key=" + n.key + " view=" + n.view);
+ pw.println(" data=" + n.data);
}
N = mNotificationData.latestCount();
- pw.println("ongoingCount.size=" + N);
+ pw.println(" ongoingCount.size=" + N);
for (int i=0; i<N; i++) {
StatusBarNotification n = mNotificationData.getLatest(i);
- pw.println(" [" + i + "] key=" + n.key + " view=" + n.view);
- pw.println(" data=" + n.data);
+ pw.println(" [" + i + "] key=" + n.key + " view=" + n.view);
+ pw.println(" data=" + n.data);
}
}
synchronized (mDisableRecords) {
final int N = mDisableRecords.size();
- pw.println("mDisableRecords.size=" + N
+ pw.println(" mDisableRecords.size=" + N
+ " mDisabled=0x" + Integer.toHexString(mDisabled));
for (int i=0; i<N; i++) {
DisableRecord tok = mDisableRecords.get(i);
- pw.println(" [" + i + "] what=0x" + Integer.toHexString(tok.what)
+ pw.println(" [" + i + "] what=0x" + Integer.toHexString(tok.what)
+ " pkg=" + tok.pkg + " token=" + tok.token);
}
}