Wake lock in LocationManagerService

Problem:

On my Android device, I met a problem that system can't suspend after a long time after user has turn off screen by pressing the power key.

From "dumpsys power" command output, I found the following info.

Sleep timeout: -1 ms
Screen off timeout: 30000 ms
Screen dim duration: 6000 ms

Wake Locks: size=2
  PARTIAL_WAKE_LOCK              'LocationManagerService' (uid=1000, pid=658, ws=WorkSource{32071 com.android.launcher})
  PARTIAL_WAKE_LOCK              'LocationManagerService' (uid=1000, pid=658, ws=WorkSource{32071 com.android.launcher})

Suspend Blockers: size=4
  PowerManagerService.WakeLocks: ref count=1
  PowerManagerService.Display: ref count=0
  PowerManagerService.Broadcasts: ref count=0
  PowerManagerService.WirelessChargerDetector: ref count=0

Display Power: state=OFF

From the power dump info, we can see that PARTIAL_WAKE_LOCK was acquired twice by com.android.launcher.

In normal case, this wake lock is used only for ILocationListener callback. and should not hold the lock for long time.

But in my case, com.android.launcher keep holding the wake lock and don't release it.

Analysis:

User can use LocationManager.requestLocationUpdates method to register a listener to listen to location changes.

The registration is implemented in LocationManagerService.

Callback functions in listener will be called if the interesting events (location changes, status changes, provider changes....) happen.

LMS follow the below steps to execute the callback function.

1. In LocationManagerService, send a message to the message queue in app's (the app has register listener to LocationManagerService) thread.

2. In LocationManagerService, acquire wake lock. Code is as follows.

        public boolean callLocationChangedLocked(Location location) {
            if (mListener != null) {
                try {
                    synchronized (this) {
                        // synchronize to ensure incrementPendingBroadcastsLocked()
                        // is called before decrementPendingBroadcasts()
                        mListener.onLocationChanged(new Location(location));
                        // call this after broadcasting so we do not increment
                        // if we throw an exeption.
                        incrementPendingBroadcastsLocked();
                    }
                } catch (RemoteException e) {
                    return false;
                }
            } else {
                Intent locationChanged = new Intent();
                locationChanged.putExtra(LocationManager.KEY_LOCATION_CHANGED, new Location(location));
                try {
                    synchronized (this) {
                        // synchronize to ensure incrementPendingBroadcastsLocked()
                        // is called before decrementPendingBroadcasts()
                        mPendingIntent.send(mContext, 0, locationChanged, this, mLocationHandler,
                                getResolutionPermission(mAllowedResolutionLevel));
                        // call this after broadcasting so we do not increment
                        // if we throw an exeption.
                        incrementPendingBroadcastsLocked();
                    }
                } catch (PendingIntent.CanceledException e) {
                    return false;
                }
            }
            return true;
        }

Call stack:

W/System.err(  652): java.lang.Exception
W/System.err(  652):     at com.android.server.LocationManagerService$Receiver.incrementPendingBroadcastsLocked(LocationManagerService.java:915)
W/System.err(  652):     at com.android.server.LocationManagerService$Receiver.callLocationChangedLocked(LocationManagerService.java:823)
W/System.err(  652):     at com.android.server.LocationManagerService.handleLocationChangedLocked(LocationManagerService.java:2271)
W/System.err(  652):     at com.android.server.LocationManagerService.handleLocationChanged(LocationManagerService.java:2365)
W/System.err(  652):     at com.android.server.LocationManagerService.access$1800(LocationManagerService.java:110)
W/System.err(  652):     at com.android.server.LocationManagerService$LocationWorkerHandler.handleMessage(LocationManagerService.java:2331)
W/System.err(  652):     at android.os.Handler.dispatchMessage(Handler.java:102)
W/System.err(  652):     at android.os.Looper.loop(Looper.java:135)
W/System.err(  652):     at android.os.HandlerThread.run(HandlerThread.java:61)

3. In message handling loop of app thread, process the message and call the corresponding callback method.

4. In app thread, call LocationManagerService.locationCallbackFinished to release wake lock.

Call stack:

W/System.err(  652):     at com.android.server.LocationManagerService$Receiver.decrementPendingBroadcastsLocked(LocationManagerService.java:924)
W/System.err(  652):     at com.android.server.LocationManagerService$Receiver.access$1500(LocationManagerService.java:604)
W/System.err(  652):     at com.android.server.LocationManagerService.locationCallbackFinished(LocationManagerService.java:959)
W/System.err(  652):     at android.location.LocationManager$ListenerTransport._handleMessage(LocationManager.java:312)
W/System.err(  652):     at android.location.LocationManager$ListenerTransport.access$000(LocationManager.java:224)
W/System.err(  652):     at android.location.LocationManager$ListenerTransport$2.handleMessage(LocationManager.java:247)
W/System.err(  652):     at android.os.Handler.dispatchMessage(Handler.java:102)
W/System.err(  652):     at android.os.Looper.loop(Looper.java:135)
W/System.err(  652):     at android.os.HandlerThread.run(HandlerThread.java:61)

So the possible reason why wake lock is not release is:

1. LMS has sent a message to app thread, and acquire the wake lock. But app thread do not process the message.

2. LMS has sent the message and acquired the lock, and app thread is processing the message. But there is an exception happened during callback function.

    private class ListenerTransport extends ILocationListener.Stub {
        private static final int TYPE_LOCATION_CHANGED = 1;
        private static final int TYPE_STATUS_CHANGED = 2;
        private static final int TYPE_PROVIDER_ENABLED = 3;
        private static final int TYPE_PROVIDER_DISABLED = 4;

        private LocationListener mListener;
        private final Handler mListenerHandler;

        ListenerTransport(LocationListener listener, Looper looper) {
            mListener = listener;

            if (looper == null) {
                mListenerHandler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        _handleMessage(msg);
                    }
                };
            } else {
                mListenerHandler = new Handler(looper) {
                    @Override
                    public void handleMessage(Message msg) {
                        _handleMessage(msg);
                    }
                };
            }
        }

        @Override
        public void onLocationChanged(Location location) {
            Message msg = Message.obtain();
            msg.what = TYPE_LOCATION_CHANGED;
            msg.obj = location;
            mListenerHandler.sendMessage(msg);
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {
            Message msg = Message.obtain();
            msg.what = TYPE_STATUS_CHANGED;
            Bundle b = new Bundle();
            b.putString("provider", provider);
            b.putInt("status", status);
            if (extras != null) {
                b.putBundle("extras", extras);
            }
            msg.obj = b;
            mListenerHandler.sendMessage(msg);
        }

        @Override
        public void onProviderEnabled(String provider) {
            Message msg = Message.obtain();
            msg.what = TYPE_PROVIDER_ENABLED;
            msg.obj = provider;
            mListenerHandler.sendMessage(msg);
        }

        @Override
        public void onProviderDisabled(String provider) {
            Message msg = Message.obtain();
            msg.what = TYPE_PROVIDER_DISABLED;
            msg.obj = provider;
            mListenerHandler.sendMessage(msg);
        }

        private void _handleMessage(Message msg) {
            switch (msg.what) {
                case TYPE_LOCATION_CHANGED:
                    Location location = new Location((Location) msg.obj);
                    mListener.onLocationChanged(location);
                    break;
                case TYPE_STATUS_CHANGED:
                    Bundle b = (Bundle) msg.obj;
                    String provider = b.getString("provider");
                    int status = b.getInt("status");
                    Bundle extras = b.getBundle("extras");
                    mListener.onStatusChanged(provider, status, extras);
                    break;
                case TYPE_PROVIDER_ENABLED:
                    mListener.onProviderEnabled((String) msg.obj);
                    break;
                case TYPE_PROVIDER_DISABLED:
                    mListener.onProviderDisabled((String) msg.obj);
                    break;
            }
            try {
                mService.locationCallbackFinished(this); it will not be called if above functions throw an exception
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
    }

If the above two case happen, there is no chance for app thread to callLocationManagerService.locationCallbackFinished to release wake lock. But user can still release the wake lock by calling LocationManager.removeUpdates.

In my case, launcher register a location listener by calling LocationManager.requestLocationUpdates.

In the listener, it does some other operations and calling LocationManager.removeUpdates at the end of callback function.

So there is no chance to call LocationManagerService.locationCallbackFinishedto release wake lock if callback is not called or there is an exception happen before LocationManager.removeUpdates

So launcher will keep holding the wake lock.

Solution:

To solve the problem, we use CountDownLatch to wait until onLocationChanged is called or timer expire.

1. register a listener

2.CountDownLatch.await(5,TimeUnit.SECONDS);

3. if onLocationChanged is called, stop waiting and remove listener.

4. if time out, remove listener.