diff options
author | Adnan Begovic <adnan@cyngn.com> | 2015-04-30 11:10:56 -0700 |
---|---|---|
committer | Adnan Begovic <adnan@cyngn.com> | 2015-04-30 11:10:56 -0700 |
commit | a7d6fc579f016e0bcd67597ce4870100b0f62ba2 (patch) | |
tree | ad2eeedf60d0026780d842800cd891055870eddd /cm/lib/main/java/org/cyanogenmod/platform | |
parent | 104a15a6b0ee9134bb6992693d37a58ba17f2d39 (diff) | |
download | vendor_cmsdk-a7d6fc579f016e0bcd67597ce4870100b0f62ba2.zip vendor_cmsdk-a7d6fc579f016e0bcd67597ce4870100b0f62ba2.tar.gz vendor_cmsdk-a7d6fc579f016e0bcd67597ce4870100b0f62ba2.tar.bz2 |
CMSDK: Refactor compile, prepare for integration tests.
Also don't build CMPlatformTests unless explicitely called.
Change-Id: I3fd8f884d8815eab9987077766c0ff2fe3f98b4d
Diffstat (limited to 'cm/lib/main/java/org/cyanogenmod/platform')
-rw-r--r-- | cm/lib/main/java/org/cyanogenmod/platform/internal/CMStatusBarManagerService.java | 506 | ||||
-rw-r--r-- | cm/lib/main/java/org/cyanogenmod/platform/internal/ManagedServices.java | 634 |
2 files changed, 1140 insertions, 0 deletions
diff --git a/cm/lib/main/java/org/cyanogenmod/platform/internal/CMStatusBarManagerService.java b/cm/lib/main/java/org/cyanogenmod/platform/internal/CMStatusBarManagerService.java new file mode 100644 index 0000000..b640aaf --- /dev/null +++ b/cm/lib/main/java/org/cyanogenmod/platform/internal/CMStatusBarManagerService.java @@ -0,0 +1,506 @@ +/** + * Copyright (c) 2015, The CyanogenMod 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 org.cyanogenmod.platform.internal; + +import android.app.ActivityManager; +import android.app.AppGlobals; +import android.content.ComponentName; +import android.content.Context; +import android.content.pm.ApplicationInfo; +import android.os.Binder; +import android.os.Handler; +import android.os.IBinder; +import android.os.IInterface; +import android.os.RemoteException; +import android.os.UserHandle; +import android.util.ArrayMap; +import android.util.ArraySet; +import android.util.Log; +import android.util.Slog; + +import com.android.server.SystemService; +import cyanogenmod.app.CMContextConstants; +import cyanogenmod.app.CustomTile; +import cyanogenmod.app.CustomTileListenerService; +import cyanogenmod.app.StatusBarPanelCustomTile; +import cyanogenmod.app.ICustomTileListener; +import cyanogenmod.app.ICMStatusBarManager; + +import org.cyanogenmod.internal.statusbar.ExternalQuickSettingsRecord; +import org.cyanogenmod.internal.statusbar.IStatusBarCustomTileHolder; + +import java.util.ArrayList; + +import com.android.internal.R; + +/** + * Internal service which manages interactions with system ui elements + * @hide + */ +public class CMStatusBarManagerService extends SystemService { + private static final String TAG = "CMStatusBarManagerService"; + + private Handler mHandler = new Handler(); + private CustomTileListeners mCustomTileListeners; + + static final int MAX_PACKAGE_TILES = 4; + + private final ManagedServices.UserProfiles mUserProfiles = new ManagedServices.UserProfiles(); + + final ArrayList<ExternalQuickSettingsRecord> mQSTileList = + new ArrayList<ExternalQuickSettingsRecord>(); + final ArrayMap<String, ExternalQuickSettingsRecord> mCustomTileByKey = + new ArrayMap<String, ExternalQuickSettingsRecord>(); + + public CMStatusBarManagerService(Context context) { + super(context); + } + + @Override + public void onStart() { + Log.d(TAG, "registerCMStatusBar cmstatusbar: " + this); + mCustomTileListeners = new CustomTileListeners(); + publishBinderService(CMContextConstants.CM_STATUS_BAR_SERVICE, mService); + } + + private final IBinder mService = new ICMStatusBarManager.Stub() { + /** + * @hide + */ + @Override + public void createCustomTileWithTag(String pkg, String opPkg, String tag, int id, + CustomTile customTile, int[] idOut, int userId) throws RemoteException { + enforceCustomTilePublish(); + createCustomTileWithTagInternal(pkg, opPkg, Binder.getCallingUid(), + Binder.getCallingPid(), tag, id, customTile, idOut, userId); + } + + /** + * @hide + */ + @Override + public void removeCustomTileWithTag(String pkg, String tag, int id, int userId) { + checkCallerIsSystemOrSameApp(pkg); + userId = ActivityManager.handleIncomingUser(Binder.getCallingPid(), + Binder.getCallingUid(), userId, true, false, "cancelCustomTileWithTag", pkg); + removeCustomTileWithTagInternal(Binder.getCallingUid(), + Binder.getCallingPid(), pkg, tag, id, userId, null); + } + + /** + * Register a listener binder directly with the status bar manager. + * + * Only works with system callers. Apps should extend + * {@link cyanogenmod.app.CustomTileListenerService}. + * @hide + */ + @Override + public void registerListener(final ICustomTileListener listener, + final ComponentName component, final int userid) { + enforceBindCustomTileListener(); + mCustomTileListeners.registerService(listener, component, userid); + } + + /** + * Remove a listener binder directly + * @hide + */ + @Override + public void unregisterListener(ICustomTileListener listener, int userid) { + enforceBindCustomTileListener(); + mCustomTileListeners.unregisterService(listener, userid); + } + + /** + * Allow an ICustomTileListener to simulate clearing (dismissing) a single customTile. + * + * @param token The binder for the listener, to check that the caller is allowed + */ + @Override + public void removeCustomTileFromListener(ICustomTileListener token, String pkg, + String tag, int id) { + final int callingUid = Binder.getCallingUid(); + final int callingPid = Binder.getCallingPid(); + long identity = Binder.clearCallingIdentity(); + try { + synchronized (mQSTileList) { + final ManagedServices.ManagedServiceInfo info + = mCustomTileListeners.checkServiceTokenLocked(token); + removeCustomTileFromListenerLocked(info, callingUid, callingPid, + pkg, tag, id, info.userid); + } + } finally { + Binder.restoreCallingIdentity(identity); + } + } + }; + + void createCustomTileWithTagInternal(final String pkg, final String opPkg, final int callingUid, + final int callingPid, final String tag, final int id, final CustomTile customTile, + final int[] idOut, final int incomingUserId) { + + if (pkg == null || customTile == null) { + throw new IllegalArgumentException("null not allowed: pkg=" + pkg + + " id=" + id + " customTile=" + customTile); + } + + final int userId = ActivityManager.handleIncomingUser(callingPid, + callingUid, incomingUserId, true, false, "createCustomTileWithTag", pkg); + final UserHandle user = new UserHandle(userId); + + // remove custom tile call ends up in not removing the custom tile. + mHandler.post(new Runnable() { + @Override + public void run() { + final StatusBarPanelCustomTile sbc = new StatusBarPanelCustomTile( + pkg, opPkg, id, tag, callingUid, callingPid, customTile, + user); + ExternalQuickSettingsRecord r = new ExternalQuickSettingsRecord(sbc); + ExternalQuickSettingsRecord old = mCustomTileByKey.get(sbc.getKey()); + + int index = indexOfQsTileLocked(sbc.getKey()); + if (index < 0) { + // If this tile unknown to us, check DOS protection + if (checkDosProtection(pkg, callingUid, userId)) return; + mQSTileList.add(r); + } else { + old = mQSTileList.get(index); + mQSTileList.set(index, r); + r.isUpdate = true; + } + + mCustomTileByKey.put(sbc.getKey(), r); + + if (customTile.icon != 0) { + StatusBarPanelCustomTile oldSbn = (old != null) ? old.sbTile : null; + mCustomTileListeners.notifyPostedLocked(sbc, oldSbn); + } else { + Slog.e(TAG, "Not posting custom tile with icon==0: " + customTile); + if (old != null && !old.isCanceled) { + mCustomTileListeners.notifyRemovedLocked(sbc); + } + } + } + }); + idOut[0] = id; + } + + private boolean checkDosProtection(String pkg, int callingUid, int userId) { + final boolean isSystemTile = isUidSystem(callingUid) || ("android".equals(pkg)); + // Limit the number of Custom tiles that any given package except the android + // package or a registered listener can enqueue. Prevents DOS attacks and deals with leaks. + if (!isSystemTile) { + synchronized (mQSTileList) { + int count = 0; + final int N = mQSTileList.size(); + + for (int i = 0; i < N; i++) { + final ExternalQuickSettingsRecord r = mQSTileList.get(i); + if (r.sbTile.getPackage().equals(pkg) && r.sbTile.getUserId() == userId) { + count++; + if (count >= MAX_PACKAGE_TILES) { + Slog.e(TAG, "Package has already posted " + count + + " custom tiles. Not showing more. package=" + pkg); + return true; + } + } + } + } + } + return false; + } + + // lock on mQSTileList + int indexOfQsTileLocked(String key) { + final int N = mQSTileList.size(); + for (int i = 0; i < N; i++) { + if (key.equals(mQSTileList.get(i).getKey())) { + return i; + } + } + return -1; + } + + // lock on mQSTileList + int indexOfQsTileLocked(String pkg, String tag, int id, int userId) { + ArrayList<ExternalQuickSettingsRecord> list = mQSTileList; + final int len = list.size(); + for (int i = 0; i < len; i++) { + ExternalQuickSettingsRecord r = list.get(i); + if (!customTileMatchesUserId(r, userId) || r.sbTile.getId() != id) { + continue; + } + if (tag == null) { + if (r.sbTile.getTag() != null) { + continue; + } + } else { + if (!tag.equals(r.sbTile.getTag())) { + continue; + } + } + if (r.sbTile.getPackage().equals(pkg)) { + return i; + } + } + return -1; + } + + private static void checkCallerIsSystemOrSameApp(String pkg) { + if (isCallerSystem()) { + return; + } + final int uid = Binder.getCallingUid(); + try { + ApplicationInfo ai = AppGlobals.getPackageManager().getApplicationInfo( + pkg, 0, UserHandle.getCallingUserId()); + if (ai == null) { + throw new SecurityException("Unknown package " + pkg); + } + if (!UserHandle.isSameApp(ai.uid, uid)) { + throw new SecurityException("Calling uid " + uid + " gave package" + + pkg + " which is owned by uid " + ai.uid); + } + } catch (RemoteException re) { + throw new SecurityException("Unknown package " + pkg + "\n" + re); + } + } + + private static boolean isUidSystem(int uid) { + final int appid = UserHandle.getAppId(uid); + return (appid == android.os.Process.SYSTEM_UID + || appid == android.os.Process.PHONE_UID || uid == 0); + } + + private static boolean isCallerSystem() { + return isUidSystem(Binder.getCallingUid()); + } + + /** + * Determine whether the userId applies to the custom tile in question, either because + * they match exactly, or one of them is USER_ALL (which is treated as a wildcard). + */ + private boolean customTileMatchesUserId(ExternalQuickSettingsRecord r, int userId) { + return + // looking for USER_ALL custom tile? match everything + userId == UserHandle.USER_ALL + // a custom tile sent to USER_ALL matches any query + || r.getUserId() == UserHandle.USER_ALL + // an exact user match + || r.getUserId() == userId; + } + + private void removeCustomTileFromListenerLocked(ManagedServices.ManagedServiceInfo info, + int callingUid, int callingPid, String pkg, String tag, int id, int userId) { + removeCustomTileWithTagInternal(callingUid, callingPid, pkg, tag, id, userId, info); + } + + void removeCustomTileWithTagInternal(final int callingUid, final int callingPid, + final String pkg, final String tag, final int id, final int userId, + final ManagedServices.ManagedServiceInfo listener) { + mHandler.post(new Runnable() { + @Override + public void run() { + synchronized (mQSTileList) { + int index = indexOfQsTileLocked(pkg, tag, id, userId); + if (index >= 0) { + ExternalQuickSettingsRecord r = mQSTileList.get(index); + mQSTileList.remove(index); + // status bar + r.isCanceled = true; + mCustomTileListeners.notifyRemovedLocked(r.sbTile); + mCustomTileByKey.remove(r.sbTile.getKey()); + } + } + } + }); + } + + private void enforceSystemOrSystemUI(String message) { + if (isCallerSystem()) return; + mContext.enforceCallingPermission(android.Manifest.permission.STATUS_BAR_SERVICE, + message); + } + + private void enforceCustomTilePublish() { + //mContext.enforceCallingOrSelfPermission( + // android.Manifest.permission.PUBLISH_QUICK_SETTINGS_TILE, + // "StatusBarManagerService"); + } + + private void enforceBindCustomTileListener() { + //mContext.enforceCallingOrSelfPermission( + // android.Manifest.permission.BIND_CUSTOM_TILE_LISTENER_SERVICE, + // "StatusBarManagerService"); + } + + private boolean isVisibleToListener(StatusBarPanelCustomTile sbc, + ManagedServices.ManagedServiceInfo listener) { + return listener.enabledAndUserMatches(sbc.getUserId()); + } + + public class CustomTileListeners extends ManagedServices { + + private final ArraySet<ManagedServiceInfo> mLightTrimListeners = new ArraySet<>(); + + public CustomTileListeners() { + super(CMStatusBarManagerService.this.mContext, mHandler, mQSTileList, mUserProfiles); + } + + @Override + protected Config getConfig() { + Config c = new Config(); + c.caption = "custom tile listener"; + c.serviceInterface = CustomTileListenerService.SERVICE_INTERFACE; + //TODO: Implement this in the future + //c.secureSettingName = Settings.Secure.ENABLED_CUSTOM_TILE_LISTENERS; + //c.bindPermission = android.Manifest.permission.BIND_CUSTOM_TILE_LISTENER_SERVICE; + //TODO: Implement this in the future + //c.settingsAction = Settings.ACTION_CUSTOM_TILE_LISTENER_SETTINGS; + //c.clientLabel = R.string.custom_tile_listener_binding_label; + return c; + } + + @Override + protected IInterface asInterface(IBinder binder) { + return ICustomTileListener.Stub.asInterface(binder); + } + + @Override + public void onServiceAdded(ManagedServiceInfo info) { + final ICustomTileListener listener = (ICustomTileListener) info.service; + try { + listener.onListenerConnected(); + } catch (RemoteException e) { + // we tried + } + } + + @Override + protected void onServiceRemovedLocked(ManagedServiceInfo removed) { + mLightTrimListeners.remove(removed); + } + + + /** + * asynchronously notify all listeners about a new custom tile + * + * <p> + * Also takes care of removing a custom tile that has been visible to a listener before, + * but isn't anymore. + */ + public void notifyPostedLocked(StatusBarPanelCustomTile sbc, + StatusBarPanelCustomTile oldSbc) { + // Lazily initialized snapshots of the custom tile. + StatusBarPanelCustomTile sbcClone = null; + + for (final ManagedServiceInfo info : mServices) { + boolean sbnVisible = isVisibleToListener(sbc, info); + boolean oldSbnVisible = oldSbc != null ? isVisibleToListener(oldSbc, info) : false; + // This custom tile hasn't been and still isn't visible -> ignore. + if (!oldSbnVisible && !sbnVisible) { + continue; + } + + // This custom tile became invisible -> remove the old one. + if (oldSbnVisible && !sbnVisible) { + final StatusBarPanelCustomTile oldSbcClone = oldSbc.clone(); + mHandler.post(new Runnable() { + @Override + public void run() { + notifyRemoved(info, oldSbcClone); + } + }); + continue; + } + sbcClone = sbc.clone(); + + final StatusBarPanelCustomTile sbcToPost = sbcClone; + mHandler.post(new Runnable() { + @Override + public void run() { + notifyPosted(info, sbcToPost); + } + }); + } + } + + /** + * asynchronously notify all listeners about a removed custom tile + */ + public void notifyRemovedLocked(StatusBarPanelCustomTile sbc) { + // make a copy in case changes are made to the underlying CustomTile object + final StatusBarPanelCustomTile sbcClone = sbc.clone(); + for (final ManagedServiceInfo info : mServices) { + if (!isVisibleToListener(sbcClone, info)) { + continue; + } + mHandler.post(new Runnable() { + @Override + public void run() { + notifyRemoved(info, sbcClone); + } + }); + } + } + + private void notifyPosted(final ManagedServiceInfo info, + final StatusBarPanelCustomTile sbc) { + final ICustomTileListener listener = (ICustomTileListener)info.service; + StatusBarCustomTileHolder sbcHolder = new StatusBarCustomTileHolder(sbc); + try { + listener.onCustomTilePosted(sbcHolder); + } catch (RemoteException ex) { + Log.e(TAG, "unable to notify listener (posted): " + listener, ex); + } + } + + private void notifyRemoved(ManagedServiceInfo info, StatusBarPanelCustomTile sbc) { + if (!info.enabledAndUserMatches(sbc.getUserId())) { + return; + } + final ICustomTileListener listener = (ICustomTileListener) info.service; + StatusBarCustomTileHolder sbcHolder = new StatusBarCustomTileHolder(sbc); + try { + listener.onCustomTileRemoved(sbcHolder); + } catch (RemoteException ex) { + Log.e(TAG, "unable to notify listener (removed): " + listener, ex); + } + } + } + + /** + * Wrapper for a StatusBarPanelCustomTile object that allows transfer across a oneway + * binder without sending large amounts of data over a oneway transaction. + */ + private static final class StatusBarCustomTileHolder + extends IStatusBarCustomTileHolder.Stub { + private StatusBarPanelCustomTile mValue; + + public StatusBarCustomTileHolder(StatusBarPanelCustomTile value) { + mValue = value; + } + + /** Get the held value and clear it. This function should only be called once per holder */ + @Override + public StatusBarPanelCustomTile get() { + StatusBarPanelCustomTile value = mValue; + mValue = null; + return value; + } + } +} diff --git a/cm/lib/main/java/org/cyanogenmod/platform/internal/ManagedServices.java b/cm/lib/main/java/org/cyanogenmod/platform/internal/ManagedServices.java new file mode 100644 index 0000000..598d90c --- /dev/null +++ b/cm/lib/main/java/org/cyanogenmod/platform/internal/ManagedServices.java @@ -0,0 +1,634 @@ +/** + * Copyright (c) 2014, 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 org.cyanogenmod.platform.internal; + +import android.app.ActivityManager; +import android.app.PendingIntent; +import android.content.ComponentName; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.content.pm.ServiceInfo; +import android.content.pm.UserInfo; +import android.database.ContentObserver; +import android.net.Uri; +import android.os.Build; +import android.os.Handler; +import android.os.IBinder; +import android.os.IInterface; +import android.os.RemoteException; +import android.os.UserHandle; +import android.os.UserManager; +import android.provider.Settings; +import android.text.TextUtils; +import android.util.ArraySet; +import android.util.Log; +import android.util.Slog; +import android.util.SparseArray; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Set; + +import com.android.internal.R; + +/** + * Manages the lifecycle of application-provided services bound by system server. + * + * Services managed by this helper must have: + * - An associated system settings value with a list of enabled component names. + * - A well-known action for services to use in their intent-filter. + * - A system permission for services to require in order to ensure system has exclusive binding. + * - A settings page for user configuration of enabled services, and associated intent action. + * - A remote interface definition (aidl) provided by the service used for communication. + */ +abstract public class ManagedServices { + protected final String TAG = getClass().getSimpleName(); + protected final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); + + private static final String ENABLED_SERVICES_SEPARATOR = ":"; + + protected final Context mContext; + protected final Object mMutex; + private final UserProfiles mUserProfiles; + private final SettingsObserver mSettingsObserver; + private final Config mConfig; + + // contains connections to all connected services, including app services + // and system services + protected final ArrayList<ManagedServiceInfo> mServices = new ArrayList<ManagedServiceInfo>(); + // things that will be put into mServices as soon as they're ready + private final ArrayList<String> mServicesBinding = new ArrayList<String>(); + // lists the component names of all enabled (and therefore connected) + // app services for current profiles. + private ArraySet<ComponentName> mEnabledServicesForCurrentProfiles + = new ArraySet<ComponentName>(); + // Just the packages from mEnabledServicesForCurrentProfiles + private ArraySet<String> mEnabledServicesPackageNames = new ArraySet<String>(); + + // Kept to de-dupe user change events (experienced after boot, when we receive a settings and a + // user change). + private int[] mLastSeenProfileIds; + + public ManagedServices(Context context, Handler handler, Object mutex, + UserProfiles userProfiles) { + mContext = context; + mMutex = mutex; + mUserProfiles = userProfiles; + mConfig = getConfig(); + mSettingsObserver = new SettingsObserver(handler); + } + + abstract protected Config getConfig(); + + private String getCaption() { + return mConfig.caption; + } + + abstract protected IInterface asInterface(IBinder binder); + + abstract protected void onServiceAdded(ManagedServiceInfo info); + + protected void onServiceRemovedLocked(ManagedServiceInfo removed) { } + + private ManagedServiceInfo newServiceInfo(IInterface service, + ComponentName component, int userid, boolean isSystem, ServiceConnection connection, + int targetSdkVersion) { + return new ManagedServiceInfo(service, component, userid, isSystem, connection, + targetSdkVersion); + } + + public void onBootPhaseAppsCanStart() { + mSettingsObserver.observe(); + } + + public void onPackagesChanged(boolean queryReplace, String[] pkgList) { + if (DEBUG) Slog.d(TAG, "onPackagesChanged queryReplace=" + queryReplace + + " pkgList=" + (pkgList == null ? null : Arrays.asList(pkgList)) + + " mEnabledServicesPackageNames=" + mEnabledServicesPackageNames); + boolean anyServicesInvolved = false; + if (pkgList != null && (pkgList.length > 0)) { + for (String pkgName : pkgList) { + if (mEnabledServicesPackageNames.contains(pkgName)) { + anyServicesInvolved = true; + } + } + } + + if (anyServicesInvolved) { + // if we're not replacing a package, clean up orphaned bits + if (!queryReplace) { + disableNonexistentServices(); + } + // make sure we're still bound to any of our services who may have just upgraded + rebindServices(); + } + } + + public void onUserSwitched() { + if (DEBUG) Slog.d(TAG, "onUserSwitched"); + if (Arrays.equals(mLastSeenProfileIds, mUserProfiles.getCurrentProfileIds())) { + if (DEBUG) Slog.d(TAG, "Current profile IDs didn't change, skipping rebindServices()."); + return; + } + rebindServices(); + } + + public ManagedServiceInfo checkServiceTokenLocked(IInterface service) { + checkNotNull(service); + final IBinder token = service.asBinder(); + final int N = mServices.size(); + for (int i=0; i<N; i++) { + final ManagedServiceInfo info = mServices.get(i); + if (info.service.asBinder() == token) return info; + } + throw new SecurityException("Disallowed call from unknown " + getCaption() + ": " + + service); + } + + public void unregisterService(IInterface service, int userid) { + checkNotNull(service); + // no need to check permissions; if your service binder is in the list, + // that's proof that you had permission to add it in the first place + unregisterServiceImpl(service, userid); + } + + public void registerService(IInterface service, ComponentName component, int userid) { + checkNotNull(service); + ManagedServiceInfo info = registerServiceImpl(service, component, userid); + if (info != null) { + onServiceAdded(info); + } + } + + /** + * Remove access for any services that no longer exist. + */ + private void disableNonexistentServices() { + int[] userIds = mUserProfiles.getCurrentProfileIds(); + final int N = userIds.length; + for (int i = 0 ; i < N; ++i) { + disableNonexistentServices(userIds[i]); + } + } + + private void disableNonexistentServices(int userId) { + String flatIn = Settings.Secure.getStringForUser( + mContext.getContentResolver(), + mConfig.secureSettingName, + userId); + if (!TextUtils.isEmpty(flatIn)) { + if (DEBUG) Slog.v(TAG, "flat before: " + flatIn); + PackageManager pm = mContext.getPackageManager(); + List<ResolveInfo> installedServices = pm.queryIntentServicesAsUser( + new Intent(mConfig.serviceInterface), + PackageManager.GET_SERVICES | PackageManager.GET_META_DATA, + userId); + if (DEBUG) Slog.v(TAG, mConfig.serviceInterface + " services: " + installedServices); + Set<ComponentName> installed = new ArraySet<ComponentName>(); + for (int i = 0, count = installedServices.size(); i < count; i++) { + ResolveInfo resolveInfo = installedServices.get(i); + ServiceInfo info = resolveInfo.serviceInfo; + + if (!mConfig.bindPermission.equals(info.permission)) { + Slog.w(TAG, "Skipping " + getCaption() + " service " + + info.packageName + "/" + info.name + + ": it does not require the permission " + + mConfig.bindPermission); + continue; + } + installed.add(new ComponentName(info.packageName, info.name)); + } + + String flatOut = ""; + if (!installed.isEmpty()) { + String[] enabled = flatIn.split(ENABLED_SERVICES_SEPARATOR); + ArrayList<String> remaining = new ArrayList<String>(enabled.length); + for (int i = 0; i < enabled.length; i++) { + ComponentName enabledComponent = ComponentName.unflattenFromString(enabled[i]); + if (installed.contains(enabledComponent)) { + remaining.add(enabled[i]); + } + } + flatOut = TextUtils.join(ENABLED_SERVICES_SEPARATOR, remaining); + } + if (DEBUG) Slog.v(TAG, "flat after: " + flatOut); + if (!flatIn.equals(flatOut)) { + Settings.Secure.putStringForUser(mContext.getContentResolver(), + mConfig.secureSettingName, + flatOut, userId); + } + } + } + + /** + * Called whenever packages change, the user switches, or the secure setting + * is altered. (For example in response to USER_SWITCHED in our broadcast receiver) + */ + private void rebindServices() { + if (DEBUG) Slog.d(TAG, "rebindServices"); + final int[] userIds = mUserProfiles.getCurrentProfileIds(); + final int nUserIds = userIds.length; + + final SparseArray<String> flat = new SparseArray<String>(); + + for (int i = 0; i < nUserIds; ++i) { + flat.put(userIds[i], Settings.Secure.getStringForUser( + mContext.getContentResolver(), + mConfig.secureSettingName, + userIds[i])); + } + + ArrayList<ManagedServiceInfo> toRemove = new ArrayList<ManagedServiceInfo>(); + final SparseArray<ArrayList<ComponentName>> toAdd + = new SparseArray<ArrayList<ComponentName>>(); + + synchronized (mMutex) { + // Unbind automatically bound services, retain system services. + for (ManagedServiceInfo service : mServices) { + if (!service.isSystem) { + toRemove.add(service); + } + } + + final ArraySet<ComponentName> newEnabled = new ArraySet<ComponentName>(); + final ArraySet<String> newPackages = new ArraySet<String>(); + + for (int i = 0; i < nUserIds; ++i) { + final ArrayList<ComponentName> add = new ArrayList<ComponentName>(); + toAdd.put(userIds[i], add); + + // decode the list of components + String toDecode = flat.get(userIds[i]); + if (toDecode != null) { + String[] components = toDecode.split(ENABLED_SERVICES_SEPARATOR); + for (int j = 0; j < components.length; j++) { + final ComponentName component + = ComponentName.unflattenFromString(components[j]); + if (component != null) { + newEnabled.add(component); + add.add(component); + newPackages.add(component.getPackageName()); + } + } + + } + } + mEnabledServicesForCurrentProfiles = newEnabled; + mEnabledServicesPackageNames = newPackages; + } + + for (ManagedServiceInfo info : toRemove) { + final ComponentName component = info.component; + final int oldUser = info.userid; + Slog.v(TAG, "disabling " + getCaption() + " for user " + + oldUser + ": " + component); + unregisterService(component, info.userid); + } + + for (int i = 0; i < nUserIds; ++i) { + final ArrayList<ComponentName> add = toAdd.get(userIds[i]); + final int N = add.size(); + for (int j = 0; j < N; j++) { + final ComponentName component = add.get(j); + Slog.v(TAG, "enabling " + getCaption() + " for user " + userIds[i] + ": " + + component); + registerService(component, userIds[i]); + } + } + + mLastSeenProfileIds = mUserProfiles.getCurrentProfileIds(); + } + + /** + * Version of registerService that takes the name of a service component to bind to. + */ + private void registerService(final ComponentName name, final int userid) { + if (DEBUG) Slog.v(TAG, "registerService: " + name + " u=" + userid); + + synchronized (mMutex) { + final String servicesBindingTag = name.toString() + "/" + userid; + if (mServicesBinding.contains(servicesBindingTag)) { + // stop registering this thing already! we're working on it + return; + } + mServicesBinding.add(servicesBindingTag); + + final int N = mServices.size(); + for (int i=N-1; i>=0; i--) { + final ManagedServiceInfo info = mServices.get(i); + if (name.equals(info.component) + && info.userid == userid) { + // cut old connections + if (DEBUG) Slog.v(TAG, " disconnecting old " + getCaption() + ": " + + info.service); + removeServiceLocked(i); + if (info.connection != null) { + mContext.unbindService(info.connection); + } + } + } + + Intent intent = new Intent(mConfig.serviceInterface); + intent.setComponent(name); + + intent.putExtra(Intent.EXTRA_CLIENT_LABEL, mConfig.clientLabel); + + final PendingIntent pendingIntent = PendingIntent.getActivity( + mContext, 0, new Intent(mConfig.settingsAction), 0); + intent.putExtra(Intent.EXTRA_CLIENT_INTENT, pendingIntent); + + ApplicationInfo appInfo = null; + try { + appInfo = mContext.getPackageManager().getApplicationInfo( + name.getPackageName(), 0); + } catch (PackageManager.NameNotFoundException e) { + // Ignore if the package doesn't exist we won't be able to bind to the service. + } + final int targetSdkVersion = + appInfo != null ? appInfo.targetSdkVersion : Build.VERSION_CODES.BASE; + + try { + if (DEBUG) Slog.v(TAG, "binding: " + intent); + if (!mContext.bindServiceAsUser(intent, + new ServiceConnection() { + IInterface mService; + + @Override + public void onServiceConnected(ComponentName name, IBinder binder) { + boolean added = false; + ManagedServiceInfo info = null; + synchronized (mMutex) { + mServicesBinding.remove(servicesBindingTag); + try { + mService = asInterface(binder); + info = newServiceInfo(mService, name, + userid, false /*isSystem*/, this, targetSdkVersion); + binder.linkToDeath(info, 0); + added = mServices.add(info); + } catch (RemoteException e) { + // already dead + } + } + if (added) { + onServiceAdded(info); + } + } + + @Override + public void onServiceDisconnected(ComponentName name) { + Slog.v(TAG, getCaption() + " connection lost: " + name); + } + }, + Context.BIND_AUTO_CREATE, + new UserHandle(userid))) + { + mServicesBinding.remove(servicesBindingTag); + Slog.w(TAG, "Unable to bind " + getCaption() + " service: " + intent); + return; + } + } catch (SecurityException ex) { + Slog.e(TAG, "Unable to bind " + getCaption() + " service: " + intent, ex); + return; + } + } + } + + /** + * Remove a service for the given user by ComponentName + */ + private void unregisterService(ComponentName name, int userid) { + synchronized (mMutex) { + final int N = mServices.size(); + for (int i=N-1; i>=0; i--) { + final ManagedServiceInfo info = mServices.get(i); + if (name.equals(info.component) + && info.userid == userid) { + removeServiceLocked(i); + if (info.connection != null) { + try { + mContext.unbindService(info.connection); + } catch (IllegalArgumentException ex) { + // something happened to the service: we think we have a connection + // but it's bogus. + Slog.e(TAG, getCaption() + " " + name + " could not be unbound: " + ex); + } + } + } + } + } + } + + /** + * Removes a service from the list but does not unbind + * + * @return the removed service. + */ + private ManagedServiceInfo removeServiceImpl(IInterface service, final int userid) { + if (DEBUG) Slog.d(TAG, "removeServiceImpl service=" + service + " u=" + userid); + ManagedServiceInfo serviceInfo = null; + synchronized (mMutex) { + final int N = mServices.size(); + for (int i=N-1; i>=0; i--) { + final ManagedServiceInfo info = mServices.get(i); + if (info.service.asBinder() == service.asBinder() + && info.userid == userid) { + if (DEBUG) Slog.d(TAG, "Removing active service " + info.component); + serviceInfo = removeServiceLocked(i); + } + } + } + return serviceInfo; + } + + private ManagedServiceInfo removeServiceLocked(int i) { + final ManagedServiceInfo info = mServices.remove(i); + onServiceRemovedLocked(info); + return info; + } + + private void checkNotNull(IInterface service) { + if (service == null) { + throw new IllegalArgumentException(getCaption() + " must not be null"); + } + } + + private ManagedServiceInfo registerServiceImpl(final IInterface service, + final ComponentName component, final int userid) { + synchronized (mMutex) { + try { + ManagedServiceInfo info = newServiceInfo(service, component, userid, + true /*isSystem*/, null, Build.VERSION_CODES.LOLLIPOP); + service.asBinder().linkToDeath(info, 0); + mServices.add(info); + return info; + } catch (RemoteException e) { + // already dead + } + } + return null; + } + + /** + * Removes a service from the list and unbinds. + */ + private void unregisterServiceImpl(IInterface service, int userid) { + ManagedServiceInfo info = removeServiceImpl(service, userid); + if (info != null && info.connection != null) { + mContext.unbindService(info.connection); + } + } + + private class SettingsObserver extends ContentObserver { + private final Uri mSecureSettingsUri = Settings.Secure.getUriFor(mConfig.secureSettingName); + + private SettingsObserver(Handler handler) { + super(handler); + } + + private void observe() { + ContentResolver resolver = mContext.getContentResolver(); + resolver.registerContentObserver(mSecureSettingsUri, + false, this, UserHandle.USER_ALL); + update(null); + } + + @Override + public void onChange(boolean selfChange, Uri uri) { + update(uri); + } + + private void update(Uri uri) { + if (uri == null || mSecureSettingsUri.equals(uri)) { + if (DEBUG) Slog.d(TAG, "Setting changed: mSecureSettingsUri=" + mSecureSettingsUri + + " / uri=" + uri); + rebindServices(); + } + } + } + + public class ManagedServiceInfo implements IBinder.DeathRecipient { + public IInterface service; + public ComponentName component; + public int userid; + public boolean isSystem; + public ServiceConnection connection; + public int targetSdkVersion; + + public ManagedServiceInfo(IInterface service, ComponentName component, + int userid, boolean isSystem, ServiceConnection connection, int targetSdkVersion) { + this.service = service; + this.component = component; + this.userid = userid; + this.isSystem = isSystem; + this.connection = connection; + this.targetSdkVersion = targetSdkVersion; + } + + @Override + public String toString() { + return new StringBuilder("ManagedServiceInfo[") + .append("component=").append(component) + .append(",userid=").append(userid) + .append(",isSystem=").append(isSystem) + .append(",targetSdkVersion=").append(targetSdkVersion) + .append(",connection=").append(connection == null ? null : "<connection>") + .append(",service=").append(service) + .append(']').toString(); + } + + public boolean enabledAndUserMatches(int nid) { + if (!isEnabledForCurrentProfiles()) { + return false; + } + if (this.userid == UserHandle.USER_ALL) return true; + if (nid == UserHandle.USER_ALL || nid == this.userid) return true; + return supportsProfiles() && mUserProfiles.isCurrentProfile(nid); + } + + public boolean supportsProfiles() { + return targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP; + } + + @Override + public void binderDied() { + if (DEBUG) Slog.d(TAG, "binderDied"); + // Remove the service, but don't unbind from the service. The system will bring the + // service back up, and the onServiceConnected handler will readd the service with the + // new binding. If this isn't a bound service, and is just a registered + // service, just removing it from the list is all we need to do anyway. + removeServiceImpl(this.service, this.userid); + } + + /** convenience method for looking in mEnabledServicesForCurrentProfiles */ + public boolean isEnabledForCurrentProfiles() { + if (this.isSystem) return true; + if (this.connection == null) return false; + return mEnabledServicesForCurrentProfiles.contains(this.component); + } + } + + public static class UserProfiles { + // Profiles of the current user. + private final SparseArray<UserInfo> mCurrentProfiles = new SparseArray<UserInfo>(); + + public void updateCache(Context context) { + UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE); + if (userManager != null) { + int currentUserId = ActivityManager.getCurrentUser(); + List<UserInfo> profiles = userManager.getProfiles(currentUserId); + synchronized (mCurrentProfiles) { + mCurrentProfiles.clear(); + for (UserInfo user : profiles) { + mCurrentProfiles.put(user.id, user); + } + } + } + } + + public int[] getCurrentProfileIds() { + synchronized (mCurrentProfiles) { + int[] users = new int[mCurrentProfiles.size()]; + final int N = mCurrentProfiles.size(); + for (int i = 0; i < N; ++i) { + users[i] = mCurrentProfiles.keyAt(i); + } + return users; + } + } + + public boolean isCurrentProfile(int userId) { + synchronized (mCurrentProfiles) { + return mCurrentProfiles.get(userId) != null; + } + } + } + + protected static class Config { + public String caption; + public String serviceInterface; + public String secureSettingName; + public String bindPermission; + public String settingsAction; + public int clientLabel; + } +}
\ No newline at end of file |