services/core/java/com/android/server/ServiceWatcher.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.server;

 import static android.content.Context.BIND_AUTO_CREATE;
 import static android.content.Context.BIND_NOT_FOREGROUND;
 import static android.content.Context.BIND_NOT_VISIBLE;
 import static android.content.pm.PackageManager.GET_META_DATA;
 import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_AUTO;
 import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_AWARE;
 import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_UNAWARE;
 import static android.content.pm.PackageManager.MATCH_SYSTEM_ONLY;

 import android.annotation.BoolRes;
 import android.annotation.Nullable;
 import android.annotation.StringRes;
 import android.annotation.UserIdInt;
 import android.app.ActivityManager;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.ServiceConnection;
 import android.content.pm.ResolveInfo;
 import android.content.res.Resources;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.RemoteException;
 import android.os.UserHandle;
 import android.util.Log;

 import com.android.internal.content.PackageMonitor;
 import com.android.internal.util.Preconditions;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;

 /**
  * Maintains a binding to the best service that matches the given intent information. Bind and
  * unbind callbacks, as well as all binder operations, will all be run on the given handler.
  */
 public class ServiceWatcher implements ServiceConnection {

     private static final String TAG = "ServiceWatcher";
     private static final boolean D = Log.isLoggable(TAG, Log.DEBUG);

     private static final String EXTRA_SERVICE_VERSION = "serviceVersion";
     private static final String EXTRA_SERVICE_IS_MULTIUSER = "serviceIsMultiuser";

     private static final long BLOCKING_BINDER_TIMEOUT_MS = 30 * 1000;

     /** Function to run on binder interface. */
     public interface BinderRunner {
         /** Called to run client code with the binder. */
         void run(IBinder binder) throws RemoteException;
     }

     /**
      * Function to run on binder interface.
      * @param <T> Type to return.
      */
     public interface BlockingBinderRunner<T> {
         /** Called to run client code with the binder. */
         T run(IBinder binder) throws RemoteException;
     }

     /**
      * Information on the service ServiceWatcher has selected as the best option for binding.
      */
     public static final class ServiceInfo implements Comparable<ServiceInfo> {

         public static final ServiceInfo NONE = new ServiceInfo(Integer.MIN_VALUE, null,
                 UserHandle.USER_NULL);

         public final int version;
         @Nullable public final ComponentName component;
         @UserIdInt public final int userId;

         ServiceInfo(ResolveInfo resolveInfo, int currentUserId) {
             Preconditions.checkArgument(resolveInfo.serviceInfo.getComponentName() != null);

             Bundle metadata = resolveInfo.serviceInfo.metaData;
             boolean isMultiuser;
             if (metadata != null) {
                 version = metadata.getInt(EXTRA_SERVICE_VERSION, Integer.MIN_VALUE);
                 isMultiuser = metadata.getBoolean(EXTRA_SERVICE_IS_MULTIUSER, false);
             } else {
                 version = Integer.MIN_VALUE;
                 isMultiuser = false;
             }

             component = resolveInfo.serviceInfo.getComponentName();
             userId = isMultiuser ? UserHandle.USER_SYSTEM : currentUserId;
         }

         private ServiceInfo(int version, @Nullable ComponentName component, int userId) {
             Preconditions.checkArgument(component != null || version == Integer.MIN_VALUE);
             this.version = version;
             this.component = component;
             this.userId = userId;
         }

         @Override
         public boolean equals(Object o) {
             if (this == o) {
                 return true;
             }
             if (!(o instanceof ServiceInfo)) {
                 return false;
             }
             ServiceInfo that = (ServiceInfo) o;
             return version == that.version && userId == that.userId
                     && Objects.equals(component, that.component);
         }

         @Override
         public int hashCode() {
             return Objects.hash(version, component, userId);
         }

         @Override
         public int compareTo(ServiceInfo that) {
             // ServiceInfos with higher version numbers always win (having a version number >
             // MIN_VALUE implies having a non-null component). if version numbers are equal, a
             // non-null component wins over a null component. if the version numbers are equal and
             // both components exist then we prefer components that work for all users vs components
             // that only work for a single user at a time. otherwise everything's equal.
             int ret = Integer.compare(version, that.version);
             if (ret == 0) {
                 if (component == null && that.component != null) {
                     ret = -1;
                 } else if (component != null && that.component == null) {
                     ret = 1;
                 } else {
                     if (userId != UserHandle.USER_SYSTEM && that.userId == UserHandle.USER_SYSTEM) {
                         ret = -1;
                     } else if (userId == UserHandle.USER_SYSTEM
                             && that.userId != UserHandle.USER_SYSTEM) {
                         ret = 1;
                     }
                 }
             }
             return ret;
         }

         @Override
         public String toString() {
             if (component == null) {
                 return "none";
             } else {
                 return component.toShortString() + "@" + version + "[u" + userId + "]";
             }
         }
     }

     private final Context mContext;
     private final Handler mHandler;
     private final Intent mIntent;

     @Nullable private final BinderRunner mOnBind;
     @Nullable private final Runnable mOnUnbind;

     // read/write from handler thread only
     private int mCurrentUserId;

     // write from handler thread only, read anywhere
     private volatile ServiceInfo mServiceInfo;
     private volatile IBinder mBinder;

     public ServiceWatcher(Context context, Handler handler, String action,
             @Nullable BinderRunner onBind, @Nullable Runnable onUnbind,
             @BoolRes int enableOverlayResId, @StringRes int nonOverlayPackageResId) {
         mContext = context;
         mHandler = FgThread.getHandler();
         mIntent = new Intent(Objects.requireNonNull(action));

         Resources resources = context.getResources();
         boolean enableOverlay = resources.getBoolean(enableOverlayResId);
         if (!enableOverlay) {
             mIntent.setPackage(resources.getString(nonOverlayPackageResId));
         }

         mOnBind = onBind;
         mOnUnbind = onUnbind;

         mCurrentUserId = UserHandle.USER_NULL;

         mServiceInfo = ServiceInfo.NONE;
         mBinder = null;
     }

     /**
      * Register this class, which will start the process of determining the best matching service
      * and maintaining a binding to it. Will return false and fail if there are no possible matching
      * services at the time this functions is called.
      */
     public boolean register() {
         if (mContext.getPackageManager().queryIntentServicesAsUser(mIntent,
                 MATCH_DIRECT_BOOT_AWARE | MATCH_DIRECT_BOOT_UNAWARE | MATCH_SYSTEM_ONLY,
                 UserHandle.USER_SYSTEM).isEmpty()) {
             return false;
         }

         new PackageMonitor() {
             @Override
             public void onPackageUpdateFinished(String packageName, int uid) {
                 ServiceWatcher.this.onPackageChanged(packageName);
             }

             @Override
             public void onPackageAdded(String packageName, int uid) {
                 ServiceWatcher.this.onPackageChanged(packageName);
             }

             @Override
             public void onPackageRemoved(String packageName, int uid) {
                 ServiceWatcher.this.onPackageChanged(packageName);
             }

             @Override
             public boolean onPackageChanged(String packageName, int uid, String[] components) {
                 ServiceWatcher.this.onPackageChanged(packageName);
                 return super.onPackageChanged(packageName, uid, components);
             }
         }.register(mContext, UserHandle.ALL, true, mHandler);

         IntentFilter intentFilter = new IntentFilter();
         intentFilter.addAction(Intent.ACTION_USER_SWITCHED);
         intentFilter.addAction(Intent.ACTION_USER_UNLOCKED);
         mContext.registerReceiverAsUser(new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 String action = intent.getAction();
                 if (action == null) {
                     return;
                 }
                 int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
                 if (userId == UserHandle.USER_NULL) {
                     return;
                 }

                 switch (action) {
                     case Intent.ACTION_USER_SWITCHED:
                         onUserSwitched(userId);
                         break;
                     case Intent.ACTION_USER_UNLOCKED:
                         onUserUnlocked(userId);
                         break;
                     default:
                         break;
                 }

             }
         }, UserHandle.ALL, intentFilter, null, mHandler);

         mCurrentUserId = ActivityManager.getCurrentUser();

         mHandler.post(() -> onBestServiceChanged(false));
         return true;
     }

     /**
      * Returns information on the currently selected service.
      */
     public ServiceInfo getBoundService() {
         return mServiceInfo;
     }

     private void onBestServiceChanged(boolean forceRebind) {
         Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

         List<ResolveInfo> resolveInfos = mContext.getPackageManager().queryIntentServicesAsUser(
                 mIntent,
                 GET_META_DATA | MATCH_DIRECT_BOOT_AUTO | MATCH_SYSTEM_ONLY,
                 mCurrentUserId);

         ServiceInfo bestServiceInfo = ServiceInfo.NONE;
         for (ResolveInfo resolveInfo : resolveInfos) {
             ServiceInfo serviceInfo = new ServiceInfo(resolveInfo, mCurrentUserId);
             if (serviceInfo.compareTo(bestServiceInfo) > 0) {
                 bestServiceInfo = serviceInfo;
             }
         }

         if (forceRebind || !bestServiceInfo.equals(mServiceInfo)) {
             rebind(bestServiceInfo);
         }
     }

     private void rebind(ServiceInfo newServiceInfo) {
         Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

         if (!mServiceInfo.equals(ServiceInfo.NONE)) {
             if (D) {
                 Log.i(TAG, "[" + mIntent.getAction() + "] unbinding from " + mServiceInfo);
             }

             mContext.unbindService(this);
             onServiceDisconnected(mServiceInfo.component);
             mServiceInfo = ServiceInfo.NONE;
         }

         mServiceInfo = newServiceInfo;
         if (mServiceInfo.equals(ServiceInfo.NONE)) {
             return;
         }

         Preconditions.checkState(mServiceInfo.component != null);

         if (D) {
             Log.i(TAG, getLogPrefix() + " binding to " + mServiceInfo);
         }

         Intent bindIntent = new Intent(mIntent).setComponent(mServiceInfo.component);
         mContext.bindServiceAsUser(bindIntent, this,
                 BIND_AUTO_CREATE | BIND_NOT_FOREGROUND | BIND_NOT_VISIBLE,
                 mHandler, UserHandle.of(mServiceInfo.userId));
     }

     @Override
     public final void onServiceConnected(ComponentName component, IBinder binder) {
         Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());
         Preconditions.checkState(mBinder == null);

         if (D) {
             Log.i(TAG, getLogPrefix() + " connected to " + component.toShortString());
         }

         mBinder = binder;
         if (mOnBind != null) {
             try {
                 mOnBind.run(binder);
             } catch (RuntimeException | RemoteException e) {
                 // binders may propagate some specific non-RemoteExceptions from the other side
                 // through the binder as well - we cannot allow those to crash the system server
                 Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
             }
         }
     }

     @Override
     public final void onServiceDisconnected(ComponentName component) {
         Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

         if (mBinder == null) {
             return;
         }

         if (D) {
             Log.i(TAG, getLogPrefix() + " disconnected from " + component.toShortString());
         }

         mBinder = null;
         if (mOnUnbind != null) {
             mOnUnbind.run();
         }
     }

     @Override
     public void onBindingDied(ComponentName component) {
         Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

         if (D) {
             Log.i(TAG, getLogPrefix() + " " + component.toShortString() + " died");
         }

         onBestServiceChanged(true);
     }

     void onUserSwitched(@UserIdInt int userId) {
         mCurrentUserId = userId;
         onBestServiceChanged(false);
     }

     void onUserUnlocked(@UserIdInt int userId) {
         if (userId == mCurrentUserId) {
             onBestServiceChanged(false);
         }
     }

     void onPackageChanged(String packageName) {
         // force a rebind if the changed package was the currently connected package
         String currentPackageName =
                 mServiceInfo.component != null ? mServiceInfo.component.getPackageName() : null;
         onBestServiceChanged(packageName.equals(currentPackageName));
     }

     /**
      * Runs the given function asynchronously if and only if currently connected. Suppresses any
      * RemoteException thrown during execution.
      */
     public final void runOnBinder(BinderRunner runner) {
         mHandler.post(() -> {
             if (mBinder == null) {
                 return;
             }

             try {
                 runner.run(mBinder);
             } catch (RuntimeException | RemoteException e) {
                 // binders may propagate some specific non-RemoteExceptions from the other side
                 // through the binder as well - we cannot allow those to crash the system server
                 Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
             }
         });
     }

     /**
      * Runs the given function synchronously if currently connected, and returns the default value
      * if not currently connected or if any exception is thrown. Do not obtain any locks within the
      * BlockingBinderRunner, or risk deadlock. The default value will be returned if there is no
      * service connection when this is run, if a RemoteException occurs, or if the operation times
      * out.
      *
      * @deprecated Using this function is an indication that your AIDL API is broken. Calls from
      * system server to outside MUST be one-way, and so cannot return any result, and this
      * method should not be needed or used. Use a separate callback interface to allow outside
      * components to return results back to the system server.
      */
     @Deprecated
     public final <T> T runOnBinderBlocking(BlockingBinderRunner<T> runner, T defaultValue) {
         try {
             return runOnHandlerBlocking(() -> {
                 if (mBinder == null) {
                     return defaultValue;
                 }

                 try {
                     return runner.run(mBinder);
                 } catch (RuntimeException | RemoteException e) {
                     // binders may propagate some specific non-RemoteExceptions from the other side
                     // through the binder as well - we cannot allow those to crash the system server
                     Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
                     return defaultValue;
                 }
             });
         } catch (InterruptedException | TimeoutException e) {
             return defaultValue;
         }
     }

     private <T> T runOnHandlerBlocking(Callable<T> c)
             throws InterruptedException, TimeoutException {
         if (Looper.myLooper() == mHandler.getLooper()) {
             try {
                 return c.call();
             } catch (Exception e) {
                 // Function cannot throw exception, this should never happen
                 throw new IllegalStateException(e);
             }
         } else {
             FutureTask<T> task = new FutureTask<>(c);
             mHandler.post(task);
             try {
                 // timeout will unblock callers, in particular if the caller is a binder thread to
                 // help reduce binder contention. this will still result in blocking the handler
                 // thread which may result in ANRs, but should make problems slightly more rare.
                 // the underlying solution is simply not to use this API at all, but that would
                 // require large refactors to very legacy code.
                 return task.get(BLOCKING_BINDER_TIMEOUT_MS, TimeUnit.MILLISECONDS);
             } catch (ExecutionException e) {
                 // Function cannot throw exception, this should never happen
                 throw new IllegalStateException(e);
             }
         }
     }

     private String getLogPrefix() {
         return "[" + mIntent.getAction() + "]";
     }

     @Override
     public String toString() {
         return mServiceInfo.toString();
     }

     /**
      * Dump for debugging.
      */
     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         pw.println("service=" + mServiceInfo);
         pw.println("connected=" + (mBinder != null));
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.server;

	import static android.content.Context.BIND_AUTO_CREATE;
	import static android.content.Context.BIND_NOT_FOREGROUND;
	import static android.content.Context.BIND_NOT_VISIBLE;
	import static android.content.pm.PackageManager.GET_META_DATA;
	import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_AUTO;
	import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_AWARE;
	import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_UNAWARE;
	import static android.content.pm.PackageManager.MATCH_SYSTEM_ONLY;

	import android.annotation.BoolRes;
	import android.annotation.Nullable;
	import android.annotation.StringRes;
	import android.annotation.UserIdInt;
	import android.app.ActivityManager;
	import android.content.BroadcastReceiver;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.content.ServiceConnection;
	import android.content.pm.ResolveInfo;
	import android.content.res.Resources;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Looper;
	import android.os.RemoteException;
	import android.os.UserHandle;
	import android.util.Log;

	import com.android.internal.content.PackageMonitor;
	import com.android.internal.util.Preconditions;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.List;
	import java.util.Objects;
	import java.util.concurrent.Callable;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.FutureTask;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.TimeoutException;

	/**
	* Maintains a binding to the best service that matches the given intent information. Bind and
	* unbind callbacks, as well as all binder operations, will all be run on the given handler.
	*/
	public class ServiceWatcher implements ServiceConnection {

	private static final String TAG = "ServiceWatcher";
	private static final boolean D = Log.isLoggable(TAG, Log.DEBUG);

	private static final String EXTRA_SERVICE_VERSION = "serviceVersion";
	private static final String EXTRA_SERVICE_IS_MULTIUSER = "serviceIsMultiuser";

	private static final long BLOCKING_BINDER_TIMEOUT_MS = 30 * 1000;

	/** Function to run on binder interface. */
	public interface BinderRunner {
	/** Called to run client code with the binder. */
	void run(IBinder binder) throws RemoteException;
	}

	/**
	* Function to run on binder interface.
	* @param <T> Type to return.
	*/
	public interface BlockingBinderRunner<T> {
	/** Called to run client code with the binder. */
	T run(IBinder binder) throws RemoteException;
	}

	/**
	* Information on the service ServiceWatcher has selected as the best option for binding.
	*/
	public static final class ServiceInfo implements Comparable<ServiceInfo> {

	public static final ServiceInfo NONE = new ServiceInfo(Integer.MIN_VALUE, null,
	UserHandle.USER_NULL);

	public final int version;
	@Nullable public final ComponentName component;
	@UserIdInt public final int userId;

	ServiceInfo(ResolveInfo resolveInfo, int currentUserId) {
	Preconditions.checkArgument(resolveInfo.serviceInfo.getComponentName() != null);

	Bundle metadata = resolveInfo.serviceInfo.metaData;
	boolean isMultiuser;
	if (metadata != null) {
	version = metadata.getInt(EXTRA_SERVICE_VERSION, Integer.MIN_VALUE);
	isMultiuser = metadata.getBoolean(EXTRA_SERVICE_IS_MULTIUSER, false);
	} else {
	version = Integer.MIN_VALUE;
	isMultiuser = false;
	}

	component = resolveInfo.serviceInfo.getComponentName();
	userId = isMultiuser ? UserHandle.USER_SYSTEM : currentUserId;
	}

	private ServiceInfo(int version, @Nullable ComponentName component, int userId) {
	Preconditions.checkArgument(component != null \|\| version == Integer.MIN_VALUE);
	this.version = version;
	this.component = component;
	this.userId = userId;
	}

	@Override
	public boolean equals(Object o) {
	if (this == o) {
	return true;
	}
	if (!(o instanceof ServiceInfo)) {
	return false;
	}
	ServiceInfo that = (ServiceInfo) o;
	return version == that.version && userId == that.userId
	&& Objects.equals(component, that.component);
	}

	@Override
	public int hashCode() {
	return Objects.hash(version, component, userId);
	}

	@Override
	public int compareTo(ServiceInfo that) {
	// ServiceInfos with higher version numbers always win (having a version number >
	// MIN_VALUE implies having a non-null component). if version numbers are equal, a
	// non-null component wins over a null component. if the version numbers are equal and
	// both components exist then we prefer components that work for all users vs components
	// that only work for a single user at a time. otherwise everything's equal.
	int ret = Integer.compare(version, that.version);
	if (ret == 0) {
	if (component == null && that.component != null) {
	ret = -1;
	} else if (component != null && that.component == null) {
	ret = 1;
	} else {
	if (userId != UserHandle.USER_SYSTEM && that.userId == UserHandle.USER_SYSTEM) {
	ret = -1;
	} else if (userId == UserHandle.USER_SYSTEM
	&& that.userId != UserHandle.USER_SYSTEM) {
	ret = 1;
	}
	}
	}
	return ret;
	}

	@Override
	public String toString() {
	if (component == null) {
	return "none";
	} else {
	return component.toShortString() + "@" + version + "[u" + userId + "]";
	}
	}
	}

	private final Context mContext;
	private final Handler mHandler;
	private final Intent mIntent;

	@Nullable private final BinderRunner mOnBind;
	@Nullable private final Runnable mOnUnbind;

	// read/write from handler thread only
	private int mCurrentUserId;

	// write from handler thread only, read anywhere
	private volatile ServiceInfo mServiceInfo;
	private volatile IBinder mBinder;

	public ServiceWatcher(Context context, Handler handler, String action,
	@Nullable BinderRunner onBind, @Nullable Runnable onUnbind,
	@BoolRes int enableOverlayResId, @StringRes int nonOverlayPackageResId) {
	mContext = context;
	mHandler = FgThread.getHandler();
	mIntent = new Intent(Objects.requireNonNull(action));

	Resources resources = context.getResources();
	boolean enableOverlay = resources.getBoolean(enableOverlayResId);
	if (!enableOverlay) {
	mIntent.setPackage(resources.getString(nonOverlayPackageResId));
	}

	mOnBind = onBind;
	mOnUnbind = onUnbind;

	mCurrentUserId = UserHandle.USER_NULL;

	mServiceInfo = ServiceInfo.NONE;
	mBinder = null;
	}

	/**
	* Register this class, which will start the process of determining the best matching service
	* and maintaining a binding to it. Will return false and fail if there are no possible matching
	* services at the time this functions is called.
	*/
	public boolean register() {
	if (mContext.getPackageManager().queryIntentServicesAsUser(mIntent,
	MATCH_DIRECT_BOOT_AWARE \| MATCH_DIRECT_BOOT_UNAWARE \| MATCH_SYSTEM_ONLY,
	UserHandle.USER_SYSTEM).isEmpty()) {
	return false;
	}

	new PackageMonitor() {
	@Override
	public void onPackageUpdateFinished(String packageName, int uid) {
	ServiceWatcher.this.onPackageChanged(packageName);
	}

	@Override
	public void onPackageAdded(String packageName, int uid) {
	ServiceWatcher.this.onPackageChanged(packageName);
	}

	@Override
	public void onPackageRemoved(String packageName, int uid) {
	ServiceWatcher.this.onPackageChanged(packageName);
	}

	@Override
	public boolean onPackageChanged(String packageName, int uid, String[] components) {
	ServiceWatcher.this.onPackageChanged(packageName);
	return super.onPackageChanged(packageName, uid, components);
	}
	}.register(mContext, UserHandle.ALL, true, mHandler);

	IntentFilter intentFilter = new IntentFilter();
	intentFilter.addAction(Intent.ACTION_USER_SWITCHED);
	intentFilter.addAction(Intent.ACTION_USER_UNLOCKED);
	mContext.registerReceiverAsUser(new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	String action = intent.getAction();
	if (action == null) {
	return;
	}
	int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
	if (userId == UserHandle.USER_NULL) {
	return;
	}

	switch (action) {
	case Intent.ACTION_USER_SWITCHED:
	onUserSwitched(userId);
	break;
	case Intent.ACTION_USER_UNLOCKED:
	onUserUnlocked(userId);
	break;
	default:
	break;
	}

	}
	}, UserHandle.ALL, intentFilter, null, mHandler);

	mCurrentUserId = ActivityManager.getCurrentUser();

	mHandler.post(() -> onBestServiceChanged(false));
	return true;
	}

	/**
	* Returns information on the currently selected service.
	*/
	public ServiceInfo getBoundService() {
	return mServiceInfo;
	}

	private void onBestServiceChanged(boolean forceRebind) {
	Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

	List<ResolveInfo> resolveInfos = mContext.getPackageManager().queryIntentServicesAsUser(
	mIntent,
	GET_META_DATA \| MATCH_DIRECT_BOOT_AUTO \| MATCH_SYSTEM_ONLY,
	mCurrentUserId);

	ServiceInfo bestServiceInfo = ServiceInfo.NONE;
	for (ResolveInfo resolveInfo : resolveInfos) {
	ServiceInfo serviceInfo = new ServiceInfo(resolveInfo, mCurrentUserId);
	if (serviceInfo.compareTo(bestServiceInfo) > 0) {
	bestServiceInfo = serviceInfo;
	}
	}

	if (forceRebind \|\| !bestServiceInfo.equals(mServiceInfo)) {
	rebind(bestServiceInfo);
	}
	}

	private void rebind(ServiceInfo newServiceInfo) {
	Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

	if (!mServiceInfo.equals(ServiceInfo.NONE)) {
	if (D) {
	Log.i(TAG, "[" + mIntent.getAction() + "] unbinding from " + mServiceInfo);
	}

	mContext.unbindService(this);
	onServiceDisconnected(mServiceInfo.component);
	mServiceInfo = ServiceInfo.NONE;
	}

	mServiceInfo = newServiceInfo;
	if (mServiceInfo.equals(ServiceInfo.NONE)) {
	return;
	}

	Preconditions.checkState(mServiceInfo.component != null);

	if (D) {
	Log.i(TAG, getLogPrefix() + " binding to " + mServiceInfo);
	}

	Intent bindIntent = new Intent(mIntent).setComponent(mServiceInfo.component);
	mContext.bindServiceAsUser(bindIntent, this,
	BIND_AUTO_CREATE \| BIND_NOT_FOREGROUND \| BIND_NOT_VISIBLE,
	mHandler, UserHandle.of(mServiceInfo.userId));
	}

	@Override
	public final void onServiceConnected(ComponentName component, IBinder binder) {
	Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());
	Preconditions.checkState(mBinder == null);

	if (D) {
	Log.i(TAG, getLogPrefix() + " connected to " + component.toShortString());
	}

	mBinder = binder;
	if (mOnBind != null) {
	try {
	mOnBind.run(binder);
	} catch (RuntimeException \| RemoteException e) {
	// binders may propagate some specific non-RemoteExceptions from the other side
	// through the binder as well - we cannot allow those to crash the system server
	Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
	}
	}
	}

	@Override
	public final void onServiceDisconnected(ComponentName component) {
	Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

	if (mBinder == null) {
	return;
	}

	if (D) {
	Log.i(TAG, getLogPrefix() + " disconnected from " + component.toShortString());
	}

	mBinder = null;
	if (mOnUnbind != null) {
	mOnUnbind.run();
	}
	}

	@Override
	public void onBindingDied(ComponentName component) {
	Preconditions.checkState(Looper.myLooper() == mHandler.getLooper());

	if (D) {
	Log.i(TAG, getLogPrefix() + " " + component.toShortString() + " died");
	}

	onBestServiceChanged(true);
	}

	void onUserSwitched(@UserIdInt int userId) {
	mCurrentUserId = userId;
	onBestServiceChanged(false);
	}

	void onUserUnlocked(@UserIdInt int userId) {
	if (userId == mCurrentUserId) {
	onBestServiceChanged(false);
	}
	}

	void onPackageChanged(String packageName) {
	// force a rebind if the changed package was the currently connected package
	String currentPackageName =
	mServiceInfo.component != null ? mServiceInfo.component.getPackageName() : null;
	onBestServiceChanged(packageName.equals(currentPackageName));
	}

	/**
	* Runs the given function asynchronously if and only if currently connected. Suppresses any
	* RemoteException thrown during execution.
	*/
	public final void runOnBinder(BinderRunner runner) {
	mHandler.post(() -> {
	if (mBinder == null) {
	return;
	}

	try {
	runner.run(mBinder);
	} catch (RuntimeException \| RemoteException e) {
	// binders may propagate some specific non-RemoteExceptions from the other side
	// through the binder as well - we cannot allow those to crash the system server
	Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
	}
	});
	}

	/**
	* Runs the given function synchronously if currently connected, and returns the default value
	* if not currently connected or if any exception is thrown. Do not obtain any locks within the
	* BlockingBinderRunner, or risk deadlock. The default value will be returned if there is no
	* service connection when this is run, if a RemoteException occurs, or if the operation times
	* out.
	*
	* @deprecated Using this function is an indication that your AIDL API is broken. Calls from
	* system server to outside MUST be one-way, and so cannot return any result, and this
	* method should not be needed or used. Use a separate callback interface to allow outside
	* components to return results back to the system server.
	*/
	@Deprecated
	public final <T> T runOnBinderBlocking(BlockingBinderRunner<T> runner, T defaultValue) {
	try {
	return runOnHandlerBlocking(() -> {
	if (mBinder == null) {
	return defaultValue;
	}

	try {
	return runner.run(mBinder);
	} catch (RuntimeException \| RemoteException e) {
	// binders may propagate some specific non-RemoteExceptions from the other side
	// through the binder as well - we cannot allow those to crash the system server
	Log.e(TAG, getLogPrefix() + " exception running on " + mServiceInfo, e);
	return defaultValue;
	}
	});
	} catch (InterruptedException \| TimeoutException e) {
	return defaultValue;
	}
	}

	private <T> T runOnHandlerBlocking(Callable<T> c)
	throws InterruptedException, TimeoutException {
	if (Looper.myLooper() == mHandler.getLooper()) {
	try {
	return c.call();
	} catch (Exception e) {
	// Function cannot throw exception, this should never happen
	throw new IllegalStateException(e);
	}
	} else {
	FutureTask<T> task = new FutureTask<>(c);
	mHandler.post(task);
	try {
	// timeout will unblock callers, in particular if the caller is a binder thread to
	// help reduce binder contention. this will still result in blocking the handler
	// thread which may result in ANRs, but should make problems slightly more rare.
	// the underlying solution is simply not to use this API at all, but that would
	// require large refactors to very legacy code.
	return task.get(BLOCKING_BINDER_TIMEOUT_MS, TimeUnit.MILLISECONDS);
	} catch (ExecutionException e) {
	// Function cannot throw exception, this should never happen
	throw new IllegalStateException(e);
	}
	}
	}

	private String getLogPrefix() {
	return "[" + mIntent.getAction() + "]";
	}

	@Override
	public String toString() {
	return mServiceInfo.toString();
	}

	/**
	* Dump for debugging.
	*/
	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	pw.println("service=" + mServiceInfo);
	pw.println("connected=" + (mBinder != null));
	}
	}