1 /** 2 * Copyright (c) 2014, The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.notification; 18 19 import static android.content.Context.BIND_ALLOW_WHITELIST_MANAGEMENT; 20 import static android.content.Context.BIND_AUTO_CREATE; 21 import static android.content.Context.BIND_FOREGROUND_SERVICE; 22 23 import android.annotation.NonNull; 24 import android.app.ActivityManager; 25 import android.app.PendingIntent; 26 import android.content.BroadcastReceiver; 27 import android.content.ComponentName; 28 import android.content.ContentResolver; 29 import android.content.Context; 30 import android.content.Intent; 31 import android.content.IntentFilter; 32 import android.content.ServiceConnection; 33 import android.content.pm.ApplicationInfo; 34 import android.content.pm.PackageManager; 35 import android.content.pm.PackageManager.NameNotFoundException; 36 import android.content.pm.ResolveInfo; 37 import android.content.pm.ServiceInfo; 38 import android.content.pm.UserInfo; 39 import android.database.ContentObserver; 40 import android.net.Uri; 41 import android.os.Build; 42 import android.os.Handler; 43 import android.os.IBinder; 44 import android.os.IInterface; 45 import android.os.RemoteException; 46 import android.os.UserHandle; 47 import android.os.UserManager; 48 import android.provider.Settings; 49 import android.text.TextUtils; 50 import android.util.ArraySet; 51 import android.util.Log; 52 import android.util.Slog; 53 import android.util.SparseArray; 54 55 import com.android.server.notification.NotificationManagerService.DumpFilter; 56 57 import java.io.PrintWriter; 58 import java.util.ArrayList; 59 import java.util.Arrays; 60 import java.util.HashSet; 61 import java.util.List; 62 import java.util.Objects; 63 import java.util.Set; 64 65 /** 66 * Manages the lifecycle of application-provided services bound by system server. 67 * 68 * Services managed by this helper must have: 69 * - An associated system settings value with a list of enabled component names. 70 * - A well-known action for services to use in their intent-filter. 71 * - A system permission for services to require in order to ensure system has exclusive binding. 72 * - A settings page for user configuration of enabled services, and associated intent action. 73 * - A remote interface definition (aidl) provided by the service used for communication. 74 */ 75 abstract public class ManagedServices { 76 protected final String TAG = getClass().getSimpleName(); 77 protected final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); 78 79 protected static final String ENABLED_SERVICES_SEPARATOR = ":"; 80 81 protected final Context mContext; 82 protected final Object mMutex; 83 private final UserProfiles mUserProfiles; 84 private final SettingsObserver mSettingsObserver; 85 private final Config mConfig; 86 private ArraySet<String> mRestored; 87 88 // contains connections to all connected services, including app services 89 // and system services 90 protected final ArrayList<ManagedServiceInfo> mServices = new ArrayList<ManagedServiceInfo>(); 91 // things that will be put into mServices as soon as they're ready 92 private final ArrayList<String> mServicesBinding = new ArrayList<String>(); 93 // lists the component names of all enabled (and therefore potentially connected) 94 // app services for current profiles. 95 private ArraySet<ComponentName> mEnabledServicesForCurrentProfiles 96 = new ArraySet<ComponentName>(); 97 // Just the packages from mEnabledServicesForCurrentProfiles 98 private ArraySet<String> mEnabledServicesPackageNames = new ArraySet<String>(); 99 // List of packages in restored setting across all mUserProfiles, for quick 100 // filtering upon package updates. 101 private ArraySet<String> mRestoredPackages = new ArraySet<>(); 102 // List of enabled packages that have nevertheless asked not to be run 103 private ArraySet<ComponentName> mSnoozingForCurrentProfiles = new ArraySet<>(); 104 105 106 // Kept to de-dupe user change events (experienced after boot, when we receive a settings and a 107 // user change). 108 private int[] mLastSeenProfileIds; 109 110 private final BroadcastReceiver mRestoreReceiver; 111 112 public ManagedServices(Context context, Handler handler, Object mutex, 113 UserProfiles userProfiles) { 114 mContext = context; 115 mMutex = mutex; 116 mUserProfiles = userProfiles; 117 mConfig = getConfig(); 118 mSettingsObserver = new SettingsObserver(handler); 119 120 mRestoreReceiver = new SettingRestoredReceiver(); 121 IntentFilter filter = new IntentFilter(Intent.ACTION_SETTING_RESTORED); 122 context.registerReceiver(mRestoreReceiver, filter); 123 rebuildRestoredPackages(); 124 } 125 126 class SettingRestoredReceiver extends BroadcastReceiver { 127 @Override 128 public void onReceive(Context context, Intent intent) { 129 if (Intent.ACTION_SETTING_RESTORED.equals(intent.getAction())) { 130 String element = intent.getStringExtra(Intent.EXTRA_SETTING_NAME); 131 if (Objects.equals(element, mConfig.secureSettingName) 132 || Objects.equals(element, mConfig.secondarySettingName)) { 133 String prevValue = intent.getStringExtra(Intent.EXTRA_SETTING_PREVIOUS_VALUE); 134 String newValue = intent.getStringExtra(Intent.EXTRA_SETTING_NEW_VALUE); 135 settingRestored(element, prevValue, newValue, getSendingUserId()); 136 } 137 } 138 } 139 } 140 141 abstract protected Config getConfig(); 142 143 private String getCaption() { 144 return mConfig.caption; 145 } 146 147 abstract protected IInterface asInterface(IBinder binder); 148 149 abstract protected boolean checkType(IInterface service); 150 151 abstract protected void onServiceAdded(ManagedServiceInfo info); 152 153 protected void onServiceRemovedLocked(ManagedServiceInfo removed) { } 154 155 private ManagedServiceInfo newServiceInfo(IInterface service, 156 ComponentName component, int userid, boolean isSystem, ServiceConnection connection, 157 int targetSdkVersion) { 158 return new ManagedServiceInfo(service, component, userid, isSystem, connection, 159 targetSdkVersion); 160 } 161 162 public void onBootPhaseAppsCanStart() { 163 mSettingsObserver.observe(); 164 } 165 166 public void dump(PrintWriter pw, DumpFilter filter) { 167 pw.println(" All " + getCaption() + "s (" + mEnabledServicesForCurrentProfiles.size() 168 + ") enabled for current profiles:"); 169 for (ComponentName cmpt : mEnabledServicesForCurrentProfiles) { 170 if (filter != null && !filter.matches(cmpt)) continue; 171 pw.println(" " + cmpt); 172 } 173 174 pw.println(" Live " + getCaption() + "s (" + mServices.size() + "):"); 175 for (ManagedServiceInfo info : mServices) { 176 if (filter != null && !filter.matches(info.component)) continue; 177 pw.println(" " + info.component 178 + " (user " + info.userid + "): " + info.service 179 + (info.isSystem?" SYSTEM":"") 180 + (info.isGuest(this)?" GUEST":"")); 181 } 182 183 pw.println(" Snoozed " + getCaption() + "s (" + 184 mSnoozingForCurrentProfiles.size() + "):"); 185 for (ComponentName name : mSnoozingForCurrentProfiles) { 186 pw.println(" " + name.flattenToShortString()); 187 } 188 } 189 190 // By convention, restored settings are replicated to another settings 191 // entry, named similarly but with a disambiguation suffix. 192 public static String restoredSettingName(String setting) { 193 return setting + ":restored"; 194 } 195 196 // The OS has done a restore of this service's saved state. We clone it to the 197 // 'restored' reserve, and then once we return and the actual write to settings is 198 // performed, our observer will do the work of maintaining the restored vs live 199 // settings data. 200 public void settingRestored(String element, String oldValue, String newValue, int userid) { 201 if (DEBUG) Slog.d(TAG, "Restored managed service setting: " + element 202 + " ovalue=" + oldValue + " nvalue=" + newValue); 203 if (mConfig.secureSettingName.equals(element) || 204 mConfig.secondarySettingName.equals(element)) { 205 if (element != null) { 206 Settings.Secure.putStringForUser(mContext.getContentResolver(), 207 restoredSettingName(element), 208 newValue, 209 userid); 210 updateSettingsAccordingToInstalledServices(element, userid); 211 rebuildRestoredPackages(); 212 } 213 } 214 } 215 216 public boolean isComponentEnabledForPackage(String pkg) { 217 return mEnabledServicesPackageNames.contains(pkg); 218 } 219 220 public void onPackagesChanged(boolean queryReplace, String[] pkgList) { 221 if (DEBUG) Slog.d(TAG, "onPackagesChanged queryReplace=" + queryReplace 222 + " pkgList=" + (pkgList == null ? null : Arrays.asList(pkgList)) 223 + " mEnabledServicesPackageNames=" + mEnabledServicesPackageNames); 224 boolean anyServicesInvolved = false; 225 226 if (pkgList != null && (pkgList.length > 0)) { 227 for (String pkgName : pkgList) { 228 if (mEnabledServicesPackageNames.contains(pkgName) || 229 mRestoredPackages.contains(pkgName)) { 230 anyServicesInvolved = true; 231 } 232 } 233 } 234 235 if (anyServicesInvolved) { 236 // if we're not replacing a package, clean up orphaned bits 237 if (!queryReplace) { 238 updateSettingsAccordingToInstalledServices(); 239 rebuildRestoredPackages(); 240 } 241 // make sure we're still bound to any of our services who may have just upgraded 242 rebindServices(false); 243 } 244 } 245 246 public void onUserSwitched(int user) { 247 if (DEBUG) Slog.d(TAG, "onUserSwitched u=" + user); 248 rebuildRestoredPackages(); 249 if (Arrays.equals(mLastSeenProfileIds, mUserProfiles.getCurrentProfileIds())) { 250 if (DEBUG) Slog.d(TAG, "Current profile IDs didn't change, skipping rebindServices()."); 251 return; 252 } 253 rebindServices(true); 254 } 255 256 public void onUserUnlocked(int user) { 257 if (DEBUG) Slog.d(TAG, "onUserUnlocked u=" + user); 258 rebuildRestoredPackages(); 259 rebindServices(false); 260 } 261 262 public ManagedServiceInfo getServiceFromTokenLocked(IInterface service) { 263 if (service == null) { 264 return null; 265 } 266 final IBinder token = service.asBinder(); 267 final int N = mServices.size(); 268 for (int i = 0; i < N; i++) { 269 final ManagedServiceInfo info = mServices.get(i); 270 if (info.service.asBinder() == token) return info; 271 } 272 return null; 273 } 274 275 public ManagedServiceInfo checkServiceTokenLocked(IInterface service) { 276 checkNotNull(service); 277 ManagedServiceInfo info = getServiceFromTokenLocked(service); 278 if (info != null) { 279 return info; 280 } 281 throw new SecurityException("Disallowed call from unknown " + getCaption() + ": " 282 + service); 283 } 284 285 public void unregisterService(IInterface service, int userid) { 286 checkNotNull(service); 287 // no need to check permissions; if your service binder is in the list, 288 // that's proof that you had permission to add it in the first place 289 unregisterServiceImpl(service, userid); 290 } 291 292 public void registerService(IInterface service, ComponentName component, int userid) { 293 checkNotNull(service); 294 ManagedServiceInfo info = registerServiceImpl(service, component, userid); 295 if (info != null) { 296 onServiceAdded(info); 297 } 298 } 299 300 /** 301 * Add a service to our callbacks. The lifecycle of this service is managed externally, 302 * but unlike a system service, it should not be considered privledged. 303 * */ 304 public void registerGuestService(ManagedServiceInfo guest) { 305 checkNotNull(guest.service); 306 if (!checkType(guest.service)) { 307 throw new IllegalArgumentException(); 308 } 309 if (registerServiceImpl(guest) != null) { 310 onServiceAdded(guest); 311 } 312 } 313 314 public void setComponentState(ComponentName component, boolean enabled) { 315 boolean previous = !mSnoozingForCurrentProfiles.contains(component); 316 if (previous == enabled) { 317 return; 318 } 319 320 if (enabled) { 321 mSnoozingForCurrentProfiles.remove(component); 322 } else { 323 mSnoozingForCurrentProfiles.add(component); 324 } 325 326 // State changed 327 if (DEBUG) { 328 Slog.d(TAG, ((enabled) ? "Enabling " : "Disabling ") + "component " + 329 component.flattenToShortString()); 330 } 331 332 333 synchronized (mMutex) { 334 final int[] userIds = mUserProfiles.getCurrentProfileIds(); 335 336 for (int userId : userIds) { 337 if (enabled) { 338 registerServiceLocked(component, userId); 339 } else { 340 unregisterServiceLocked(component, userId); 341 } 342 } 343 } 344 } 345 346 private void rebuildRestoredPackages() { 347 mRestoredPackages.clear(); 348 mSnoozingForCurrentProfiles.clear(); 349 String secureSettingName = restoredSettingName(mConfig.secureSettingName); 350 String secondarySettingName = mConfig.secondarySettingName == null 351 ? null : restoredSettingName(mConfig.secondarySettingName); 352 int[] userIds = mUserProfiles.getCurrentProfileIds(); 353 final int N = userIds.length; 354 for (int i = 0; i < N; ++i) { 355 ArraySet<ComponentName> names = 356 loadComponentNamesFromSetting(secureSettingName, userIds[i]); 357 if (secondarySettingName != null) { 358 names.addAll(loadComponentNamesFromSetting(secondarySettingName, userIds[i])); 359 } 360 for (ComponentName name : names) { 361 mRestoredPackages.add(name.getPackageName()); 362 } 363 } 364 } 365 366 367 protected @NonNull ArraySet<ComponentName> loadComponentNamesFromSetting(String settingName, 368 int userId) { 369 final ContentResolver cr = mContext.getContentResolver(); 370 String settingValue = Settings.Secure.getStringForUser( 371 cr, 372 settingName, 373 userId); 374 if (TextUtils.isEmpty(settingValue)) 375 return new ArraySet<>(); 376 String[] restored = settingValue.split(ENABLED_SERVICES_SEPARATOR); 377 ArraySet<ComponentName> result = new ArraySet<>(restored.length); 378 for (int i = 0; i < restored.length; i++) { 379 ComponentName value = ComponentName.unflattenFromString(restored[i]); 380 if (null != value) { 381 result.add(value); 382 } 383 } 384 return result; 385 } 386 387 private void storeComponentsToSetting(Set<ComponentName> components, 388 String settingName, 389 int userId) { 390 String[] componentNames = null; 391 if (null != components) { 392 componentNames = new String[components.size()]; 393 int index = 0; 394 for (ComponentName c: components) { 395 componentNames[index++] = c.flattenToString(); 396 } 397 } 398 final String value = (componentNames == null) ? "" : 399 TextUtils.join(ENABLED_SERVICES_SEPARATOR, componentNames); 400 final ContentResolver cr = mContext.getContentResolver(); 401 Settings.Secure.putStringForUser( 402 cr, 403 settingName, 404 value, 405 userId); 406 } 407 408 /** 409 * Remove access for any services that no longer exist. 410 */ 411 private void updateSettingsAccordingToInstalledServices() { 412 int[] userIds = mUserProfiles.getCurrentProfileIds(); 413 final int N = userIds.length; 414 for (int i = 0; i < N; ++i) { 415 updateSettingsAccordingToInstalledServices(mConfig.secureSettingName, userIds[i]); 416 if (mConfig.secondarySettingName != null) { 417 updateSettingsAccordingToInstalledServices( 418 mConfig.secondarySettingName, userIds[i]); 419 } 420 } 421 rebuildRestoredPackages(); 422 } 423 424 protected Set<ComponentName> queryPackageForServices(String packageName, int userId) { 425 Set<ComponentName> installed = new ArraySet<>(); 426 final PackageManager pm = mContext.getPackageManager(); 427 Intent queryIntent = new Intent(mConfig.serviceInterface); 428 if (!TextUtils.isEmpty(packageName)) { 429 queryIntent.setPackage(packageName); 430 } 431 List<ResolveInfo> installedServices = pm.queryIntentServicesAsUser( 432 queryIntent, 433 PackageManager.GET_SERVICES | PackageManager.GET_META_DATA, 434 userId); 435 if (DEBUG) 436 Slog.v(TAG, mConfig.serviceInterface + " services: " + installedServices); 437 if (installedServices != null) { 438 for (int i = 0, count = installedServices.size(); i < count; i++) { 439 ResolveInfo resolveInfo = installedServices.get(i); 440 ServiceInfo info = resolveInfo.serviceInfo; 441 442 ComponentName component = new ComponentName(info.packageName, info.name); 443 if (!mConfig.bindPermission.equals(info.permission)) { 444 Slog.w(TAG, "Skipping " + getCaption() + " service " 445 + info.packageName + "/" + info.name 446 + ": it does not require the permission " 447 + mConfig.bindPermission); 448 continue; 449 } 450 installed.add(component); 451 } 452 } 453 return installed; 454 } 455 456 private void updateSettingsAccordingToInstalledServices(String setting, int userId) { 457 boolean restoredChanged = false; 458 boolean currentChanged = false; 459 Set<ComponentName> restored = 460 loadComponentNamesFromSetting(restoredSettingName(setting), userId); 461 Set<ComponentName> current = 462 loadComponentNamesFromSetting(setting, userId); 463 // Load all services for all packages. 464 Set<ComponentName> installed = queryPackageForServices(null, userId); 465 466 ArraySet<ComponentName> retained = new ArraySet<>(); 467 468 for (ComponentName component : installed) { 469 if (null != restored) { 470 boolean wasRestored = restored.remove(component); 471 if (wasRestored) { 472 // Freshly installed package has service that was mentioned in restored setting. 473 if (DEBUG) 474 Slog.v(TAG, "Restoring " + component + " for user " + userId); 475 restoredChanged = true; 476 currentChanged = true; 477 retained.add(component); 478 continue; 479 } 480 } 481 482 if (null != current) { 483 if (current.contains(component)) 484 retained.add(component); 485 } 486 } 487 488 currentChanged |= ((current == null ? 0 : current.size()) != retained.size()); 489 490 if (currentChanged) { 491 if (DEBUG) Slog.v(TAG, "List of " + getCaption() + " services was updated " + current); 492 storeComponentsToSetting(retained, setting, userId); 493 } 494 495 if (restoredChanged) { 496 if (DEBUG) Slog.v(TAG, 497 "List of " + getCaption() + " restored services was updated " + restored); 498 storeComponentsToSetting(restored, restoredSettingName(setting), userId); 499 } 500 } 501 502 /** 503 * Called whenever packages change, the user switches, or the secure setting 504 * is altered. (For example in response to USER_SWITCHED in our broadcast receiver) 505 */ 506 private void rebindServices(boolean forceRebind) { 507 if (DEBUG) Slog.d(TAG, "rebindServices"); 508 final int[] userIds = mUserProfiles.getCurrentProfileIds(); 509 final int nUserIds = userIds.length; 510 511 final SparseArray<ArraySet<ComponentName>> componentsByUser = new SparseArray<>(); 512 513 for (int i = 0; i < nUserIds; ++i) { 514 componentsByUser.put(userIds[i], 515 loadComponentNamesFromSetting(mConfig.secureSettingName, userIds[i])); 516 if (mConfig.secondarySettingName != null) { 517 componentsByUser.get(userIds[i]).addAll( 518 loadComponentNamesFromSetting(mConfig.secondarySettingName, userIds[i])); 519 } 520 } 521 522 final ArrayList<ManagedServiceInfo> removableBoundServices = new ArrayList<>(); 523 final SparseArray<Set<ComponentName>> toAdd = new SparseArray<>(); 524 525 synchronized (mMutex) { 526 // Rebind to non-system services if user switched 527 for (ManagedServiceInfo service : mServices) { 528 if (!service.isSystem && !service.isGuest(this)) { 529 removableBoundServices.add(service); 530 } 531 } 532 533 mEnabledServicesForCurrentProfiles.clear(); 534 mEnabledServicesPackageNames.clear(); 535 536 for (int i = 0; i < nUserIds; ++i) { 537 // decode the list of components 538 final ArraySet<ComponentName> userComponents = componentsByUser.get(userIds[i]); 539 if (null == userComponents) { 540 toAdd.put(userIds[i], new ArraySet<ComponentName>()); 541 continue; 542 } 543 544 final Set<ComponentName> add = new HashSet<>(userComponents); 545 add.removeAll(mSnoozingForCurrentProfiles); 546 547 toAdd.put(userIds[i], add); 548 549 mEnabledServicesForCurrentProfiles.addAll(userComponents); 550 551 for (int j = 0; j < userComponents.size(); j++) { 552 final ComponentName component = userComponents.valueAt(j); 553 mEnabledServicesPackageNames.add(component.getPackageName()); 554 } 555 } 556 } 557 558 for (ManagedServiceInfo info : removableBoundServices) { 559 final ComponentName component = info.component; 560 final int oldUser = info.userid; 561 final Set<ComponentName> allowedComponents = toAdd.get(info.userid); 562 if (allowedComponents != null) { 563 if (allowedComponents.contains(component) && !forceRebind) { 564 // Already bound, don't need to bind again. 565 allowedComponents.remove(component); 566 } else { 567 // No longer allowed to be bound, or must rebind. 568 Slog.v(TAG, "disabling " + getCaption() + " for user " 569 + oldUser + ": " + component); 570 unregisterService(component, oldUser); 571 } 572 } 573 } 574 575 for (int i = 0; i < nUserIds; ++i) { 576 final Set<ComponentName> add = toAdd.get(userIds[i]); 577 for (ComponentName component : add) { 578 Slog.v(TAG, "enabling " + getCaption() + " for " + userIds[i] + ": " + component); 579 registerService(component, userIds[i]); 580 } 581 } 582 583 mLastSeenProfileIds = userIds; 584 } 585 586 /** 587 * Version of registerService that takes the name of a service component to bind to. 588 */ 589 private void registerService(final ComponentName name, final int userid) { 590 synchronized (mMutex) { 591 registerServiceLocked(name, userid); 592 } 593 } 594 595 /** 596 * Inject a system service into the management list. 597 */ 598 public void registerSystemService(final ComponentName name, final int userid) { 599 synchronized (mMutex) { 600 registerServiceLocked(name, userid, true /* isSystem */); 601 } 602 } 603 604 private void registerServiceLocked(final ComponentName name, final int userid) { 605 registerServiceLocked(name, userid, false /* isSystem */); 606 } 607 608 private void registerServiceLocked(final ComponentName name, final int userid, 609 final boolean isSystem) { 610 if (DEBUG) Slog.v(TAG, "registerService: " + name + " u=" + userid); 611 612 final String servicesBindingTag = name.toString() + "/" + userid; 613 if (mServicesBinding.contains(servicesBindingTag)) { 614 // stop registering this thing already! we're working on it 615 return; 616 } 617 mServicesBinding.add(servicesBindingTag); 618 619 final int N = mServices.size(); 620 for (int i = N - 1; i >= 0; i--) { 621 final ManagedServiceInfo info = mServices.get(i); 622 if (name.equals(info.component) 623 && info.userid == userid) { 624 // cut old connections 625 if (DEBUG) Slog.v(TAG, " disconnecting old " + getCaption() + ": " 626 + info.service); 627 removeServiceLocked(i); 628 if (info.connection != null) { 629 mContext.unbindService(info.connection); 630 } 631 } 632 } 633 634 Intent intent = new Intent(mConfig.serviceInterface); 635 intent.setComponent(name); 636 637 intent.putExtra(Intent.EXTRA_CLIENT_LABEL, mConfig.clientLabel); 638 639 final PendingIntent pendingIntent = PendingIntent.getActivity( 640 mContext, 0, new Intent(mConfig.settingsAction), 0); 641 intent.putExtra(Intent.EXTRA_CLIENT_INTENT, pendingIntent); 642 643 ApplicationInfo appInfo = null; 644 try { 645 appInfo = mContext.getPackageManager().getApplicationInfo( 646 name.getPackageName(), 0); 647 } catch (NameNotFoundException e) { 648 // Ignore if the package doesn't exist we won't be able to bind to the service. 649 } 650 final int targetSdkVersion = 651 appInfo != null ? appInfo.targetSdkVersion : Build.VERSION_CODES.BASE; 652 653 try { 654 if (DEBUG) Slog.v(TAG, "binding: " + intent); 655 ServiceConnection serviceConnection = new ServiceConnection() { 656 IInterface mService; 657 658 @Override 659 public void onServiceConnected(ComponentName name, IBinder binder) { 660 boolean added = false; 661 ManagedServiceInfo info = null; 662 synchronized (mMutex) { 663 mServicesBinding.remove(servicesBindingTag); 664 try { 665 mService = asInterface(binder); 666 info = newServiceInfo(mService, name, 667 userid, isSystem, this, targetSdkVersion); 668 binder.linkToDeath(info, 0); 669 added = mServices.add(info); 670 } catch (RemoteException e) { 671 // already dead 672 } 673 } 674 if (added) { 675 onServiceAdded(info); 676 } 677 } 678 679 @Override 680 public void onServiceDisconnected(ComponentName name) { 681 Slog.v(TAG, getCaption() + " connection lost: " + name); 682 } 683 }; 684 if (!mContext.bindServiceAsUser(intent, 685 serviceConnection, 686 BIND_AUTO_CREATE | BIND_FOREGROUND_SERVICE | BIND_ALLOW_WHITELIST_MANAGEMENT, 687 new UserHandle(userid))) { 688 mServicesBinding.remove(servicesBindingTag); 689 Slog.w(TAG, "Unable to bind " + getCaption() + " service: " + intent); 690 return; 691 } 692 } catch (SecurityException ex) { 693 Slog.e(TAG, "Unable to bind " + getCaption() + " service: " + intent, ex); 694 return; 695 } 696 } 697 698 /** 699 * Remove a service for the given user by ComponentName 700 */ 701 private void unregisterService(ComponentName name, int userid) { 702 synchronized (mMutex) { 703 unregisterServiceLocked(name, userid); 704 } 705 } 706 707 private void unregisterServiceLocked(ComponentName name, int userid) { 708 final int N = mServices.size(); 709 for (int i = N - 1; i >= 0; i--) { 710 final ManagedServiceInfo info = mServices.get(i); 711 if (name.equals(info.component) 712 && info.userid == userid) { 713 removeServiceLocked(i); 714 if (info.connection != null) { 715 try { 716 mContext.unbindService(info.connection); 717 } catch (IllegalArgumentException ex) { 718 // something happened to the service: we think we have a connection 719 // but it's bogus. 720 Slog.e(TAG, getCaption() + " " + name + " could not be unbound: " + ex); 721 } 722 } 723 } 724 } 725 } 726 727 /** 728 * Removes a service from the list but does not unbind 729 * 730 * @return the removed service. 731 */ 732 private ManagedServiceInfo removeServiceImpl(IInterface service, final int userid) { 733 if (DEBUG) Slog.d(TAG, "removeServiceImpl service=" + service + " u=" + userid); 734 ManagedServiceInfo serviceInfo = null; 735 synchronized (mMutex) { 736 final int N = mServices.size(); 737 for (int i = N - 1; i >= 0; i--) { 738 final ManagedServiceInfo info = mServices.get(i); 739 if (info.service.asBinder() == service.asBinder() 740 && info.userid == userid) { 741 if (DEBUG) Slog.d(TAG, "Removing active service " + info.component); 742 serviceInfo = removeServiceLocked(i); 743 } 744 } 745 } 746 return serviceInfo; 747 } 748 749 private ManagedServiceInfo removeServiceLocked(int i) { 750 final ManagedServiceInfo info = mServices.remove(i); 751 onServiceRemovedLocked(info); 752 return info; 753 } 754 755 private void checkNotNull(IInterface service) { 756 if (service == null) { 757 throw new IllegalArgumentException(getCaption() + " must not be null"); 758 } 759 } 760 761 private ManagedServiceInfo registerServiceImpl(final IInterface service, 762 final ComponentName component, final int userid) { 763 ManagedServiceInfo info = newServiceInfo(service, component, userid, 764 true /*isSystem*/, null /*connection*/, Build.VERSION_CODES.LOLLIPOP); 765 return registerServiceImpl(info); 766 } 767 768 private ManagedServiceInfo registerServiceImpl(ManagedServiceInfo info) { 769 synchronized (mMutex) { 770 try { 771 info.service.asBinder().linkToDeath(info, 0); 772 mServices.add(info); 773 return info; 774 } catch (RemoteException e) { 775 // already dead 776 } 777 } 778 return null; 779 } 780 781 /** 782 * Removes a service from the list and unbinds. 783 */ 784 private void unregisterServiceImpl(IInterface service, int userid) { 785 ManagedServiceInfo info = removeServiceImpl(service, userid); 786 if (info != null && info.connection != null && !info.isGuest(this)) { 787 mContext.unbindService(info.connection); 788 } 789 } 790 791 private class SettingsObserver extends ContentObserver { 792 private final Uri mSecureSettingsUri = Settings.Secure.getUriFor(mConfig.secureSettingName); 793 private final Uri mSecondarySettingsUri; 794 795 private SettingsObserver(Handler handler) { 796 super(handler); 797 if (mConfig.secondarySettingName != null) { 798 mSecondarySettingsUri = Settings.Secure.getUriFor(mConfig.secondarySettingName); 799 } else { 800 mSecondarySettingsUri = null; 801 } 802 } 803 804 private void observe() { 805 ContentResolver resolver = mContext.getContentResolver(); 806 resolver.registerContentObserver(mSecureSettingsUri, 807 false, this, UserHandle.USER_ALL); 808 if (mSecondarySettingsUri != null) { 809 resolver.registerContentObserver(mSecondarySettingsUri, 810 false, this, UserHandle.USER_ALL); 811 } 812 update(null); 813 } 814 815 @Override 816 public void onChange(boolean selfChange, Uri uri) { 817 update(uri); 818 } 819 820 private void update(Uri uri) { 821 if (uri == null || mSecureSettingsUri.equals(uri) 822 || uri.equals(mSecondarySettingsUri)) { 823 if (DEBUG) Slog.d(TAG, "Setting changed: uri=" + uri); 824 rebindServices(false); 825 rebuildRestoredPackages(); 826 } 827 } 828 } 829 830 public class ManagedServiceInfo implements IBinder.DeathRecipient { 831 public IInterface service; 832 public ComponentName component; 833 public int userid; 834 public boolean isSystem; 835 public ServiceConnection connection; 836 public int targetSdkVersion; 837 838 public ManagedServiceInfo(IInterface service, ComponentName component, 839 int userid, boolean isSystem, ServiceConnection connection, int targetSdkVersion) { 840 this.service = service; 841 this.component = component; 842 this.userid = userid; 843 this.isSystem = isSystem; 844 this.connection = connection; 845 this.targetSdkVersion = targetSdkVersion; 846 } 847 848 public boolean isGuest(ManagedServices host) { 849 return ManagedServices.this != host; 850 } 851 852 public ManagedServices getOwner() { 853 return ManagedServices.this; 854 } 855 856 @Override 857 public String toString() { 858 return new StringBuilder("ManagedServiceInfo[") 859 .append("component=").append(component) 860 .append(",userid=").append(userid) 861 .append(",isSystem=").append(isSystem) 862 .append(",targetSdkVersion=").append(targetSdkVersion) 863 .append(",connection=").append(connection == null ? null : "<connection>") 864 .append(",service=").append(service) 865 .append(']').toString(); 866 } 867 868 public boolean enabledAndUserMatches(int nid) { 869 if (!isEnabledForCurrentProfiles()) { 870 return false; 871 } 872 if (this.userid == UserHandle.USER_ALL) return true; 873 if (this.isSystem) return true; 874 if (nid == UserHandle.USER_ALL || nid == this.userid) return true; 875 return supportsProfiles() && mUserProfiles.isCurrentProfile(nid); 876 } 877 878 public boolean supportsProfiles() { 879 return targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP; 880 } 881 882 @Override 883 public void binderDied() { 884 if (DEBUG) Slog.d(TAG, "binderDied"); 885 // Remove the service, but don't unbind from the service. The system will bring the 886 // service back up, and the onServiceConnected handler will readd the service with the 887 // new binding. If this isn't a bound service, and is just a registered 888 // service, just removing it from the list is all we need to do anyway. 889 removeServiceImpl(this.service, this.userid); 890 } 891 892 /** convenience method for looking in mEnabledServicesForCurrentProfiles */ 893 public boolean isEnabledForCurrentProfiles() { 894 if (this.isSystem) return true; 895 if (this.connection == null) return false; 896 return mEnabledServicesForCurrentProfiles.contains(this.component); 897 } 898 } 899 900 /** convenience method for looking in mEnabledServicesForCurrentProfiles */ 901 public boolean isComponentEnabledForCurrentProfiles(ComponentName component) { 902 return mEnabledServicesForCurrentProfiles.contains(component); 903 } 904 905 public static class UserProfiles { 906 // Profiles of the current user. 907 private final SparseArray<UserInfo> mCurrentProfiles = new SparseArray<>(); 908 909 public void updateCache(@NonNull Context context) { 910 UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE); 911 if (userManager != null) { 912 int currentUserId = ActivityManager.getCurrentUser(); 913 List<UserInfo> profiles = userManager.getProfiles(currentUserId); 914 synchronized (mCurrentProfiles) { 915 mCurrentProfiles.clear(); 916 for (UserInfo user : profiles) { 917 mCurrentProfiles.put(user.id, user); 918 } 919 } 920 } 921 } 922 923 public int[] getCurrentProfileIds() { 924 synchronized (mCurrentProfiles) { 925 int[] users = new int[mCurrentProfiles.size()]; 926 final int N = mCurrentProfiles.size(); 927 for (int i = 0; i < N; ++i) { 928 users[i] = mCurrentProfiles.keyAt(i); 929 } 930 return users; 931 } 932 } 933 934 public boolean isCurrentProfile(int userId) { 935 synchronized (mCurrentProfiles) { 936 return mCurrentProfiles.get(userId) != null; 937 } 938 } 939 } 940 941 public static class Config { 942 public String caption; 943 public String serviceInterface; 944 public String secureSettingName; 945 public String secondarySettingName; 946 public String bindPermission; 947 public String settingsAction; 948 public int clientLabel; 949 } 950 } 951
