03cdd3d275
This changelist revises LocationManager's previous multiuser system. Location provider services that are not multiuser-aware continue to run as before: ServiceWatcher binds to location provider services as the current active user. When the device switches from one user to another, ServiceWatcher unbinds from the old user's location provider service and binds to the new user's instance. Now, location provider services that are multiuser-aware or user-agnostic can declare "serviceIsMultiuser" metadata in their AndroidManifest.xml to prevent ServiceWatcher from performing this switching. These services will run as singleton services and will be expected to handle user switches on their own. With this feature in, I was able to switch FusedLocationProvider to run in multiuser mode, sharing the system_server process instead of running in its own process. The NetworkLocationProvider is unchanged, still running in singleuser mode, cheerfully oblivious to the possibility that there might be any user on the device besides the one it services. Bug: 8028045 Change-Id: I1a5bd032918419bab6edb46c62ff8c6811170654
331 lines
12 KiB
Java
331 lines
12 KiB
Java
/*
|
|
* 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 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.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.PackageManager.NameNotFoundException;
|
|
import android.content.pm.ResolveInfo;
|
|
import android.content.pm.Signature;
|
|
import android.os.Handler;
|
|
import android.os.IBinder;
|
|
import android.os.UserHandle;
|
|
import android.util.Log;
|
|
|
|
import com.android.internal.content.PackageMonitor;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Find the best Service, and bind to it.
|
|
* Handles run-time package changes.
|
|
*/
|
|
public class ServiceWatcher implements ServiceConnection {
|
|
private static final boolean D = false;
|
|
public static final String EXTRA_SERVICE_VERSION = "serviceVersion";
|
|
public static final String EXTRA_SERVICE_IS_MULTIUSER = "serviceIsMultiuser";
|
|
|
|
private final String mTag;
|
|
private final Context mContext;
|
|
private final PackageManager mPm;
|
|
private final List<HashSet<Signature>> mSignatureSets;
|
|
private final String mAction;
|
|
private final Runnable mNewServiceWork;
|
|
private final Handler mHandler;
|
|
|
|
private Object mLock = new Object();
|
|
|
|
// all fields below synchronized on mLock
|
|
private IBinder mBinder; // connected service
|
|
private String mPackageName; // current best package
|
|
private int mVersion = Integer.MIN_VALUE; // current best version
|
|
/**
|
|
* Whether the currently-connected service is multiuser-aware. This can change at run-time
|
|
* when switching from one version of a service to another.
|
|
*/
|
|
private boolean mIsMultiuser = false;
|
|
|
|
public static ArrayList<HashSet<Signature>> getSignatureSets(Context context,
|
|
List<String> initialPackageNames) {
|
|
PackageManager pm = context.getPackageManager();
|
|
ArrayList<HashSet<Signature>> sigSets = new ArrayList<HashSet<Signature>>();
|
|
for (int i = 0, size = initialPackageNames.size(); i < size; i++) {
|
|
String pkg = initialPackageNames.get(i);
|
|
try {
|
|
HashSet<Signature> set = new HashSet<Signature>();
|
|
Signature[] sigs = pm.getPackageInfo(pkg, PackageManager.GET_SIGNATURES).signatures;
|
|
set.addAll(Arrays.asList(sigs));
|
|
sigSets.add(set);
|
|
} catch (NameNotFoundException e) {
|
|
Log.w("ServiceWatcher", pkg + " not found");
|
|
}
|
|
}
|
|
return sigSets;
|
|
}
|
|
|
|
public ServiceWatcher(Context context, String logTag, String action,
|
|
List<String> initialPackageNames, Runnable newServiceWork, Handler handler) {
|
|
mContext = context;
|
|
mTag = logTag;
|
|
mAction = action;
|
|
mPm = mContext.getPackageManager();
|
|
mNewServiceWork = newServiceWork;
|
|
mHandler = handler;
|
|
mSignatureSets = getSignatureSets(context, initialPackageNames);
|
|
}
|
|
|
|
public boolean start() {
|
|
synchronized (mLock) {
|
|
if (!bindBestPackageLocked(null)) return false;
|
|
}
|
|
|
|
// listen for user change
|
|
IntentFilter intentFilter = new IntentFilter();
|
|
intentFilter.addAction(Intent.ACTION_USER_SWITCHED);
|
|
mContext.registerReceiverAsUser(new BroadcastReceiver() {
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
String action = intent.getAction();
|
|
if (Intent.ACTION_USER_SWITCHED.equals(action)) {
|
|
switchUser();
|
|
}
|
|
}
|
|
}, UserHandle.ALL, intentFilter, null, mHandler);
|
|
|
|
// listen for relevant package changes
|
|
mPackageMonitor.register(mContext, null, UserHandle.ALL, true);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Searches and binds to the best package, or do nothing
|
|
* if the best package is already bound.
|
|
* Only checks the named package, or checks all packages if it
|
|
* is null.
|
|
* Return true if a new package was found to bind to.
|
|
*/
|
|
private boolean bindBestPackageLocked(String justCheckThisPackage) {
|
|
Intent intent = new Intent(mAction);
|
|
if (justCheckThisPackage != null) {
|
|
intent.setPackage(justCheckThisPackage);
|
|
}
|
|
List<ResolveInfo> rInfos = mPm.queryIntentServicesAsUser(new Intent(mAction),
|
|
PackageManager.GET_META_DATA, UserHandle.USER_OWNER);
|
|
int bestVersion = Integer.MIN_VALUE;
|
|
String bestPackage = null;
|
|
boolean bestIsMultiuser = false;
|
|
for (ResolveInfo rInfo : rInfos) {
|
|
String packageName = rInfo.serviceInfo.packageName;
|
|
|
|
// check signature
|
|
try {
|
|
PackageInfo pInfo;
|
|
pInfo = mPm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
|
|
if (!isSignatureMatch(pInfo.signatures)) {
|
|
Log.w(mTag, packageName + " resolves service " + mAction +
|
|
", but has wrong signature, ignoring");
|
|
continue;
|
|
}
|
|
} catch (NameNotFoundException e) {
|
|
Log.wtf(mTag, e);
|
|
continue;
|
|
}
|
|
|
|
// check metadata
|
|
int version = Integer.MIN_VALUE;
|
|
boolean isMultiuser = false;
|
|
if (rInfo.serviceInfo.metaData != null) {
|
|
version = rInfo.serviceInfo.metaData.getInt(EXTRA_SERVICE_VERSION,
|
|
Integer.MIN_VALUE);
|
|
isMultiuser = rInfo.serviceInfo.metaData.getBoolean(EXTRA_SERVICE_IS_MULTIUSER);
|
|
}
|
|
|
|
if (version > mVersion) {
|
|
bestVersion = version;
|
|
bestPackage = packageName;
|
|
bestIsMultiuser = isMultiuser;
|
|
}
|
|
}
|
|
|
|
if (D) Log.d(mTag, String.format("bindBestPackage for %s : %s found %d, %s", mAction,
|
|
(justCheckThisPackage == null ? "" : "(" + justCheckThisPackage + ") "),
|
|
rInfos.size(),
|
|
(bestPackage == null ? "no new best package" : "new best package: "
|
|
+ bestPackage)));
|
|
|
|
if (bestPackage != null) {
|
|
bindToPackageLocked(bestPackage, bestVersion, bestIsMultiuser);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void unbindLocked() {
|
|
String pkg;
|
|
pkg = mPackageName;
|
|
mPackageName = null;
|
|
mVersion = Integer.MIN_VALUE;
|
|
mIsMultiuser = false;
|
|
if (pkg != null) {
|
|
if (D) Log.d(mTag, "unbinding " + pkg);
|
|
mContext.unbindService(this);
|
|
}
|
|
}
|
|
|
|
private void bindToPackageLocked(String packageName, int version, boolean isMultiuser) {
|
|
unbindLocked();
|
|
Intent intent = new Intent(mAction);
|
|
intent.setPackage(packageName);
|
|
mPackageName = packageName;
|
|
mVersion = version;
|
|
mIsMultiuser = isMultiuser;
|
|
if (D) Log.d(mTag, "binding " + packageName + " (version " + version + ") ("
|
|
+ (isMultiuser ? "multi" : "single") + "-user)");
|
|
mContext.bindServiceAsUser(intent, this, Context.BIND_AUTO_CREATE | Context.BIND_NOT_FOREGROUND
|
|
| Context.BIND_NOT_VISIBLE, mIsMultiuser ? UserHandle.OWNER : UserHandle.CURRENT);
|
|
}
|
|
|
|
public static boolean isSignatureMatch(Signature[] signatures,
|
|
List<HashSet<Signature>> sigSets) {
|
|
if (signatures == null) return false;
|
|
|
|
// build hashset of input to test against
|
|
HashSet<Signature> inputSet = new HashSet<Signature>();
|
|
for (Signature s : signatures) {
|
|
inputSet.add(s);
|
|
}
|
|
|
|
// test input against each of the signature sets
|
|
for (HashSet<Signature> referenceSet : sigSets) {
|
|
if (referenceSet.equals(inputSet)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean isSignatureMatch(Signature[] signatures) {
|
|
return isSignatureMatch(signatures, mSignatureSets);
|
|
}
|
|
|
|
private final PackageMonitor mPackageMonitor = new PackageMonitor() {
|
|
/**
|
|
* Called when package has been reinstalled
|
|
*/
|
|
@Override
|
|
public void onPackageUpdateFinished(String packageName, int uid) {
|
|
synchronized (mLock) {
|
|
if (packageName.equals(mPackageName)) {
|
|
// package updated, make sure to rebind
|
|
unbindLocked();
|
|
}
|
|
// check the updated package in case it is better
|
|
bindBestPackageLocked(packageName);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onPackageAdded(String packageName, int uid) {
|
|
synchronized (mLock) {
|
|
if (packageName.equals(mPackageName)) {
|
|
// package updated, make sure to rebind
|
|
unbindLocked();
|
|
}
|
|
// check the new package is case it is better
|
|
bindBestPackageLocked(packageName);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onPackageRemoved(String packageName, int uid) {
|
|
synchronized (mLock) {
|
|
if (packageName.equals(mPackageName)) {
|
|
unbindLocked();
|
|
// the currently bound package was removed,
|
|
// need to search for a new package
|
|
bindBestPackageLocked(null);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public void onServiceConnected(ComponentName name, IBinder binder) {
|
|
synchronized (mLock) {
|
|
String packageName = name.getPackageName();
|
|
if (packageName.equals(mPackageName)) {
|
|
if (D) Log.d(mTag, packageName + " connected");
|
|
mBinder = binder;
|
|
if (mHandler !=null && mNewServiceWork != null) {
|
|
mHandler.post(mNewServiceWork);
|
|
}
|
|
} else {
|
|
Log.w(mTag, "unexpected onServiceConnected: " + packageName);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onServiceDisconnected(ComponentName name) {
|
|
synchronized (mLock) {
|
|
String packageName = name.getPackageName();
|
|
if (D) Log.d(mTag, packageName + " disconnected");
|
|
|
|
if (packageName.equals(mPackageName)) {
|
|
mBinder = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public String getBestPackageName() {
|
|
synchronized (mLock) {
|
|
return mPackageName;
|
|
}
|
|
}
|
|
|
|
public int getBestVersion() {
|
|
synchronized (mLock) {
|
|
return mVersion;
|
|
}
|
|
}
|
|
|
|
public IBinder getBinder() {
|
|
synchronized (mLock) {
|
|
return mBinder;
|
|
}
|
|
}
|
|
|
|
public void switchUser() {
|
|
synchronized (mLock) {
|
|
if (!mIsMultiuser) {
|
|
unbindLocked();
|
|
bindBestPackageLocked(null);
|
|
}
|
|
}
|
|
}
|
|
}
|