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