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 android.app.ActivityManager; 20 import android.app.PendingIntent; 21 import android.content.BroadcastReceiver; 22 import android.content.ComponentName; 23 import android.content.ContentResolver; 24 import android.content.Context; 25 import android.content.Intent; 26 import android.content.IntentFilter; 27 import android.content.ServiceConnection; 28 import android.content.pm.ApplicationInfo; 29 import android.content.pm.PackageManager; 30 import android.content.pm.PackageManager.NameNotFoundException; 31 import android.content.pm.ResolveInfo; 32 import android.content.pm.ServiceInfo; 33 import android.content.pm.UserInfo; 34 import android.database.ContentObserver; 35 import android.net.Uri; 36 import android.os.Build; 37 import android.os.Handler; 38 import android.os.IBinder; 39 import android.os.IInterface; 40 import android.os.RemoteException; 41 import android.os.UserHandle; 42 import android.os.UserManager; 43 import android.provider.Settings; 44 import android.text.TextUtils; 45 import android.util.ArraySet; 46 import android.util.Log; 47 import android.util.Slog; 48 import android.util.SparseArray; 49 50 import com.android.server.notification.NotificationManagerService.DumpFilter; 51 52 import java.io.PrintWriter; 53 import java.util.ArrayList; 54 import java.util.Arrays; 55 import java.util.List; 56 import java.util.Objects; 57 import java.util.Set; 58 59 /** 60 * Manages the lifecycle of application-provided services bound by system server. 61 * 62 * Services managed by this helper must have: 63 * - An associated system settings value with a list of enabled component names. 64 * - A well-known action for services to use in their intent-filter. 65 * - A system permission for services to require in order to ensure system has exclusive binding. 66 * - A settings page for user configuration of enabled services, and associated intent action. 67 * - A remote interface definition (aidl) provided by the service used for communication. 68 */ 69 abstract public class ManagedServices { 70 protected final String TAG = getClass().getSimpleName(); 71 protected final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); 72 73 private static final String ENABLED_SERVICES_SEPARATOR = ":"; 74 75 protected final Context mContext; 76 protected final Object mMutex; 77 private final UserProfiles mUserProfiles; 78 private final SettingsObserver mSettingsObserver; 79 private final Config mConfig; 80 private ArraySet<String> mRestored; 81 82 // contains connections to all connected services, including app services 83 // and system services 84 protected final ArrayList<ManagedServiceInfo> mServices = new ArrayList<ManagedServiceInfo>(); 85 // things that will be put into mServices as soon as they're ready 86 private final ArrayList<String> mServicesBinding = new ArrayList<String>(); 87 // lists the component names of all enabled (and therefore connected) 88 // app services for current profiles. 89 private ArraySet<ComponentName> mEnabledServicesForCurrentProfiles 90 = new ArraySet<ComponentName>(); 91 // Just the packages from mEnabledServicesForCurrentProfiles 92 private ArraySet<String> mEnabledServicesPackageNames = new ArraySet<String>(); 93 94 // Kept to de-dupe user change events (experienced after boot, when we receive a settings and a 95 // user change). 96 private int[] mLastSeenProfileIds; 97 98 private final BroadcastReceiver mRestoreReceiver; 99 100 public ManagedServices(Context context, Handler handler, Object mutex, 101 UserProfiles userProfiles) { 102 mContext = context; 103 mMutex = mutex; 104 mUserProfiles = userProfiles; 105 mConfig = getConfig(); 106 mSettingsObserver = new SettingsObserver(handler); 107 108 mRestoreReceiver = new SettingRestoredReceiver(); 109 IntentFilter filter = new IntentFilter(Intent.ACTION_SETTING_RESTORED); 110 context.registerReceiver(mRestoreReceiver, filter); 111 } 112 113 class SettingRestoredReceiver extends BroadcastReceiver { 114 @Override 115 public void onReceive(Context context, Intent intent) { 116 if (Intent.ACTION_SETTING_RESTORED.equals(intent.getAction())) { 117 String element = intent.getStringExtra(Intent.EXTRA_SETTING_NAME); 118 if (Objects.equals(element, mConfig.secureSettingName)) { 119 String prevValue = intent.getStringExtra(Intent.EXTRA_SETTING_PREVIOUS_VALUE); 120 String newValue = intent.getStringExtra(Intent.EXTRA_SETTING_NEW_VALUE); 121 settingRestored(element, prevValue, newValue, getSendingUserId()); 122 } 123 } 124 } 125 } 126 127 abstract protected Config getConfig(); 128 129 private String getCaption() { 130 return mConfig.caption; 131 } 132 133 abstract protected IInterface asInterface(IBinder binder); 134 135 abstract protected void onServiceAdded(ManagedServiceInfo info); 136 137 protected void onServiceRemovedLocked(ManagedServiceInfo removed) { } 138 139 private ManagedServiceInfo newServiceInfo(IInterface service, 140 ComponentName component, int userid, boolean isSystem, ServiceConnection connection, 141 int targetSdkVersion) { 142 return new ManagedServiceInfo(service, component, userid, isSystem, connection, 143 targetSdkVersion); 144 } 145 146 public void onBootPhaseAppsCanStart() { 147 mSettingsObserver.observe(); 148 } 149 150 public void dump(PrintWriter pw, DumpFilter filter) { 151 pw.println(" All " + getCaption() + "s (" + mEnabledServicesForCurrentProfiles.size() 152 + ") enabled for current profiles:"); 153 for (ComponentName cmpt : mEnabledServicesForCurrentProfiles) { 154 if (filter != null && !filter.matches(cmpt)) continue; 155 pw.println(" " + cmpt); 156 } 157 158 pw.println(" Live " + getCaption() + "s (" + mServices.size() + "):"); 159 for (ManagedServiceInfo info : mServices) { 160 if (filter != null && !filter.matches(info.component)) continue; 161 pw.println(" " + info.component 162 + " (user " + info.userid + "): " + info.service 163 + (info.isSystem?" SYSTEM":"")); 164 } 165 } 166 167 // By convention, restored settings are replicated to another settings 168 // entry, named similarly but with a disambiguation suffix. 169 public static final String restoredSettingName(Config config) { 170 return config.secureSettingName + ":restored"; 171 } 172 173 // The OS has done a restore of this service's saved state. We clone it to the 174 // 'restored' reserve, and then once we return and the actual write to settings is 175 // performed, our observer will do the work of maintaining the restored vs live 176 // settings data. 177 public void settingRestored(String element, String oldValue, String newValue, int userid) { 178 if (DEBUG) Slog.d(TAG, "Restored managed service setting: " + element 179 + " ovalue=" + oldValue + " nvalue=" + newValue); 180 if (mConfig.secureSettingName.equals(element)) { 181 if (element != null) { 182 mRestored = null; 183 Settings.Secure.putStringForUser(mContext.getContentResolver(), 184 restoredSettingName(mConfig), 185 newValue, 186 userid); 187 disableNonexistentServices(userid); 188 } 189 } 190 } 191 192 public boolean isComponentEnabledForPackage(String pkg) { 193 return mEnabledServicesPackageNames.contains(pkg); 194 } 195 196 public void onPackagesChanged(boolean queryReplace, String[] pkgList) { 197 if (DEBUG) Slog.d(TAG, "onPackagesChanged queryReplace=" + queryReplace 198 + " pkgList=" + (pkgList == null ? null : Arrays.asList(pkgList)) 199 + " mEnabledServicesPackageNames=" + mEnabledServicesPackageNames); 200 boolean anyServicesInvolved = false; 201 if (pkgList != null && (pkgList.length > 0)) { 202 for (String pkgName : pkgList) { 203 if (mEnabledServicesPackageNames.contains(pkgName)) { 204 anyServicesInvolved = true; 205 } 206 } 207 } 208 209 if (anyServicesInvolved) { 210 // if we're not replacing a package, clean up orphaned bits 211 if (!queryReplace) { 212 disableNonexistentServices(); 213 } 214 // make sure we're still bound to any of our services who may have just upgraded 215 rebindServices(); 216 } 217 } 218 219 public void onUserSwitched(int user) { 220 if (DEBUG) Slog.d(TAG, "onUserSwitched u=" + user); 221 if (Arrays.equals(mLastSeenProfileIds, mUserProfiles.getCurrentProfileIds())) { 222 if (DEBUG) Slog.d(TAG, "Current profile IDs didn't change, skipping rebindServices()."); 223 return; 224 } 225 rebindServices(); 226 } 227 228 public ManagedServiceInfo checkServiceTokenLocked(IInterface service) { 229 checkNotNull(service); 230 final IBinder token = service.asBinder(); 231 final int N = mServices.size(); 232 for (int i=0; i<N; i++) { 233 final ManagedServiceInfo info = mServices.get(i); 234 if (info.service.asBinder() == token) return info; 235 } 236 throw new SecurityException("Disallowed call from unknown " + getCaption() + ": " 237 + service); 238 } 239 240 public void unregisterService(IInterface service, int userid) { 241 checkNotNull(service); 242 // no need to check permissions; if your service binder is in the list, 243 // that's proof that you had permission to add it in the first place 244 unregisterServiceImpl(service, userid); 245 } 246 247 public void registerService(IInterface service, ComponentName component, int userid) { 248 checkNotNull(service); 249 ManagedServiceInfo info = registerServiceImpl(service, component, userid); 250 if (info != null) { 251 onServiceAdded(info); 252 } 253 } 254 255 /** 256 * Remove access for any services that no longer exist. 257 */ 258 private void disableNonexistentServices() { 259 int[] userIds = mUserProfiles.getCurrentProfileIds(); 260 final int N = userIds.length; 261 for (int i = 0 ; i < N; ++i) { 262 disableNonexistentServices(userIds[i]); 263 } 264 } 265 266 private void disableNonexistentServices(int userId) { 267 final ContentResolver cr = mContext.getContentResolver(); 268 boolean restoredChanged = false; 269 if (mRestored == null) { 270 String restoredSetting = Settings.Secure.getStringForUser( 271 cr, 272 restoredSettingName(mConfig), 273 userId); 274 if (!TextUtils.isEmpty(restoredSetting)) { 275 if (DEBUG) Slog.d(TAG, "restored: " + restoredSetting); 276 String[] restored = restoredSetting.split(ENABLED_SERVICES_SEPARATOR); 277 mRestored = new ArraySet<String>(Arrays.asList(restored)); 278 } else { 279 mRestored = new ArraySet<String>(); 280 } 281 } 282 String flatIn = Settings.Secure.getStringForUser( 283 cr, 284 mConfig.secureSettingName, 285 userId); 286 if (!TextUtils.isEmpty(flatIn)) { 287 if (DEBUG) Slog.v(TAG, "flat before: " + flatIn); 288 PackageManager pm = mContext.getPackageManager(); 289 List<ResolveInfo> installedServices = pm.queryIntentServicesAsUser( 290 new Intent(mConfig.serviceInterface), 291 PackageManager.GET_SERVICES | PackageManager.GET_META_DATA, 292 userId); 293 if (DEBUG) Slog.v(TAG, mConfig.serviceInterface + " services: " + installedServices); 294 Set<ComponentName> installed = new ArraySet<ComponentName>(); 295 for (int i = 0, count = installedServices.size(); i < count; i++) { 296 ResolveInfo resolveInfo = installedServices.get(i); 297 ServiceInfo info = resolveInfo.serviceInfo; 298 299 ComponentName component = new ComponentName(info.packageName, info.name); 300 if (!mConfig.bindPermission.equals(info.permission)) { 301 Slog.w(TAG, "Skipping " + getCaption() + " service " 302 + info.packageName + "/" + info.name 303 + ": it does not require the permission " 304 + mConfig.bindPermission); 305 restoredChanged |= mRestored.remove(component.flattenToString()); 306 continue; 307 } 308 installed.add(component); 309 } 310 311 String flatOut = ""; 312 if (!installed.isEmpty()) { 313 String[] enabled = flatIn.split(ENABLED_SERVICES_SEPARATOR); 314 ArrayList<String> remaining = new ArrayList<String>(enabled.length); 315 for (int i = 0; i < enabled.length; i++) { 316 ComponentName enabledComponent = ComponentName.unflattenFromString(enabled[i]); 317 if (installed.contains(enabledComponent)) { 318 remaining.add(enabled[i]); 319 restoredChanged |= mRestored.remove(enabled[i]); 320 } 321 } 322 remaining.addAll(mRestored); 323 flatOut = TextUtils.join(ENABLED_SERVICES_SEPARATOR, remaining); 324 } 325 if (DEBUG) Slog.v(TAG, "flat after: " + flatOut); 326 if (!flatIn.equals(flatOut)) { 327 Settings.Secure.putStringForUser(cr, 328 mConfig.secureSettingName, 329 flatOut, userId); 330 } 331 if (restoredChanged) { 332 if (DEBUG) Slog.d(TAG, "restored changed; rewriting"); 333 final String flatRestored = TextUtils.join(ENABLED_SERVICES_SEPARATOR, 334 mRestored.toArray()); 335 Settings.Secure.putStringForUser(cr, 336 restoredSettingName(mConfig), 337 flatRestored, 338 userId); 339 } 340 } 341 } 342 343 /** 344 * Called whenever packages change, the user switches, or the secure setting 345 * is altered. (For example in response to USER_SWITCHED in our broadcast receiver) 346 */ 347 private void rebindServices() { 348 if (DEBUG) Slog.d(TAG, "rebindServices"); 349 final int[] userIds = mUserProfiles.getCurrentProfileIds(); 350 final int nUserIds = userIds.length; 351 352 final SparseArray<String> flat = new SparseArray<String>(); 353 354 for (int i = 0; i < nUserIds; ++i) { 355 flat.put(userIds[i], Settings.Secure.getStringForUser( 356 mContext.getContentResolver(), 357 mConfig.secureSettingName, 358 userIds[i])); 359 } 360 361 ArrayList<ManagedServiceInfo> toRemove = new ArrayList<ManagedServiceInfo>(); 362 final SparseArray<ArrayList<ComponentName>> toAdd 363 = new SparseArray<ArrayList<ComponentName>>(); 364 365 synchronized (mMutex) { 366 // Unbind automatically bound services, retain system services. 367 for (ManagedServiceInfo service : mServices) { 368 if (!service.isSystem) { 369 toRemove.add(service); 370 } 371 } 372 373 final ArraySet<ComponentName> newEnabled = new ArraySet<ComponentName>(); 374 final ArraySet<String> newPackages = new ArraySet<String>(); 375 376 for (int i = 0; i < nUserIds; ++i) { 377 final ArrayList<ComponentName> add = new ArrayList<ComponentName>(); 378 toAdd.put(userIds[i], add); 379 380 // decode the list of components 381 String toDecode = flat.get(userIds[i]); 382 if (toDecode != null) { 383 String[] components = toDecode.split(ENABLED_SERVICES_SEPARATOR); 384 for (int j = 0; j < components.length; j++) { 385 final ComponentName component 386 = ComponentName.unflattenFromString(components[j]); 387 if (component != null) { 388 newEnabled.add(component); 389 add.add(component); 390 newPackages.add(component.getPackageName()); 391 } 392 } 393 394 } 395 } 396 mEnabledServicesForCurrentProfiles = newEnabled; 397 mEnabledServicesPackageNames = newPackages; 398 } 399 400 for (ManagedServiceInfo info : toRemove) { 401 final ComponentName component = info.component; 402 final int oldUser = info.userid; 403 Slog.v(TAG, "disabling " + getCaption() + " for user " 404 + oldUser + ": " + component); 405 unregisterService(component, info.userid); 406 } 407 408 for (int i = 0; i < nUserIds; ++i) { 409 final ArrayList<ComponentName> add = toAdd.get(userIds[i]); 410 final int N = add.size(); 411 for (int j = 0; j < N; j++) { 412 final ComponentName component = add.get(j); 413 Slog.v(TAG, "enabling " + getCaption() + " for user " + userIds[i] + ": " 414 + component); 415 registerService(component, userIds[i]); 416 } 417 } 418 419 mLastSeenProfileIds = mUserProfiles.getCurrentProfileIds(); 420 } 421 422 /** 423 * Version of registerService that takes the name of a service component to bind to. 424 */ 425 private void registerService(final ComponentName name, final int userid) { 426 if (DEBUG) Slog.v(TAG, "registerService: " + name + " u=" + userid); 427 428 synchronized (mMutex) { 429 final String servicesBindingTag = name.toString() + "/" + userid; 430 if (mServicesBinding.contains(servicesBindingTag)) { 431 // stop registering this thing already! we're working on it 432 return; 433 } 434 mServicesBinding.add(servicesBindingTag); 435 436 final int N = mServices.size(); 437 for (int i=N-1; i>=0; i--) { 438 final ManagedServiceInfo info = mServices.get(i); 439 if (name.equals(info.component) 440 && info.userid == userid) { 441 // cut old connections 442 if (DEBUG) Slog.v(TAG, " disconnecting old " + getCaption() + ": " 443 + info.service); 444 removeServiceLocked(i); 445 if (info.connection != null) { 446 mContext.unbindService(info.connection); 447 } 448 } 449 } 450 451 Intent intent = new Intent(mConfig.serviceInterface); 452 intent.setComponent(name); 453 454 intent.putExtra(Intent.EXTRA_CLIENT_LABEL, mConfig.clientLabel); 455 456 final PendingIntent pendingIntent = PendingIntent.getActivity( 457 mContext, 0, new Intent(mConfig.settingsAction), 0); 458 intent.putExtra(Intent.EXTRA_CLIENT_INTENT, pendingIntent); 459 460 ApplicationInfo appInfo = null; 461 try { 462 appInfo = mContext.getPackageManager().getApplicationInfo( 463 name.getPackageName(), 0); 464 } catch (NameNotFoundException e) { 465 // Ignore if the package doesn't exist we won't be able to bind to the service. 466 } 467 final int targetSdkVersion = 468 appInfo != null ? appInfo.targetSdkVersion : Build.VERSION_CODES.BASE; 469 470 try { 471 if (DEBUG) Slog.v(TAG, "binding: " + intent); 472 if (!mContext.bindServiceAsUser(intent, 473 new ServiceConnection() { 474 IInterface mService; 475 476 @Override 477 public void onServiceConnected(ComponentName name, IBinder binder) { 478 boolean added = false; 479 ManagedServiceInfo info = null; 480 synchronized (mMutex) { 481 mServicesBinding.remove(servicesBindingTag); 482 try { 483 mService = asInterface(binder); 484 info = newServiceInfo(mService, name, 485 userid, false /*isSystem*/, this, targetSdkVersion); 486 binder.linkToDeath(info, 0); 487 added = mServices.add(info); 488 } catch (RemoteException e) { 489 // already dead 490 } 491 } 492 if (added) { 493 onServiceAdded(info); 494 } 495 } 496 497 @Override 498 public void onServiceDisconnected(ComponentName name) { 499 Slog.v(TAG, getCaption() + " connection lost: " + name); 500 } 501 }, 502 Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE, 503 new UserHandle(userid))) 504 { 505 mServicesBinding.remove(servicesBindingTag); 506 Slog.w(TAG, "Unable to bind " + getCaption() + " service: " + intent); 507 return; 508 } 509 } catch (SecurityException ex) { 510 Slog.e(TAG, "Unable to bind " + getCaption() + " service: " + intent, ex); 511 return; 512 } 513 } 514 } 515 516 /** 517 * Remove a service for the given user by ComponentName 518 */ 519 private void unregisterService(ComponentName name, int userid) { 520 synchronized (mMutex) { 521 final int N = mServices.size(); 522 for (int i=N-1; i>=0; i--) { 523 final ManagedServiceInfo info = mServices.get(i); 524 if (name.equals(info.component) 525 && info.userid == userid) { 526 removeServiceLocked(i); 527 if (info.connection != null) { 528 try { 529 mContext.unbindService(info.connection); 530 } catch (IllegalArgumentException ex) { 531 // something happened to the service: we think we have a connection 532 // but it's bogus. 533 Slog.e(TAG, getCaption() + " " + name + " could not be unbound: " + ex); 534 } 535 } 536 } 537 } 538 } 539 } 540 541 /** 542 * Removes a service from the list but does not unbind 543 * 544 * @return the removed service. 545 */ 546 private ManagedServiceInfo removeServiceImpl(IInterface service, final int userid) { 547 if (DEBUG) Slog.d(TAG, "removeServiceImpl service=" + service + " u=" + userid); 548 ManagedServiceInfo serviceInfo = null; 549 synchronized (mMutex) { 550 final int N = mServices.size(); 551 for (int i=N-1; i>=0; i--) { 552 final ManagedServiceInfo info = mServices.get(i); 553 if (info.service.asBinder() == service.asBinder() 554 && info.userid == userid) { 555 if (DEBUG) Slog.d(TAG, "Removing active service " + info.component); 556 serviceInfo = removeServiceLocked(i); 557 } 558 } 559 } 560 return serviceInfo; 561 } 562 563 private ManagedServiceInfo removeServiceLocked(int i) { 564 final ManagedServiceInfo info = mServices.remove(i); 565 onServiceRemovedLocked(info); 566 return info; 567 } 568 569 private void checkNotNull(IInterface service) { 570 if (service == null) { 571 throw new IllegalArgumentException(getCaption() + " must not be null"); 572 } 573 } 574 575 private ManagedServiceInfo registerServiceImpl(final IInterface service, 576 final ComponentName component, final int userid) { 577 synchronized (mMutex) { 578 try { 579 ManagedServiceInfo info = newServiceInfo(service, component, userid, 580 true /*isSystem*/, null, Build.VERSION_CODES.LOLLIPOP); 581 service.asBinder().linkToDeath(info, 0); 582 mServices.add(info); 583 return info; 584 } catch (RemoteException e) { 585 // already dead 586 } 587 } 588 return null; 589 } 590 591 /** 592 * Removes a service from the list and unbinds. 593 */ 594 private void unregisterServiceImpl(IInterface service, int userid) { 595 ManagedServiceInfo info = removeServiceImpl(service, userid); 596 if (info != null && info.connection != null) { 597 mContext.unbindService(info.connection); 598 } 599 } 600 601 private class SettingsObserver extends ContentObserver { 602 private final Uri mSecureSettingsUri = Settings.Secure.getUriFor(mConfig.secureSettingName); 603 604 private SettingsObserver(Handler handler) { 605 super(handler); 606 } 607 608 private void observe() { 609 ContentResolver resolver = mContext.getContentResolver(); 610 resolver.registerContentObserver(mSecureSettingsUri, 611 false, this, UserHandle.USER_ALL); 612 update(null); 613 } 614 615 @Override 616 public void onChange(boolean selfChange, Uri uri) { 617 update(uri); 618 } 619 620 private void update(Uri uri) { 621 if (uri == null || mSecureSettingsUri.equals(uri)) { 622 if (DEBUG) Slog.d(TAG, "Setting changed: mSecureSettingsUri=" + mSecureSettingsUri + 623 " / uri=" + uri); 624 rebindServices(); 625 } 626 } 627 } 628 629 public class ManagedServiceInfo implements IBinder.DeathRecipient { 630 public IInterface service; 631 public ComponentName component; 632 public int userid; 633 public boolean isSystem; 634 public ServiceConnection connection; 635 public int targetSdkVersion; 636 637 public ManagedServiceInfo(IInterface service, ComponentName component, 638 int userid, boolean isSystem, ServiceConnection connection, int targetSdkVersion) { 639 this.service = service; 640 this.component = component; 641 this.userid = userid; 642 this.isSystem = isSystem; 643 this.connection = connection; 644 this.targetSdkVersion = targetSdkVersion; 645 } 646 647 @Override 648 public String toString() { 649 return new StringBuilder("ManagedServiceInfo[") 650 .append("component=").append(component) 651 .append(",userid=").append(userid) 652 .append(",isSystem=").append(isSystem) 653 .append(",targetSdkVersion=").append(targetSdkVersion) 654 .append(",connection=").append(connection == null ? null : "<connection>") 655 .append(",service=").append(service) 656 .append(']').toString(); 657 } 658 659 public boolean enabledAndUserMatches(int nid) { 660 if (!isEnabledForCurrentProfiles()) { 661 return false; 662 } 663 if (this.userid == UserHandle.USER_ALL) return true; 664 if (nid == UserHandle.USER_ALL || nid == this.userid) return true; 665 return supportsProfiles() && mUserProfiles.isCurrentProfile(nid); 666 } 667 668 public boolean supportsProfiles() { 669 return targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP; 670 } 671 672 @Override 673 public void binderDied() { 674 if (DEBUG) Slog.d(TAG, "binderDied"); 675 // Remove the service, but don't unbind from the service. The system will bring the 676 // service back up, and the onServiceConnected handler will readd the service with the 677 // new binding. If this isn't a bound service, and is just a registered 678 // service, just removing it from the list is all we need to do anyway. 679 removeServiceImpl(this.service, this.userid); 680 } 681 682 /** convenience method for looking in mEnabledServicesForCurrentProfiles */ 683 public boolean isEnabledForCurrentProfiles() { 684 if (this.isSystem) return true; 685 if (this.connection == null) return false; 686 return mEnabledServicesForCurrentProfiles.contains(this.component); 687 } 688 } 689 690 public static class UserProfiles { 691 // Profiles of the current user. 692 private final SparseArray<UserInfo> mCurrentProfiles = new SparseArray<UserInfo>(); 693 694 public void updateCache(Context context) { 695 UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE); 696 if (userManager != null) { 697 int currentUserId = ActivityManager.getCurrentUser(); 698 List<UserInfo> profiles = userManager.getProfiles(currentUserId); 699 synchronized (mCurrentProfiles) { 700 mCurrentProfiles.clear(); 701 for (UserInfo user : profiles) { 702 mCurrentProfiles.put(user.id, user); 703 } 704 } 705 } 706 } 707 708 public int[] getCurrentProfileIds() { 709 synchronized (mCurrentProfiles) { 710 int[] users = new int[mCurrentProfiles.size()]; 711 final int N = mCurrentProfiles.size(); 712 for (int i = 0; i < N; ++i) { 713 users[i] = mCurrentProfiles.keyAt(i); 714 } 715 return users; 716 } 717 } 718 719 public boolean isCurrentProfile(int userId) { 720 synchronized (mCurrentProfiles) { 721 return mCurrentProfiles.get(userId) != null; 722 } 723 } 724 } 725 726 protected static class Config { 727 String caption; 728 String serviceInterface; 729 String secureSettingName; 730 String bindPermission; 731 String settingsAction; 732 int clientLabel; 733 } 734 } 735
