1 /* 2 * Copyright (C) 2006 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 android.app; 18 19 import android.app.usage.IUsageStatsManager; 20 import android.app.usage.UsageStatsManager; 21 import android.appwidget.AppWidgetManager; 22 import android.os.Build; 23 import android.service.persistentdata.IPersistentDataBlockService; 24 import android.service.persistentdata.PersistentDataBlockManager; 25 26 import com.android.internal.appwidget.IAppWidgetService; 27 import com.android.internal.policy.PolicyManager; 28 import com.android.internal.util.Preconditions; 29 30 import android.bluetooth.BluetoothManager; 31 import android.content.BroadcastReceiver; 32 import android.content.ComponentName; 33 import android.content.ContentProvider; 34 import android.content.ContentResolver; 35 import android.content.Context; 36 import android.content.ContextWrapper; 37 import android.content.IContentProvider; 38 import android.content.Intent; 39 import android.content.IntentFilter; 40 import android.content.IIntentReceiver; 41 import android.content.IntentSender; 42 import android.content.IRestrictionsManager; 43 import android.content.ReceiverCallNotAllowedException; 44 import android.content.RestrictionsManager; 45 import android.content.ServiceConnection; 46 import android.content.SharedPreferences; 47 import android.content.pm.ApplicationInfo; 48 import android.content.pm.ILauncherApps; 49 import android.content.pm.IPackageManager; 50 import android.content.pm.LauncherApps; 51 import android.content.pm.PackageManager; 52 import android.content.pm.PackageManager.NameNotFoundException; 53 import android.content.res.AssetManager; 54 import android.content.res.CompatibilityInfo; 55 import android.content.res.Configuration; 56 import android.content.res.Resources; 57 import android.database.DatabaseErrorHandler; 58 import android.database.sqlite.SQLiteDatabase; 59 import android.database.sqlite.SQLiteDatabase.CursorFactory; 60 import android.graphics.Bitmap; 61 import android.graphics.drawable.Drawable; 62 import android.hardware.ConsumerIrManager; 63 import android.hardware.ISerialManager; 64 import android.hardware.SerialManager; 65 import android.hardware.SystemSensorManager; 66 import android.hardware.hdmi.HdmiControlManager; 67 import android.hardware.hdmi.IHdmiControlService; 68 import android.hardware.camera2.CameraManager; 69 import android.hardware.display.DisplayManager; 70 import android.hardware.input.InputManager; 71 import android.hardware.usb.IUsbManager; 72 import android.hardware.usb.UsbManager; 73 import android.location.CountryDetector; 74 import android.location.ICountryDetector; 75 import android.location.ILocationManager; 76 import android.location.LocationManager; 77 import android.media.AudioManager; 78 import android.media.MediaRouter; 79 import android.media.projection.MediaProjectionManager; 80 import android.media.session.MediaSessionManager; 81 import android.media.tv.ITvInputManager; 82 import android.media.tv.TvInputManager; 83 import android.net.ConnectivityManager; 84 import android.net.IConnectivityManager; 85 import android.net.EthernetManager; 86 import android.net.IEthernetManager; 87 import android.net.INetworkPolicyManager; 88 import android.net.NetworkPolicyManager; 89 import android.net.NetworkScoreManager; 90 import android.net.Uri; 91 import android.net.nsd.INsdManager; 92 import android.net.nsd.NsdManager; 93 import android.net.wifi.IWifiManager; 94 import android.net.wifi.WifiManager; 95 import android.net.wifi.p2p.IWifiP2pManager; 96 import android.net.wifi.p2p.WifiP2pManager; 97 import android.net.wifi.IWifiScanner; 98 import android.net.wifi.WifiScanner; 99 import android.net.wifi.IRttManager; 100 import android.net.wifi.RttManager; 101 import android.nfc.NfcManager; 102 import android.os.BatteryManager; 103 import android.os.Binder; 104 import android.os.Bundle; 105 import android.os.Debug; 106 import android.os.DropBoxManager; 107 import android.os.Environment; 108 import android.os.FileUtils; 109 import android.os.Handler; 110 import android.os.IBinder; 111 import android.os.IPowerManager; 112 import android.os.IUserManager; 113 import android.os.Looper; 114 import android.os.PowerManager; 115 import android.os.Process; 116 import android.os.RemoteException; 117 import android.os.ServiceManager; 118 import android.os.UserHandle; 119 import android.os.SystemVibrator; 120 import android.os.UserManager; 121 import android.os.storage.IMountService; 122 import android.os.storage.StorageManager; 123 import android.print.IPrintManager; 124 import android.print.PrintManager; 125 import android.service.fingerprint.IFingerprintService; 126 import android.service.fingerprint.FingerprintManager; 127 import android.telecom.TelecomManager; 128 import android.telephony.SubscriptionManager; 129 import android.telephony.TelephonyManager; 130 import android.content.ClipboardManager; 131 import android.util.AndroidRuntimeException; 132 import android.util.ArrayMap; 133 import android.util.Log; 134 import android.util.Slog; 135 import android.view.DisplayAdjustments; 136 import android.view.ContextThemeWrapper; 137 import android.view.Display; 138 import android.view.WindowManagerImpl; 139 import android.view.accessibility.AccessibilityManager; 140 import android.view.accessibility.CaptioningManager; 141 import android.view.inputmethod.InputMethodManager; 142 import android.view.textservice.TextServicesManager; 143 import android.accounts.AccountManager; 144 import android.accounts.IAccountManager; 145 import android.app.admin.DevicePolicyManager; 146 import android.app.job.IJobScheduler; 147 import android.app.trust.TrustManager; 148 149 import com.android.internal.annotations.GuardedBy; 150 import com.android.internal.app.IAppOpsService; 151 import com.android.internal.os.IDropBoxManagerService; 152 153 import java.io.File; 154 import java.io.FileInputStream; 155 import java.io.FileNotFoundException; 156 import java.io.FileOutputStream; 157 import java.io.IOException; 158 import java.io.InputStream; 159 import java.util.ArrayList; 160 import java.util.HashMap; 161 162 class ReceiverRestrictedContext extends ContextWrapper { 163 ReceiverRestrictedContext(Context base) { 164 super(base); 165 } 166 167 @Override 168 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { 169 return registerReceiver(receiver, filter, null, null); 170 } 171 172 @Override 173 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, 174 String broadcastPermission, Handler scheduler) { 175 if (receiver == null) { 176 // Allow retrieving current sticky broadcast; this is safe since we 177 // aren't actually registering a receiver. 178 return super.registerReceiver(null, filter, broadcastPermission, scheduler); 179 } else { 180 throw new ReceiverCallNotAllowedException( 181 "BroadcastReceiver components are not allowed to register to receive intents"); 182 } 183 } 184 185 @Override 186 public Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user, 187 IntentFilter filter, String broadcastPermission, Handler scheduler) { 188 if (receiver == null) { 189 // Allow retrieving current sticky broadcast; this is safe since we 190 // aren't actually registering a receiver. 191 return super.registerReceiverAsUser(null, user, filter, broadcastPermission, scheduler); 192 } else { 193 throw new ReceiverCallNotAllowedException( 194 "BroadcastReceiver components are not allowed to register to receive intents"); 195 } 196 } 197 198 @Override 199 public boolean bindService(Intent service, ServiceConnection conn, int flags) { 200 throw new ReceiverCallNotAllowedException( 201 "BroadcastReceiver components are not allowed to bind to services"); 202 } 203 } 204 205 /** 206 * Common implementation of Context API, which provides the base 207 * context object for Activity and other application components. 208 */ 209 class ContextImpl extends Context { 210 private final static String TAG = "ContextImpl"; 211 private final static boolean DEBUG = false; 212 213 /** 214 * Map from package name, to preference name, to cached preferences. 215 */ 216 private static ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>> sSharedPrefs; 217 218 final ActivityThread mMainThread; 219 final LoadedApk mPackageInfo; 220 221 private final IBinder mActivityToken; 222 223 private final UserHandle mUser; 224 225 private final ApplicationContentResolver mContentResolver; 226 227 private final String mBasePackageName; 228 private final String mOpPackageName; 229 230 private final ResourcesManager mResourcesManager; 231 private final Resources mResources; 232 private final Display mDisplay; // may be null if default display 233 private final DisplayAdjustments mDisplayAdjustments = new DisplayAdjustments(); 234 private final Configuration mOverrideConfiguration; 235 236 private final boolean mRestricted; 237 238 private Context mOuterContext; 239 private int mThemeResource = 0; 240 private Resources.Theme mTheme = null; 241 private PackageManager mPackageManager; 242 private Context mReceiverRestrictedContext = null; 243 244 private final Object mSync = new Object(); 245 246 @GuardedBy("mSync") 247 private File mDatabasesDir; 248 @GuardedBy("mSync") 249 private File mPreferencesDir; 250 @GuardedBy("mSync") 251 private File mFilesDir; 252 @GuardedBy("mSync") 253 private File mNoBackupFilesDir; 254 @GuardedBy("mSync") 255 private File mCacheDir; 256 @GuardedBy("mSync") 257 private File mCodeCacheDir; 258 259 @GuardedBy("mSync") 260 private File[] mExternalObbDirs; 261 @GuardedBy("mSync") 262 private File[] mExternalFilesDirs; 263 @GuardedBy("mSync") 264 private File[] mExternalCacheDirs; 265 @GuardedBy("mSync") 266 private File[] mExternalMediaDirs; 267 268 private static final String[] EMPTY_FILE_LIST = {}; 269 270 /** 271 * Override this class when the system service constructor needs a 272 * ContextImpl. Else, use StaticServiceFetcher below. 273 */ 274 /*package*/ static class ServiceFetcher { 275 int mContextCacheIndex = -1; 276 277 /** 278 * Main entrypoint; only override if you don't need caching. 279 */ 280 public Object getService(ContextImpl ctx) { 281 ArrayList<Object> cache = ctx.mServiceCache; 282 Object service; 283 synchronized (cache) { 284 if (cache.size() == 0) { 285 // Initialize the cache vector on first access. 286 // At this point sNextPerContextServiceCacheIndex 287 // is the number of potential services that are 288 // cached per-Context. 289 for (int i = 0; i < sNextPerContextServiceCacheIndex; i++) { 290 cache.add(null); 291 } 292 } else { 293 service = cache.get(mContextCacheIndex); 294 if (service != null) { 295 return service; 296 } 297 } 298 service = createService(ctx); 299 cache.set(mContextCacheIndex, service); 300 return service; 301 } 302 } 303 304 /** 305 * Override this to create a new per-Context instance of the 306 * service. getService() will handle locking and caching. 307 */ 308 public Object createService(ContextImpl ctx) { 309 throw new RuntimeException("Not implemented"); 310 } 311 } 312 313 /** 314 * Override this class for services to be cached process-wide. 315 */ 316 abstract static class StaticServiceFetcher extends ServiceFetcher { 317 private Object mCachedInstance; 318 319 @Override 320 public final Object getService(ContextImpl unused) { 321 synchronized (StaticServiceFetcher.this) { 322 Object service = mCachedInstance; 323 if (service != null) { 324 return service; 325 } 326 return mCachedInstance = createStaticService(); 327 } 328 } 329 330 public abstract Object createStaticService(); 331 } 332 333 private static final HashMap<String, ServiceFetcher> SYSTEM_SERVICE_MAP = 334 new HashMap<String, ServiceFetcher>(); 335 336 private static int sNextPerContextServiceCacheIndex = 0; 337 private static void registerService(String serviceName, ServiceFetcher fetcher) { 338 if (!(fetcher instanceof StaticServiceFetcher)) { 339 fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++; 340 } 341 SYSTEM_SERVICE_MAP.put(serviceName, fetcher); 342 } 343 344 // This one's defined separately and given a variable name so it 345 // can be re-used by getWallpaperManager(), avoiding a HashMap 346 // lookup. 347 private static ServiceFetcher WALLPAPER_FETCHER = new ServiceFetcher() { 348 public Object createService(ContextImpl ctx) { 349 return new WallpaperManager(ctx.getOuterContext(), 350 ctx.mMainThread.getHandler()); 351 }}; 352 353 static { 354 registerService(ACCESSIBILITY_SERVICE, new ServiceFetcher() { 355 public Object getService(ContextImpl ctx) { 356 return AccessibilityManager.getInstance(ctx); 357 }}); 358 359 registerService(CAPTIONING_SERVICE, new ServiceFetcher() { 360 public Object getService(ContextImpl ctx) { 361 return new CaptioningManager(ctx); 362 }}); 363 364 registerService(ACCOUNT_SERVICE, new ServiceFetcher() { 365 public Object createService(ContextImpl ctx) { 366 IBinder b = ServiceManager.getService(ACCOUNT_SERVICE); 367 IAccountManager service = IAccountManager.Stub.asInterface(b); 368 return new AccountManager(ctx, service); 369 }}); 370 371 registerService(ACTIVITY_SERVICE, new ServiceFetcher() { 372 public Object createService(ContextImpl ctx) { 373 return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler()); 374 }}); 375 376 registerService(ALARM_SERVICE, new ServiceFetcher() { 377 public Object createService(ContextImpl ctx) { 378 IBinder b = ServiceManager.getService(ALARM_SERVICE); 379 IAlarmManager service = IAlarmManager.Stub.asInterface(b); 380 return new AlarmManager(service, ctx); 381 }}); 382 383 registerService(AUDIO_SERVICE, new ServiceFetcher() { 384 public Object createService(ContextImpl ctx) { 385 return new AudioManager(ctx); 386 }}); 387 388 registerService(MEDIA_ROUTER_SERVICE, new ServiceFetcher() { 389 public Object createService(ContextImpl ctx) { 390 return new MediaRouter(ctx); 391 }}); 392 393 registerService(BLUETOOTH_SERVICE, new ServiceFetcher() { 394 public Object createService(ContextImpl ctx) { 395 return new BluetoothManager(ctx); 396 }}); 397 398 registerService(HDMI_CONTROL_SERVICE, new StaticServiceFetcher() { 399 public Object createStaticService() { 400 IBinder b = ServiceManager.getService(HDMI_CONTROL_SERVICE); 401 return new HdmiControlManager(IHdmiControlService.Stub.asInterface(b)); 402 }}); 403 404 registerService(CLIPBOARD_SERVICE, new ServiceFetcher() { 405 public Object createService(ContextImpl ctx) { 406 return new ClipboardManager(ctx.getOuterContext(), 407 ctx.mMainThread.getHandler()); 408 }}); 409 410 registerService(CONNECTIVITY_SERVICE, new ServiceFetcher() { 411 public Object createService(ContextImpl ctx) { 412 IBinder b = ServiceManager.getService(CONNECTIVITY_SERVICE); 413 return new ConnectivityManager(IConnectivityManager.Stub.asInterface(b)); 414 }}); 415 416 registerService(COUNTRY_DETECTOR, new StaticServiceFetcher() { 417 public Object createStaticService() { 418 IBinder b = ServiceManager.getService(COUNTRY_DETECTOR); 419 return new CountryDetector(ICountryDetector.Stub.asInterface(b)); 420 }}); 421 422 registerService(DEVICE_POLICY_SERVICE, new ServiceFetcher() { 423 public Object createService(ContextImpl ctx) { 424 return DevicePolicyManager.create(ctx, ctx.mMainThread.getHandler()); 425 }}); 426 427 registerService(DOWNLOAD_SERVICE, new ServiceFetcher() { 428 public Object createService(ContextImpl ctx) { 429 return new DownloadManager(ctx.getContentResolver(), ctx.getPackageName()); 430 }}); 431 432 registerService(BATTERY_SERVICE, new ServiceFetcher() { 433 public Object createService(ContextImpl ctx) { 434 return new BatteryManager(); 435 }}); 436 437 registerService(NFC_SERVICE, new ServiceFetcher() { 438 public Object createService(ContextImpl ctx) { 439 return new NfcManager(ctx); 440 }}); 441 442 registerService(DROPBOX_SERVICE, new StaticServiceFetcher() { 443 public Object createStaticService() { 444 return createDropBoxManager(); 445 }}); 446 447 registerService(INPUT_SERVICE, new StaticServiceFetcher() { 448 public Object createStaticService() { 449 return InputManager.getInstance(); 450 }}); 451 452 registerService(DISPLAY_SERVICE, new ServiceFetcher() { 453 @Override 454 public Object createService(ContextImpl ctx) { 455 return new DisplayManager(ctx.getOuterContext()); 456 }}); 457 458 registerService(INPUT_METHOD_SERVICE, new StaticServiceFetcher() { 459 public Object createStaticService() { 460 return InputMethodManager.getInstance(); 461 }}); 462 463 registerService(TEXT_SERVICES_MANAGER_SERVICE, new ServiceFetcher() { 464 public Object createService(ContextImpl ctx) { 465 return TextServicesManager.getInstance(); 466 }}); 467 468 registerService(KEYGUARD_SERVICE, new ServiceFetcher() { 469 public Object getService(ContextImpl ctx) { 470 // TODO: why isn't this caching it? It wasn't 471 // before, so I'm preserving the old behavior and 472 // using getService(), instead of createService() 473 // which would do the caching. 474 return new KeyguardManager(); 475 }}); 476 477 registerService(LAYOUT_INFLATER_SERVICE, new ServiceFetcher() { 478 public Object createService(ContextImpl ctx) { 479 return PolicyManager.makeNewLayoutInflater(ctx.getOuterContext()); 480 }}); 481 482 registerService(LOCATION_SERVICE, new ServiceFetcher() { 483 public Object createService(ContextImpl ctx) { 484 IBinder b = ServiceManager.getService(LOCATION_SERVICE); 485 return new LocationManager(ctx, ILocationManager.Stub.asInterface(b)); 486 }}); 487 488 registerService(NETWORK_POLICY_SERVICE, new ServiceFetcher() { 489 @Override 490 public Object createService(ContextImpl ctx) { 491 return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface( 492 ServiceManager.getService(NETWORK_POLICY_SERVICE))); 493 } 494 }); 495 496 registerService(NOTIFICATION_SERVICE, new ServiceFetcher() { 497 public Object createService(ContextImpl ctx) { 498 final Context outerContext = ctx.getOuterContext(); 499 return new NotificationManager( 500 new ContextThemeWrapper(outerContext, 501 Resources.selectSystemTheme(0, 502 outerContext.getApplicationInfo().targetSdkVersion, 503 com.android.internal.R.style.Theme_Dialog, 504 com.android.internal.R.style.Theme_Holo_Dialog, 505 com.android.internal.R.style.Theme_DeviceDefault_Dialog, 506 com.android.internal.R.style.Theme_DeviceDefault_Light_Dialog)), 507 ctx.mMainThread.getHandler()); 508 }}); 509 510 registerService(NSD_SERVICE, new ServiceFetcher() { 511 @Override 512 public Object createService(ContextImpl ctx) { 513 IBinder b = ServiceManager.getService(NSD_SERVICE); 514 INsdManager service = INsdManager.Stub.asInterface(b); 515 return new NsdManager(ctx.getOuterContext(), service); 516 }}); 517 518 // Note: this was previously cached in a static variable, but 519 // constructed using mMainThread.getHandler(), so converting 520 // it to be a regular Context-cached service... 521 registerService(POWER_SERVICE, new ServiceFetcher() { 522 public Object createService(ContextImpl ctx) { 523 IBinder b = ServiceManager.getService(POWER_SERVICE); 524 IPowerManager service = IPowerManager.Stub.asInterface(b); 525 if (service == null) { 526 Log.wtf(TAG, "Failed to get power manager service."); 527 } 528 return new PowerManager(ctx.getOuterContext(), 529 service, ctx.mMainThread.getHandler()); 530 }}); 531 532 registerService(SEARCH_SERVICE, new ServiceFetcher() { 533 public Object createService(ContextImpl ctx) { 534 return new SearchManager(ctx.getOuterContext(), 535 ctx.mMainThread.getHandler()); 536 }}); 537 538 registerService(SENSOR_SERVICE, new ServiceFetcher() { 539 public Object createService(ContextImpl ctx) { 540 return new SystemSensorManager(ctx.getOuterContext(), 541 ctx.mMainThread.getHandler().getLooper()); 542 }}); 543 544 registerService(STATUS_BAR_SERVICE, new ServiceFetcher() { 545 public Object createService(ContextImpl ctx) { 546 return new StatusBarManager(ctx.getOuterContext()); 547 }}); 548 549 registerService(STORAGE_SERVICE, new ServiceFetcher() { 550 public Object createService(ContextImpl ctx) { 551 try { 552 return new StorageManager( 553 ctx.getContentResolver(), ctx.mMainThread.getHandler().getLooper()); 554 } catch (RemoteException rex) { 555 Log.e(TAG, "Failed to create StorageManager", rex); 556 return null; 557 } 558 }}); 559 560 registerService(TELEPHONY_SERVICE, new ServiceFetcher() { 561 public Object createService(ContextImpl ctx) { 562 return new TelephonyManager(ctx.getOuterContext()); 563 }}); 564 565 registerService(TELEPHONY_SUBSCRIPTION_SERVICE, new ServiceFetcher() { 566 public Object createService(ContextImpl ctx) { 567 return new SubscriptionManager(ctx.getOuterContext()); 568 }}); 569 570 registerService(TELECOM_SERVICE, new ServiceFetcher() { 571 public Object createService(ContextImpl ctx) { 572 return new TelecomManager(ctx.getOuterContext()); 573 }}); 574 575 registerService(UI_MODE_SERVICE, new ServiceFetcher() { 576 public Object createService(ContextImpl ctx) { 577 return new UiModeManager(); 578 }}); 579 580 registerService(USB_SERVICE, new ServiceFetcher() { 581 public Object createService(ContextImpl ctx) { 582 IBinder b = ServiceManager.getService(USB_SERVICE); 583 return new UsbManager(ctx, IUsbManager.Stub.asInterface(b)); 584 }}); 585 586 registerService(SERIAL_SERVICE, new ServiceFetcher() { 587 public Object createService(ContextImpl ctx) { 588 IBinder b = ServiceManager.getService(SERIAL_SERVICE); 589 return new SerialManager(ctx, ISerialManager.Stub.asInterface(b)); 590 }}); 591 592 registerService(VIBRATOR_SERVICE, new ServiceFetcher() { 593 public Object createService(ContextImpl ctx) { 594 return new SystemVibrator(ctx); 595 }}); 596 597 registerService(WALLPAPER_SERVICE, WALLPAPER_FETCHER); 598 599 registerService(WIFI_SERVICE, new ServiceFetcher() { 600 public Object createService(ContextImpl ctx) { 601 IBinder b = ServiceManager.getService(WIFI_SERVICE); 602 IWifiManager service = IWifiManager.Stub.asInterface(b); 603 return new WifiManager(ctx.getOuterContext(), service); 604 }}); 605 606 registerService(WIFI_P2P_SERVICE, new ServiceFetcher() { 607 public Object createService(ContextImpl ctx) { 608 IBinder b = ServiceManager.getService(WIFI_P2P_SERVICE); 609 IWifiP2pManager service = IWifiP2pManager.Stub.asInterface(b); 610 return new WifiP2pManager(service); 611 }}); 612 613 registerService(WIFI_SCANNING_SERVICE, new ServiceFetcher() { 614 public Object createService(ContextImpl ctx) { 615 IBinder b = ServiceManager.getService(WIFI_SCANNING_SERVICE); 616 IWifiScanner service = IWifiScanner.Stub.asInterface(b); 617 return new WifiScanner(ctx.getOuterContext(), service); 618 }}); 619 620 registerService(WIFI_RTT_SERVICE, new ServiceFetcher() { 621 public Object createService(ContextImpl ctx) { 622 IBinder b = ServiceManager.getService(WIFI_RTT_SERVICE); 623 IRttManager service = IRttManager.Stub.asInterface(b); 624 return new RttManager(ctx.getOuterContext(), service); 625 }}); 626 627 registerService(ETHERNET_SERVICE, new ServiceFetcher() { 628 public Object createService(ContextImpl ctx) { 629 IBinder b = ServiceManager.getService(ETHERNET_SERVICE); 630 IEthernetManager service = IEthernetManager.Stub.asInterface(b); 631 return new EthernetManager(ctx.getOuterContext(), service); 632 }}); 633 634 registerService(WINDOW_SERVICE, new ServiceFetcher() { 635 Display mDefaultDisplay; 636 public Object getService(ContextImpl ctx) { 637 Display display = ctx.mDisplay; 638 if (display == null) { 639 if (mDefaultDisplay == null) { 640 DisplayManager dm = (DisplayManager)ctx.getOuterContext(). 641 getSystemService(Context.DISPLAY_SERVICE); 642 mDefaultDisplay = dm.getDisplay(Display.DEFAULT_DISPLAY); 643 } 644 display = mDefaultDisplay; 645 } 646 return new WindowManagerImpl(display); 647 }}); 648 649 registerService(USER_SERVICE, new ServiceFetcher() { 650 public Object createService(ContextImpl ctx) { 651 IBinder b = ServiceManager.getService(USER_SERVICE); 652 IUserManager service = IUserManager.Stub.asInterface(b); 653 return new UserManager(ctx, service); 654 }}); 655 656 registerService(APP_OPS_SERVICE, new ServiceFetcher() { 657 public Object createService(ContextImpl ctx) { 658 IBinder b = ServiceManager.getService(APP_OPS_SERVICE); 659 IAppOpsService service = IAppOpsService.Stub.asInterface(b); 660 return new AppOpsManager(ctx, service); 661 }}); 662 663 registerService(CAMERA_SERVICE, new ServiceFetcher() { 664 public Object createService(ContextImpl ctx) { 665 return new CameraManager(ctx); 666 } 667 }); 668 669 registerService(LAUNCHER_APPS_SERVICE, new ServiceFetcher() { 670 public Object createService(ContextImpl ctx) { 671 IBinder b = ServiceManager.getService(LAUNCHER_APPS_SERVICE); 672 ILauncherApps service = ILauncherApps.Stub.asInterface(b); 673 return new LauncherApps(ctx, service); 674 } 675 }); 676 677 registerService(RESTRICTIONS_SERVICE, new ServiceFetcher() { 678 public Object createService(ContextImpl ctx) { 679 IBinder b = ServiceManager.getService(RESTRICTIONS_SERVICE); 680 IRestrictionsManager service = IRestrictionsManager.Stub.asInterface(b); 681 return new RestrictionsManager(ctx, service); 682 } 683 }); 684 registerService(PRINT_SERVICE, new ServiceFetcher() { 685 public Object createService(ContextImpl ctx) { 686 IBinder iBinder = ServiceManager.getService(Context.PRINT_SERVICE); 687 IPrintManager service = IPrintManager.Stub.asInterface(iBinder); 688 return new PrintManager(ctx.getOuterContext(), service, UserHandle.myUserId(), 689 UserHandle.getAppId(Process.myUid())); 690 }}); 691 692 registerService(CONSUMER_IR_SERVICE, new ServiceFetcher() { 693 public Object createService(ContextImpl ctx) { 694 return new ConsumerIrManager(ctx); 695 }}); 696 697 registerService(MEDIA_SESSION_SERVICE, new ServiceFetcher() { 698 public Object createService(ContextImpl ctx) { 699 return new MediaSessionManager(ctx); 700 } 701 }); 702 703 registerService(TRUST_SERVICE, new ServiceFetcher() { 704 public Object createService(ContextImpl ctx) { 705 IBinder b = ServiceManager.getService(TRUST_SERVICE); 706 return new TrustManager(b); 707 } 708 }); 709 710 registerService(FINGERPRINT_SERVICE, new ServiceFetcher() { 711 public Object createService(ContextImpl ctx) { 712 IBinder binder = ServiceManager.getService(FINGERPRINT_SERVICE); 713 IFingerprintService service = IFingerprintService.Stub.asInterface(binder); 714 return new FingerprintManager(ctx.getOuterContext(), service); 715 } 716 }); 717 718 registerService(TV_INPUT_SERVICE, new ServiceFetcher() { 719 public Object createService(ContextImpl ctx) { 720 IBinder iBinder = ServiceManager.getService(TV_INPUT_SERVICE); 721 ITvInputManager service = ITvInputManager.Stub.asInterface(iBinder); 722 return new TvInputManager(service, UserHandle.myUserId()); 723 } 724 }); 725 726 registerService(NETWORK_SCORE_SERVICE, new ServiceFetcher() { 727 public Object createService(ContextImpl ctx) { 728 return new NetworkScoreManager(ctx); 729 } 730 }); 731 732 registerService(USAGE_STATS_SERVICE, new ServiceFetcher() { 733 public Object createService(ContextImpl ctx) { 734 IBinder iBinder = ServiceManager.getService(USAGE_STATS_SERVICE); 735 IUsageStatsManager service = IUsageStatsManager.Stub.asInterface(iBinder); 736 return new UsageStatsManager(ctx.getOuterContext(), service); 737 } 738 }); 739 740 registerService(JOB_SCHEDULER_SERVICE, new ServiceFetcher() { 741 public Object createService(ContextImpl ctx) { 742 IBinder b = ServiceManager.getService(JOB_SCHEDULER_SERVICE); 743 return new JobSchedulerImpl(IJobScheduler.Stub.asInterface(b)); 744 }}); 745 746 registerService(PERSISTENT_DATA_BLOCK_SERVICE, new ServiceFetcher() { 747 public Object createService(ContextImpl ctx) { 748 IBinder b = ServiceManager.getService(PERSISTENT_DATA_BLOCK_SERVICE); 749 IPersistentDataBlockService persistentDataBlockService = 750 IPersistentDataBlockService.Stub.asInterface(b); 751 if (persistentDataBlockService != null) { 752 return new PersistentDataBlockManager(persistentDataBlockService); 753 } else { 754 // not supported 755 return null; 756 } 757 } 758 }); 759 760 registerService(MEDIA_PROJECTION_SERVICE, new ServiceFetcher() { 761 public Object createService(ContextImpl ctx) { 762 return new MediaProjectionManager(ctx); 763 } 764 }); 765 766 registerService(APPWIDGET_SERVICE, new ServiceFetcher() { 767 public Object createService(ContextImpl ctx) { 768 IBinder b = ServiceManager.getService(APPWIDGET_SERVICE); 769 return new AppWidgetManager(ctx, IAppWidgetService.Stub.asInterface(b)); 770 }}); 771 } 772 773 static ContextImpl getImpl(Context context) { 774 Context nextContext; 775 while ((context instanceof ContextWrapper) && 776 (nextContext=((ContextWrapper)context).getBaseContext()) != null) { 777 context = nextContext; 778 } 779 return (ContextImpl)context; 780 } 781 782 // The system service cache for the system services that are 783 // cached per-ContextImpl. Package-scoped to avoid accessor 784 // methods. 785 final ArrayList<Object> mServiceCache = new ArrayList<Object>(); 786 787 @Override 788 public AssetManager getAssets() { 789 return getResources().getAssets(); 790 } 791 792 @Override 793 public Resources getResources() { 794 return mResources; 795 } 796 797 @Override 798 public PackageManager getPackageManager() { 799 if (mPackageManager != null) { 800 return mPackageManager; 801 } 802 803 IPackageManager pm = ActivityThread.getPackageManager(); 804 if (pm != null) { 805 // Doesn't matter if we make more than one instance. 806 return (mPackageManager = new ApplicationPackageManager(this, pm)); 807 } 808 809 return null; 810 } 811 812 @Override 813 public ContentResolver getContentResolver() { 814 return mContentResolver; 815 } 816 817 @Override 818 public Looper getMainLooper() { 819 return mMainThread.getLooper(); 820 } 821 822 @Override 823 public Context getApplicationContext() { 824 return (mPackageInfo != null) ? 825 mPackageInfo.getApplication() : mMainThread.getApplication(); 826 } 827 828 @Override 829 public void setTheme(int resid) { 830 mThemeResource = resid; 831 } 832 833 @Override 834 public int getThemeResId() { 835 return mThemeResource; 836 } 837 838 @Override 839 public Resources.Theme getTheme() { 840 if (mTheme == null) { 841 mThemeResource = Resources.selectDefaultTheme(mThemeResource, 842 getOuterContext().getApplicationInfo().targetSdkVersion); 843 mTheme = mResources.newTheme(); 844 mTheme.applyStyle(mThemeResource, true); 845 } 846 return mTheme; 847 } 848 849 @Override 850 public ClassLoader getClassLoader() { 851 return mPackageInfo != null ? 852 mPackageInfo.getClassLoader() : ClassLoader.getSystemClassLoader(); 853 } 854 855 @Override 856 public String getPackageName() { 857 if (mPackageInfo != null) { 858 return mPackageInfo.getPackageName(); 859 } 860 // No mPackageInfo means this is a Context for the system itself, 861 // and this here is its name. 862 return "android"; 863 } 864 865 /** @hide */ 866 @Override 867 public String getBasePackageName() { 868 return mBasePackageName != null ? mBasePackageName : getPackageName(); 869 } 870 871 /** @hide */ 872 @Override 873 public String getOpPackageName() { 874 return mOpPackageName != null ? mOpPackageName : getBasePackageName(); 875 } 876 877 @Override 878 public ApplicationInfo getApplicationInfo() { 879 if (mPackageInfo != null) { 880 return mPackageInfo.getApplicationInfo(); 881 } 882 throw new RuntimeException("Not supported in system context"); 883 } 884 885 @Override 886 public String getPackageResourcePath() { 887 if (mPackageInfo != null) { 888 return mPackageInfo.getResDir(); 889 } 890 throw new RuntimeException("Not supported in system context"); 891 } 892 893 @Override 894 public String getPackageCodePath() { 895 if (mPackageInfo != null) { 896 return mPackageInfo.getAppDir(); 897 } 898 throw new RuntimeException("Not supported in system context"); 899 } 900 901 public File getSharedPrefsFile(String name) { 902 return makeFilename(getPreferencesDir(), name + ".xml"); 903 } 904 905 @Override 906 public SharedPreferences getSharedPreferences(String name, int mode) { 907 SharedPreferencesImpl sp; 908 synchronized (ContextImpl.class) { 909 if (sSharedPrefs == null) { 910 sSharedPrefs = new ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>>(); 911 } 912 913 final String packageName = getPackageName(); 914 ArrayMap<String, SharedPreferencesImpl> packagePrefs = sSharedPrefs.get(packageName); 915 if (packagePrefs == null) { 916 packagePrefs = new ArrayMap<String, SharedPreferencesImpl>(); 917 sSharedPrefs.put(packageName, packagePrefs); 918 } 919 920 // At least one application in the world actually passes in a null 921 // name. This happened to work because when we generated the file name 922 // we would stringify it to "null.xml". Nice. 923 if (mPackageInfo.getApplicationInfo().targetSdkVersion < 924 Build.VERSION_CODES.KITKAT) { 925 if (name == null) { 926 name = "null"; 927 } 928 } 929 930 sp = packagePrefs.get(name); 931 if (sp == null) { 932 File prefsFile = getSharedPrefsFile(name); 933 sp = new SharedPreferencesImpl(prefsFile, mode); 934 packagePrefs.put(name, sp); 935 return sp; 936 } 937 } 938 if ((mode & Context.MODE_MULTI_PROCESS) != 0 || 939 getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) { 940 // If somebody else (some other process) changed the prefs 941 // file behind our back, we reload it. This has been the 942 // historical (if undocumented) behavior. 943 sp.startReloadIfChangedUnexpectedly(); 944 } 945 return sp; 946 } 947 948 private File getPreferencesDir() { 949 synchronized (mSync) { 950 if (mPreferencesDir == null) { 951 mPreferencesDir = new File(getDataDirFile(), "shared_prefs"); 952 } 953 return mPreferencesDir; 954 } 955 } 956 957 @Override 958 public FileInputStream openFileInput(String name) 959 throws FileNotFoundException { 960 File f = makeFilename(getFilesDir(), name); 961 return new FileInputStream(f); 962 } 963 964 @Override 965 public FileOutputStream openFileOutput(String name, int mode) 966 throws FileNotFoundException { 967 final boolean append = (mode&MODE_APPEND) != 0; 968 File f = makeFilename(getFilesDir(), name); 969 try { 970 FileOutputStream fos = new FileOutputStream(f, append); 971 setFilePermissionsFromMode(f.getPath(), mode, 0); 972 return fos; 973 } catch (FileNotFoundException e) { 974 } 975 976 File parent = f.getParentFile(); 977 parent.mkdir(); 978 FileUtils.setPermissions( 979 parent.getPath(), 980 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, 981 -1, -1); 982 FileOutputStream fos = new FileOutputStream(f, append); 983 setFilePermissionsFromMode(f.getPath(), mode, 0); 984 return fos; 985 } 986 987 @Override 988 public boolean deleteFile(String name) { 989 File f = makeFilename(getFilesDir(), name); 990 return f.delete(); 991 } 992 993 // Common-path handling of app data dir creation 994 private static File createFilesDirLocked(File file) { 995 if (!file.exists()) { 996 if (!file.mkdirs()) { 997 if (file.exists()) { 998 // spurious failure; probably racing with another process for this app 999 return file; 1000 } 1001 Log.w(TAG, "Unable to create files subdir " + file.getPath()); 1002 return null; 1003 } 1004 FileUtils.setPermissions( 1005 file.getPath(), 1006 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, 1007 -1, -1); 1008 } 1009 return file; 1010 } 1011 1012 @Override 1013 public File getFilesDir() { 1014 synchronized (mSync) { 1015 if (mFilesDir == null) { 1016 mFilesDir = new File(getDataDirFile(), "files"); 1017 } 1018 return createFilesDirLocked(mFilesDir); 1019 } 1020 } 1021 1022 @Override 1023 public File getNoBackupFilesDir() { 1024 synchronized (mSync) { 1025 if (mNoBackupFilesDir == null) { 1026 mNoBackupFilesDir = new File(getDataDirFile(), "no_backup"); 1027 } 1028 return createFilesDirLocked(mNoBackupFilesDir); 1029 } 1030 } 1031 1032 @Override 1033 public File getExternalFilesDir(String type) { 1034 // Operates on primary external storage 1035 return getExternalFilesDirs(type)[0]; 1036 } 1037 1038 @Override 1039 public File[] getExternalFilesDirs(String type) { 1040 synchronized (mSync) { 1041 if (mExternalFilesDirs == null) { 1042 mExternalFilesDirs = Environment.buildExternalStorageAppFilesDirs(getPackageName()); 1043 } 1044 1045 // Splice in requested type, if any 1046 File[] dirs = mExternalFilesDirs; 1047 if (type != null) { 1048 dirs = Environment.buildPaths(dirs, type); 1049 } 1050 1051 // Create dirs if needed 1052 return ensureDirsExistOrFilter(dirs); 1053 } 1054 } 1055 1056 @Override 1057 public File getObbDir() { 1058 // Operates on primary external storage 1059 return getObbDirs()[0]; 1060 } 1061 1062 @Override 1063 public File[] getObbDirs() { 1064 synchronized (mSync) { 1065 if (mExternalObbDirs == null) { 1066 mExternalObbDirs = Environment.buildExternalStorageAppObbDirs(getPackageName()); 1067 } 1068 1069 // Create dirs if needed 1070 return ensureDirsExistOrFilter(mExternalObbDirs); 1071 } 1072 } 1073 1074 @Override 1075 public File getCacheDir() { 1076 synchronized (mSync) { 1077 if (mCacheDir == null) { 1078 mCacheDir = new File(getDataDirFile(), "cache"); 1079 } 1080 return createFilesDirLocked(mCacheDir); 1081 } 1082 } 1083 1084 @Override 1085 public File getCodeCacheDir() { 1086 synchronized (mSync) { 1087 if (mCodeCacheDir == null) { 1088 mCodeCacheDir = new File(getDataDirFile(), "code_cache"); 1089 } 1090 return createFilesDirLocked(mCodeCacheDir); 1091 } 1092 } 1093 1094 @Override 1095 public File getExternalCacheDir() { 1096 // Operates on primary external storage 1097 return getExternalCacheDirs()[0]; 1098 } 1099 1100 @Override 1101 public File[] getExternalCacheDirs() { 1102 synchronized (mSync) { 1103 if (mExternalCacheDirs == null) { 1104 mExternalCacheDirs = Environment.buildExternalStorageAppCacheDirs(getPackageName()); 1105 } 1106 1107 // Create dirs if needed 1108 return ensureDirsExistOrFilter(mExternalCacheDirs); 1109 } 1110 } 1111 1112 @Override 1113 public File[] getExternalMediaDirs() { 1114 synchronized (mSync) { 1115 if (mExternalMediaDirs == null) { 1116 mExternalMediaDirs = Environment.buildExternalStorageAppMediaDirs(getPackageName()); 1117 } 1118 1119 // Create dirs if needed 1120 return ensureDirsExistOrFilter(mExternalMediaDirs); 1121 } 1122 } 1123 1124 @Override 1125 public File getFileStreamPath(String name) { 1126 return makeFilename(getFilesDir(), name); 1127 } 1128 1129 @Override 1130 public String[] fileList() { 1131 final String[] list = getFilesDir().list(); 1132 return (list != null) ? list : EMPTY_FILE_LIST; 1133 } 1134 1135 @Override 1136 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) { 1137 return openOrCreateDatabase(name, mode, factory, null); 1138 } 1139 1140 @Override 1141 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, 1142 DatabaseErrorHandler errorHandler) { 1143 File f = validateFilePath(name, true); 1144 int flags = SQLiteDatabase.CREATE_IF_NECESSARY; 1145 if ((mode & MODE_ENABLE_WRITE_AHEAD_LOGGING) != 0) { 1146 flags |= SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING; 1147 } 1148 SQLiteDatabase db = SQLiteDatabase.openDatabase(f.getPath(), factory, flags, errorHandler); 1149 setFilePermissionsFromMode(f.getPath(), mode, 0); 1150 return db; 1151 } 1152 1153 @Override 1154 public boolean deleteDatabase(String name) { 1155 try { 1156 File f = validateFilePath(name, false); 1157 return SQLiteDatabase.deleteDatabase(f); 1158 } catch (Exception e) { 1159 } 1160 return false; 1161 } 1162 1163 @Override 1164 public File getDatabasePath(String name) { 1165 return validateFilePath(name, false); 1166 } 1167 1168 @Override 1169 public String[] databaseList() { 1170 final String[] list = getDatabasesDir().list(); 1171 return (list != null) ? list : EMPTY_FILE_LIST; 1172 } 1173 1174 1175 private File getDatabasesDir() { 1176 synchronized (mSync) { 1177 if (mDatabasesDir == null) { 1178 mDatabasesDir = new File(getDataDirFile(), "databases"); 1179 } 1180 if (mDatabasesDir.getPath().equals("databases")) { 1181 mDatabasesDir = new File("/data/system"); 1182 } 1183 return mDatabasesDir; 1184 } 1185 } 1186 1187 @Override 1188 public Drawable getWallpaper() { 1189 return getWallpaperManager().getDrawable(); 1190 } 1191 1192 @Override 1193 public Drawable peekWallpaper() { 1194 return getWallpaperManager().peekDrawable(); 1195 } 1196 1197 @Override 1198 public int getWallpaperDesiredMinimumWidth() { 1199 return getWallpaperManager().getDesiredMinimumWidth(); 1200 } 1201 1202 @Override 1203 public int getWallpaperDesiredMinimumHeight() { 1204 return getWallpaperManager().getDesiredMinimumHeight(); 1205 } 1206 1207 @Override 1208 public void setWallpaper(Bitmap bitmap) throws IOException { 1209 getWallpaperManager().setBitmap(bitmap); 1210 } 1211 1212 @Override 1213 public void setWallpaper(InputStream data) throws IOException { 1214 getWallpaperManager().setStream(data); 1215 } 1216 1217 @Override 1218 public void clearWallpaper() throws IOException { 1219 getWallpaperManager().clear(); 1220 } 1221 1222 @Override 1223 public void startActivity(Intent intent) { 1224 warnIfCallingFromSystemProcess(); 1225 startActivity(intent, null); 1226 } 1227 1228 /** @hide */ 1229 @Override 1230 public void startActivityAsUser(Intent intent, UserHandle user) { 1231 startActivityAsUser(intent, null, user); 1232 } 1233 1234 @Override 1235 public void startActivity(Intent intent, Bundle options) { 1236 warnIfCallingFromSystemProcess(); 1237 if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { 1238 throw new AndroidRuntimeException( 1239 "Calling startActivity() from outside of an Activity " 1240 + " context requires the FLAG_ACTIVITY_NEW_TASK flag." 1241 + " Is this really what you want?"); 1242 } 1243 mMainThread.getInstrumentation().execStartActivity( 1244 getOuterContext(), mMainThread.getApplicationThread(), null, 1245 (Activity)null, intent, -1, options); 1246 } 1247 1248 /** @hide */ 1249 @Override 1250 public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) { 1251 try { 1252 ActivityManagerNative.getDefault().startActivityAsUser( 1253 mMainThread.getApplicationThread(), getBasePackageName(), intent, 1254 intent.resolveTypeIfNeeded(getContentResolver()), 1255 null, null, 0, Intent.FLAG_ACTIVITY_NEW_TASK, null, options, 1256 user.getIdentifier()); 1257 } catch (RemoteException re) { 1258 } 1259 } 1260 1261 @Override 1262 public void startActivities(Intent[] intents) { 1263 warnIfCallingFromSystemProcess(); 1264 startActivities(intents, null); 1265 } 1266 1267 /** @hide */ 1268 @Override 1269 public void startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) { 1270 if ((intents[0].getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { 1271 throw new AndroidRuntimeException( 1272 "Calling startActivities() from outside of an Activity " 1273 + " context requires the FLAG_ACTIVITY_NEW_TASK flag on first Intent." 1274 + " Is this really what you want?"); 1275 } 1276 mMainThread.getInstrumentation().execStartActivitiesAsUser( 1277 getOuterContext(), mMainThread.getApplicationThread(), null, 1278 (Activity)null, intents, options, userHandle.getIdentifier()); 1279 } 1280 1281 @Override 1282 public void startActivities(Intent[] intents, Bundle options) { 1283 warnIfCallingFromSystemProcess(); 1284 if ((intents[0].getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { 1285 throw new AndroidRuntimeException( 1286 "Calling startActivities() from outside of an Activity " 1287 + " context requires the FLAG_ACTIVITY_NEW_TASK flag on first Intent." 1288 + " Is this really what you want?"); 1289 } 1290 mMainThread.getInstrumentation().execStartActivities( 1291 getOuterContext(), mMainThread.getApplicationThread(), null, 1292 (Activity)null, intents, options); 1293 } 1294 1295 @Override 1296 public void startIntentSender(IntentSender intent, 1297 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 1298 throws IntentSender.SendIntentException { 1299 startIntentSender(intent, fillInIntent, flagsMask, flagsValues, extraFlags, null); 1300 } 1301 1302 @Override 1303 public void startIntentSender(IntentSender intent, Intent fillInIntent, 1304 int flagsMask, int flagsValues, int extraFlags, Bundle options) 1305 throws IntentSender.SendIntentException { 1306 try { 1307 String resolvedType = null; 1308 if (fillInIntent != null) { 1309 fillInIntent.migrateExtraStreamToClipData(); 1310 fillInIntent.prepareToLeaveProcess(); 1311 resolvedType = fillInIntent.resolveTypeIfNeeded(getContentResolver()); 1312 } 1313 int result = ActivityManagerNative.getDefault() 1314 .startActivityIntentSender(mMainThread.getApplicationThread(), intent, 1315 fillInIntent, resolvedType, null, null, 1316 0, flagsMask, flagsValues, options); 1317 if (result == ActivityManager.START_CANCELED) { 1318 throw new IntentSender.SendIntentException(); 1319 } 1320 Instrumentation.checkStartActivityResult(result, null); 1321 } catch (RemoteException e) { 1322 } 1323 } 1324 1325 @Override 1326 public void sendBroadcast(Intent intent) { 1327 warnIfCallingFromSystemProcess(); 1328 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1329 try { 1330 intent.prepareToLeaveProcess(); 1331 ActivityManagerNative.getDefault().broadcastIntent( 1332 mMainThread.getApplicationThread(), intent, resolvedType, null, 1333 Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, false, false, 1334 getUserId()); 1335 } catch (RemoteException e) { 1336 } 1337 } 1338 1339 @Override 1340 public void sendBroadcast(Intent intent, String receiverPermission) { 1341 warnIfCallingFromSystemProcess(); 1342 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1343 try { 1344 intent.prepareToLeaveProcess(); 1345 ActivityManagerNative.getDefault().broadcastIntent( 1346 mMainThread.getApplicationThread(), intent, resolvedType, null, 1347 Activity.RESULT_OK, null, null, receiverPermission, AppOpsManager.OP_NONE, 1348 false, false, getUserId()); 1349 } catch (RemoteException e) { 1350 } 1351 } 1352 1353 @Override 1354 public void sendBroadcast(Intent intent, String receiverPermission, int appOp) { 1355 warnIfCallingFromSystemProcess(); 1356 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1357 try { 1358 intent.prepareToLeaveProcess(); 1359 ActivityManagerNative.getDefault().broadcastIntent( 1360 mMainThread.getApplicationThread(), intent, resolvedType, null, 1361 Activity.RESULT_OK, null, null, receiverPermission, appOp, false, false, 1362 getUserId()); 1363 } catch (RemoteException e) { 1364 } 1365 } 1366 1367 @Override 1368 public void sendOrderedBroadcast(Intent intent, 1369 String receiverPermission) { 1370 warnIfCallingFromSystemProcess(); 1371 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1372 try { 1373 intent.prepareToLeaveProcess(); 1374 ActivityManagerNative.getDefault().broadcastIntent( 1375 mMainThread.getApplicationThread(), intent, resolvedType, null, 1376 Activity.RESULT_OK, null, null, receiverPermission, AppOpsManager.OP_NONE, true, false, 1377 getUserId()); 1378 } catch (RemoteException e) { 1379 } 1380 } 1381 1382 @Override 1383 public void sendOrderedBroadcast(Intent intent, 1384 String receiverPermission, BroadcastReceiver resultReceiver, 1385 Handler scheduler, int initialCode, String initialData, 1386 Bundle initialExtras) { 1387 sendOrderedBroadcast(intent, receiverPermission, AppOpsManager.OP_NONE, 1388 resultReceiver, scheduler, initialCode, initialData, initialExtras); 1389 } 1390 1391 @Override 1392 public void sendOrderedBroadcast(Intent intent, 1393 String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 1394 Handler scheduler, int initialCode, String initialData, 1395 Bundle initialExtras) { 1396 warnIfCallingFromSystemProcess(); 1397 IIntentReceiver rd = null; 1398 if (resultReceiver != null) { 1399 if (mPackageInfo != null) { 1400 if (scheduler == null) { 1401 scheduler = mMainThread.getHandler(); 1402 } 1403 rd = mPackageInfo.getReceiverDispatcher( 1404 resultReceiver, getOuterContext(), scheduler, 1405 mMainThread.getInstrumentation(), false); 1406 } else { 1407 if (scheduler == null) { 1408 scheduler = mMainThread.getHandler(); 1409 } 1410 rd = new LoadedApk.ReceiverDispatcher( 1411 resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver(); 1412 } 1413 } 1414 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1415 try { 1416 intent.prepareToLeaveProcess(); 1417 ActivityManagerNative.getDefault().broadcastIntent( 1418 mMainThread.getApplicationThread(), intent, resolvedType, rd, 1419 initialCode, initialData, initialExtras, receiverPermission, appOp, 1420 true, false, getUserId()); 1421 } catch (RemoteException e) { 1422 } 1423 } 1424 1425 @Override 1426 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 1427 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1428 try { 1429 intent.prepareToLeaveProcess(); 1430 ActivityManagerNative.getDefault().broadcastIntent(mMainThread.getApplicationThread(), 1431 intent, resolvedType, null, Activity.RESULT_OK, null, null, null, 1432 AppOpsManager.OP_NONE, false, false, user.getIdentifier()); 1433 } catch (RemoteException e) { 1434 } 1435 } 1436 1437 @Override 1438 public void sendBroadcastAsUser(Intent intent, UserHandle user, 1439 String receiverPermission) { 1440 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1441 try { 1442 intent.prepareToLeaveProcess(); 1443 ActivityManagerNative.getDefault().broadcastIntent( 1444 mMainThread.getApplicationThread(), intent, resolvedType, null, 1445 Activity.RESULT_OK, null, null, receiverPermission, AppOpsManager.OP_NONE, false, false, 1446 user.getIdentifier()); 1447 } catch (RemoteException e) { 1448 } 1449 } 1450 1451 @Override 1452 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 1453 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 1454 int initialCode, String initialData, Bundle initialExtras) { 1455 sendOrderedBroadcastAsUser(intent, user, receiverPermission, AppOpsManager.OP_NONE, 1456 resultReceiver, scheduler, initialCode, initialData, initialExtras); 1457 } 1458 1459 @Override 1460 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 1461 String receiverPermission, int appOp, BroadcastReceiver resultReceiver, 1462 Handler scheduler, 1463 int initialCode, String initialData, Bundle initialExtras) { 1464 IIntentReceiver rd = null; 1465 if (resultReceiver != null) { 1466 if (mPackageInfo != null) { 1467 if (scheduler == null) { 1468 scheduler = mMainThread.getHandler(); 1469 } 1470 rd = mPackageInfo.getReceiverDispatcher( 1471 resultReceiver, getOuterContext(), scheduler, 1472 mMainThread.getInstrumentation(), false); 1473 } else { 1474 if (scheduler == null) { 1475 scheduler = mMainThread.getHandler(); 1476 } 1477 rd = new LoadedApk.ReceiverDispatcher( 1478 resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver(); 1479 } 1480 } 1481 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1482 try { 1483 intent.prepareToLeaveProcess(); 1484 ActivityManagerNative.getDefault().broadcastIntent( 1485 mMainThread.getApplicationThread(), intent, resolvedType, rd, 1486 initialCode, initialData, initialExtras, receiverPermission, 1487 appOp, true, false, user.getIdentifier()); 1488 } catch (RemoteException e) { 1489 } 1490 } 1491 1492 @Override 1493 public void sendStickyBroadcast(Intent intent) { 1494 warnIfCallingFromSystemProcess(); 1495 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1496 try { 1497 intent.prepareToLeaveProcess(); 1498 ActivityManagerNative.getDefault().broadcastIntent( 1499 mMainThread.getApplicationThread(), intent, resolvedType, null, 1500 Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, false, true, 1501 getUserId()); 1502 } catch (RemoteException e) { 1503 } 1504 } 1505 1506 @Override 1507 public void sendStickyOrderedBroadcast(Intent intent, 1508 BroadcastReceiver resultReceiver, 1509 Handler scheduler, int initialCode, String initialData, 1510 Bundle initialExtras) { 1511 warnIfCallingFromSystemProcess(); 1512 IIntentReceiver rd = null; 1513 if (resultReceiver != null) { 1514 if (mPackageInfo != null) { 1515 if (scheduler == null) { 1516 scheduler = mMainThread.getHandler(); 1517 } 1518 rd = mPackageInfo.getReceiverDispatcher( 1519 resultReceiver, getOuterContext(), scheduler, 1520 mMainThread.getInstrumentation(), false); 1521 } else { 1522 if (scheduler == null) { 1523 scheduler = mMainThread.getHandler(); 1524 } 1525 rd = new LoadedApk.ReceiverDispatcher( 1526 resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver(); 1527 } 1528 } 1529 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1530 try { 1531 intent.prepareToLeaveProcess(); 1532 ActivityManagerNative.getDefault().broadcastIntent( 1533 mMainThread.getApplicationThread(), intent, resolvedType, rd, 1534 initialCode, initialData, initialExtras, null, 1535 AppOpsManager.OP_NONE, true, true, getUserId()); 1536 } catch (RemoteException e) { 1537 } 1538 } 1539 1540 @Override 1541 public void removeStickyBroadcast(Intent intent) { 1542 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1543 if (resolvedType != null) { 1544 intent = new Intent(intent); 1545 intent.setDataAndType(intent.getData(), resolvedType); 1546 } 1547 try { 1548 intent.prepareToLeaveProcess(); 1549 ActivityManagerNative.getDefault().unbroadcastIntent( 1550 mMainThread.getApplicationThread(), intent, getUserId()); 1551 } catch (RemoteException e) { 1552 } 1553 } 1554 1555 @Override 1556 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 1557 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1558 try { 1559 intent.prepareToLeaveProcess(); 1560 ActivityManagerNative.getDefault().broadcastIntent( 1561 mMainThread.getApplicationThread(), intent, resolvedType, null, 1562 Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, false, true, user.getIdentifier()); 1563 } catch (RemoteException e) { 1564 } 1565 } 1566 1567 @Override 1568 public void sendStickyOrderedBroadcastAsUser(Intent intent, 1569 UserHandle user, BroadcastReceiver resultReceiver, 1570 Handler scheduler, int initialCode, String initialData, 1571 Bundle initialExtras) { 1572 IIntentReceiver rd = null; 1573 if (resultReceiver != null) { 1574 if (mPackageInfo != null) { 1575 if (scheduler == null) { 1576 scheduler = mMainThread.getHandler(); 1577 } 1578 rd = mPackageInfo.getReceiverDispatcher( 1579 resultReceiver, getOuterContext(), scheduler, 1580 mMainThread.getInstrumentation(), false); 1581 } else { 1582 if (scheduler == null) { 1583 scheduler = mMainThread.getHandler(); 1584 } 1585 rd = new LoadedApk.ReceiverDispatcher( 1586 resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver(); 1587 } 1588 } 1589 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1590 try { 1591 intent.prepareToLeaveProcess(); 1592 ActivityManagerNative.getDefault().broadcastIntent( 1593 mMainThread.getApplicationThread(), intent, resolvedType, rd, 1594 initialCode, initialData, initialExtras, null, 1595 AppOpsManager.OP_NONE, true, true, user.getIdentifier()); 1596 } catch (RemoteException e) { 1597 } 1598 } 1599 1600 @Override 1601 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 1602 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1603 if (resolvedType != null) { 1604 intent = new Intent(intent); 1605 intent.setDataAndType(intent.getData(), resolvedType); 1606 } 1607 try { 1608 intent.prepareToLeaveProcess(); 1609 ActivityManagerNative.getDefault().unbroadcastIntent( 1610 mMainThread.getApplicationThread(), intent, user.getIdentifier()); 1611 } catch (RemoteException e) { 1612 } 1613 } 1614 1615 @Override 1616 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { 1617 return registerReceiver(receiver, filter, null, null); 1618 } 1619 1620 @Override 1621 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, 1622 String broadcastPermission, Handler scheduler) { 1623 return registerReceiverInternal(receiver, getUserId(), 1624 filter, broadcastPermission, scheduler, getOuterContext()); 1625 } 1626 1627 @Override 1628 public Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user, 1629 IntentFilter filter, String broadcastPermission, Handler scheduler) { 1630 return registerReceiverInternal(receiver, user.getIdentifier(), 1631 filter, broadcastPermission, scheduler, getOuterContext()); 1632 } 1633 1634 private Intent registerReceiverInternal(BroadcastReceiver receiver, int userId, 1635 IntentFilter filter, String broadcastPermission, 1636 Handler scheduler, Context context) { 1637 IIntentReceiver rd = null; 1638 if (receiver != null) { 1639 if (mPackageInfo != null && context != null) { 1640 if (scheduler == null) { 1641 scheduler = mMainThread.getHandler(); 1642 } 1643 rd = mPackageInfo.getReceiverDispatcher( 1644 receiver, context, scheduler, 1645 mMainThread.getInstrumentation(), true); 1646 } else { 1647 if (scheduler == null) { 1648 scheduler = mMainThread.getHandler(); 1649 } 1650 rd = new LoadedApk.ReceiverDispatcher( 1651 receiver, context, scheduler, null, true).getIIntentReceiver(); 1652 } 1653 } 1654 try { 1655 return ActivityManagerNative.getDefault().registerReceiver( 1656 mMainThread.getApplicationThread(), mBasePackageName, 1657 rd, filter, broadcastPermission, userId); 1658 } catch (RemoteException e) { 1659 return null; 1660 } 1661 } 1662 1663 @Override 1664 public void unregisterReceiver(BroadcastReceiver receiver) { 1665 if (mPackageInfo != null) { 1666 IIntentReceiver rd = mPackageInfo.forgetReceiverDispatcher( 1667 getOuterContext(), receiver); 1668 try { 1669 ActivityManagerNative.getDefault().unregisterReceiver(rd); 1670 } catch (RemoteException e) { 1671 } 1672 } else { 1673 throw new RuntimeException("Not supported in system context"); 1674 } 1675 } 1676 1677 private void validateServiceIntent(Intent service) { 1678 if (service.getComponent() == null && service.getPackage() == null) { 1679 if (getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP) { 1680 IllegalArgumentException ex = new IllegalArgumentException( 1681 "Service Intent must be explicit: " + service); 1682 throw ex; 1683 } else { 1684 Log.w(TAG, "Implicit intents with startService are not safe: " + service 1685 + " " + Debug.getCallers(2, 3)); 1686 } 1687 } 1688 } 1689 1690 @Override 1691 public ComponentName startService(Intent service) { 1692 warnIfCallingFromSystemProcess(); 1693 return startServiceCommon(service, mUser); 1694 } 1695 1696 @Override 1697 public boolean stopService(Intent service) { 1698 warnIfCallingFromSystemProcess(); 1699 return stopServiceCommon(service, mUser); 1700 } 1701 1702 @Override 1703 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 1704 return startServiceCommon(service, user); 1705 } 1706 1707 private ComponentName startServiceCommon(Intent service, UserHandle user) { 1708 try { 1709 validateServiceIntent(service); 1710 service.prepareToLeaveProcess(); 1711 ComponentName cn = ActivityManagerNative.getDefault().startService( 1712 mMainThread.getApplicationThread(), service, 1713 service.resolveTypeIfNeeded(getContentResolver()), user.getIdentifier()); 1714 if (cn != null) { 1715 if (cn.getPackageName().equals("!")) { 1716 throw new SecurityException( 1717 "Not allowed to start service " + service 1718 + " without permission " + cn.getClassName()); 1719 } else if (cn.getPackageName().equals("!!")) { 1720 throw new SecurityException( 1721 "Unable to start service " + service 1722 + ": " + cn.getClassName()); 1723 } 1724 } 1725 return cn; 1726 } catch (RemoteException e) { 1727 return null; 1728 } 1729 } 1730 1731 @Override 1732 public boolean stopServiceAsUser(Intent service, UserHandle user) { 1733 return stopServiceCommon(service, user); 1734 } 1735 1736 private boolean stopServiceCommon(Intent service, UserHandle user) { 1737 try { 1738 validateServiceIntent(service); 1739 service.prepareToLeaveProcess(); 1740 int res = ActivityManagerNative.getDefault().stopService( 1741 mMainThread.getApplicationThread(), service, 1742 service.resolveTypeIfNeeded(getContentResolver()), user.getIdentifier()); 1743 if (res < 0) { 1744 throw new SecurityException( 1745 "Not allowed to stop service " + service); 1746 } 1747 return res != 0; 1748 } catch (RemoteException e) { 1749 return false; 1750 } 1751 } 1752 1753 @Override 1754 public boolean bindService(Intent service, ServiceConnection conn, 1755 int flags) { 1756 warnIfCallingFromSystemProcess(); 1757 return bindServiceCommon(service, conn, flags, Process.myUserHandle()); 1758 } 1759 1760 /** @hide */ 1761 @Override 1762 public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags, 1763 UserHandle user) { 1764 return bindServiceCommon(service, conn, flags, user); 1765 } 1766 1767 private boolean bindServiceCommon(Intent service, ServiceConnection conn, int flags, 1768 UserHandle user) { 1769 IServiceConnection sd; 1770 if (conn == null) { 1771 throw new IllegalArgumentException("connection is null"); 1772 } 1773 if (mPackageInfo != null) { 1774 sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), 1775 mMainThread.getHandler(), flags); 1776 } else { 1777 throw new RuntimeException("Not supported in system context"); 1778 } 1779 validateServiceIntent(service); 1780 try { 1781 IBinder token = getActivityToken(); 1782 if (token == null && (flags&BIND_AUTO_CREATE) == 0 && mPackageInfo != null 1783 && mPackageInfo.getApplicationInfo().targetSdkVersion 1784 < android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH) { 1785 flags |= BIND_WAIVE_PRIORITY; 1786 } 1787 service.prepareToLeaveProcess(); 1788 int res = ActivityManagerNative.getDefault().bindService( 1789 mMainThread.getApplicationThread(), getActivityToken(), 1790 service, service.resolveTypeIfNeeded(getContentResolver()), 1791 sd, flags, user.getIdentifier()); 1792 if (res < 0) { 1793 throw new SecurityException( 1794 "Not allowed to bind to service " + service); 1795 } 1796 return res != 0; 1797 } catch (RemoteException e) { 1798 return false; 1799 } 1800 } 1801 1802 @Override 1803 public void unbindService(ServiceConnection conn) { 1804 if (conn == null) { 1805 throw new IllegalArgumentException("connection is null"); 1806 } 1807 if (mPackageInfo != null) { 1808 IServiceConnection sd = mPackageInfo.forgetServiceDispatcher( 1809 getOuterContext(), conn); 1810 try { 1811 ActivityManagerNative.getDefault().unbindService(sd); 1812 } catch (RemoteException e) { 1813 } 1814 } else { 1815 throw new RuntimeException("Not supported in system context"); 1816 } 1817 } 1818 1819 @Override 1820 public boolean startInstrumentation(ComponentName className, 1821 String profileFile, Bundle arguments) { 1822 try { 1823 if (arguments != null) { 1824 arguments.setAllowFds(false); 1825 } 1826 return ActivityManagerNative.getDefault().startInstrumentation( 1827 className, profileFile, 0, arguments, null, null, getUserId(), 1828 null /* ABI override */); 1829 } catch (RemoteException e) { 1830 // System has crashed, nothing we can do. 1831 } 1832 return false; 1833 } 1834 1835 @Override 1836 public Object getSystemService(String name) { 1837 ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name); 1838 return fetcher == null ? null : fetcher.getService(this); 1839 } 1840 1841 private WallpaperManager getWallpaperManager() { 1842 return (WallpaperManager) WALLPAPER_FETCHER.getService(this); 1843 } 1844 1845 /* package */ static DropBoxManager createDropBoxManager() { 1846 IBinder b = ServiceManager.getService(DROPBOX_SERVICE); 1847 IDropBoxManagerService service = IDropBoxManagerService.Stub.asInterface(b); 1848 if (service == null) { 1849 // Don't return a DropBoxManager that will NPE upon use. 1850 // This also avoids caching a broken DropBoxManager in 1851 // getDropBoxManager during early boot, before the 1852 // DROPBOX_SERVICE is registered. 1853 return null; 1854 } 1855 return new DropBoxManager(service); 1856 } 1857 1858 @Override 1859 public int checkPermission(String permission, int pid, int uid) { 1860 if (permission == null) { 1861 throw new IllegalArgumentException("permission is null"); 1862 } 1863 1864 try { 1865 return ActivityManagerNative.getDefault().checkPermission( 1866 permission, pid, uid); 1867 } catch (RemoteException e) { 1868 return PackageManager.PERMISSION_DENIED; 1869 } 1870 } 1871 1872 /** @hide */ 1873 @Override 1874 public int checkPermission(String permission, int pid, int uid, IBinder callerToken) { 1875 if (permission == null) { 1876 throw new IllegalArgumentException("permission is null"); 1877 } 1878 1879 try { 1880 return ActivityManagerNative.getDefault().checkPermissionWithToken( 1881 permission, pid, uid, callerToken); 1882 } catch (RemoteException e) { 1883 return PackageManager.PERMISSION_DENIED; 1884 } 1885 } 1886 1887 @Override 1888 public int checkCallingPermission(String permission) { 1889 if (permission == null) { 1890 throw new IllegalArgumentException("permission is null"); 1891 } 1892 1893 int pid = Binder.getCallingPid(); 1894 if (pid != Process.myPid()) { 1895 return checkPermission(permission, pid, Binder.getCallingUid()); 1896 } 1897 return PackageManager.PERMISSION_DENIED; 1898 } 1899 1900 @Override 1901 public int checkCallingOrSelfPermission(String permission) { 1902 if (permission == null) { 1903 throw new IllegalArgumentException("permission is null"); 1904 } 1905 1906 return checkPermission(permission, Binder.getCallingPid(), 1907 Binder.getCallingUid()); 1908 } 1909 1910 private void enforce( 1911 String permission, int resultOfCheck, 1912 boolean selfToo, int uid, String message) { 1913 if (resultOfCheck != PackageManager.PERMISSION_GRANTED) { 1914 throw new SecurityException( 1915 (message != null ? (message + ": ") : "") + 1916 (selfToo 1917 ? "Neither user " + uid + " nor current process has " 1918 : "uid " + uid + " does not have ") + 1919 permission + 1920 "."); 1921 } 1922 } 1923 1924 public void enforcePermission( 1925 String permission, int pid, int uid, String message) { 1926 enforce(permission, 1927 checkPermission(permission, pid, uid), 1928 false, 1929 uid, 1930 message); 1931 } 1932 1933 public void enforceCallingPermission(String permission, String message) { 1934 enforce(permission, 1935 checkCallingPermission(permission), 1936 false, 1937 Binder.getCallingUid(), 1938 message); 1939 } 1940 1941 public void enforceCallingOrSelfPermission( 1942 String permission, String message) { 1943 enforce(permission, 1944 checkCallingOrSelfPermission(permission), 1945 true, 1946 Binder.getCallingUid(), 1947 message); 1948 } 1949 1950 @Override 1951 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 1952 try { 1953 ActivityManagerNative.getDefault().grantUriPermission( 1954 mMainThread.getApplicationThread(), toPackage, 1955 ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri)); 1956 } catch (RemoteException e) { 1957 } 1958 } 1959 1960 @Override 1961 public void revokeUriPermission(Uri uri, int modeFlags) { 1962 try { 1963 ActivityManagerNative.getDefault().revokeUriPermission( 1964 mMainThread.getApplicationThread(), 1965 ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri)); 1966 } catch (RemoteException e) { 1967 } 1968 } 1969 1970 @Override 1971 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 1972 try { 1973 return ActivityManagerNative.getDefault().checkUriPermission( 1974 ContentProvider.getUriWithoutUserId(uri), pid, uid, modeFlags, 1975 resolveUserId(uri), null); 1976 } catch (RemoteException e) { 1977 return PackageManager.PERMISSION_DENIED; 1978 } 1979 } 1980 1981 /** @hide */ 1982 @Override 1983 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) { 1984 try { 1985 return ActivityManagerNative.getDefault().checkUriPermission( 1986 ContentProvider.getUriWithoutUserId(uri), pid, uid, modeFlags, 1987 resolveUserId(uri), callerToken); 1988 } catch (RemoteException e) { 1989 return PackageManager.PERMISSION_DENIED; 1990 } 1991 } 1992 1993 private int resolveUserId(Uri uri) { 1994 return ContentProvider.getUserIdFromUri(uri, getUserId()); 1995 } 1996 1997 @Override 1998 public int checkCallingUriPermission(Uri uri, int modeFlags) { 1999 int pid = Binder.getCallingPid(); 2000 if (pid != Process.myPid()) { 2001 return checkUriPermission(uri, pid, 2002 Binder.getCallingUid(), modeFlags); 2003 } 2004 return PackageManager.PERMISSION_DENIED; 2005 } 2006 2007 @Override 2008 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 2009 return checkUriPermission(uri, Binder.getCallingPid(), 2010 Binder.getCallingUid(), modeFlags); 2011 } 2012 2013 @Override 2014 public int checkUriPermission(Uri uri, String readPermission, 2015 String writePermission, int pid, int uid, int modeFlags) { 2016 if (DEBUG) { 2017 Log.i("foo", "checkUriPermission: uri=" + uri + "readPermission=" 2018 + readPermission + " writePermission=" + writePermission 2019 + " pid=" + pid + " uid=" + uid + " mode" + modeFlags); 2020 } 2021 if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { 2022 if (readPermission == null 2023 || checkPermission(readPermission, pid, uid) 2024 == PackageManager.PERMISSION_GRANTED) { 2025 return PackageManager.PERMISSION_GRANTED; 2026 } 2027 } 2028 if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { 2029 if (writePermission == null 2030 || checkPermission(writePermission, pid, uid) 2031 == PackageManager.PERMISSION_GRANTED) { 2032 return PackageManager.PERMISSION_GRANTED; 2033 } 2034 } 2035 return uri != null ? checkUriPermission(uri, pid, uid, modeFlags) 2036 : PackageManager.PERMISSION_DENIED; 2037 } 2038 2039 private String uriModeFlagToString(int uriModeFlags) { 2040 StringBuilder builder = new StringBuilder(); 2041 if ((uriModeFlags & Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { 2042 builder.append("read and "); 2043 } 2044 if ((uriModeFlags & Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { 2045 builder.append("write and "); 2046 } 2047 if ((uriModeFlags & Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION) != 0) { 2048 builder.append("persistable and "); 2049 } 2050 if ((uriModeFlags & Intent.FLAG_GRANT_PREFIX_URI_PERMISSION) != 0) { 2051 builder.append("prefix and "); 2052 } 2053 2054 if (builder.length() > 5) { 2055 builder.setLength(builder.length() - 5); 2056 return builder.toString(); 2057 } else { 2058 throw new IllegalArgumentException("Unknown permission mode flags: " + uriModeFlags); 2059 } 2060 } 2061 2062 private void enforceForUri( 2063 int modeFlags, int resultOfCheck, boolean selfToo, 2064 int uid, Uri uri, String message) { 2065 if (resultOfCheck != PackageManager.PERMISSION_GRANTED) { 2066 throw new SecurityException( 2067 (message != null ? (message + ": ") : "") + 2068 (selfToo 2069 ? "Neither user " + uid + " nor current process has " 2070 : "User " + uid + " does not have ") + 2071 uriModeFlagToString(modeFlags) + 2072 " permission on " + 2073 uri + 2074 "."); 2075 } 2076 } 2077 2078 public void enforceUriPermission( 2079 Uri uri, int pid, int uid, int modeFlags, String message) { 2080 enforceForUri( 2081 modeFlags, checkUriPermission(uri, pid, uid, modeFlags), 2082 false, uid, uri, message); 2083 } 2084 2085 public void enforceCallingUriPermission( 2086 Uri uri, int modeFlags, String message) { 2087 enforceForUri( 2088 modeFlags, checkCallingUriPermission(uri, modeFlags), 2089 false, 2090 Binder.getCallingUid(), uri, message); 2091 } 2092 2093 public void enforceCallingOrSelfUriPermission( 2094 Uri uri, int modeFlags, String message) { 2095 enforceForUri( 2096 modeFlags, 2097 checkCallingOrSelfUriPermission(uri, modeFlags), true, 2098 Binder.getCallingUid(), uri, message); 2099 } 2100 2101 public void enforceUriPermission( 2102 Uri uri, String readPermission, String writePermission, 2103 int pid, int uid, int modeFlags, String message) { 2104 enforceForUri(modeFlags, 2105 checkUriPermission( 2106 uri, readPermission, writePermission, pid, uid, 2107 modeFlags), 2108 false, 2109 uid, 2110 uri, 2111 message); 2112 } 2113 2114 /** 2115 * Logs a warning if the system process directly called a method such as 2116 * {@link #startService(Intent)} instead of {@link #startServiceAsUser(Intent, UserHandle)}. 2117 * The "AsUser" variants allow us to properly enforce the user's restrictions. 2118 */ 2119 private void warnIfCallingFromSystemProcess() { 2120 if (Process.myUid() == Process.SYSTEM_UID) { 2121 Slog.w(TAG, "Calling a method in the system process without a qualified user: " 2122 + Debug.getCallers(5)); 2123 } 2124 } 2125 2126 @Override 2127 public Context createApplicationContext(ApplicationInfo application, int flags) 2128 throws NameNotFoundException { 2129 LoadedApk pi = mMainThread.getPackageInfo(application, mResources.getCompatibilityInfo(), 2130 flags | CONTEXT_REGISTER_PACKAGE); 2131 if (pi != null) { 2132 final boolean restricted = (flags & CONTEXT_RESTRICTED) == CONTEXT_RESTRICTED; 2133 ContextImpl c = new ContextImpl(this, mMainThread, pi, mActivityToken, 2134 new UserHandle(UserHandle.getUserId(application.uid)), restricted, 2135 mDisplay, mOverrideConfiguration); 2136 if (c.mResources != null) { 2137 return c; 2138 } 2139 } 2140 2141 throw new PackageManager.NameNotFoundException( 2142 "Application package " + application.packageName + " not found"); 2143 } 2144 2145 @Override 2146 public Context createPackageContext(String packageName, int flags) 2147 throws NameNotFoundException { 2148 return createPackageContextAsUser(packageName, flags, 2149 mUser != null ? mUser : Process.myUserHandle()); 2150 } 2151 2152 @Override 2153 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 2154 throws NameNotFoundException { 2155 final boolean restricted = (flags & CONTEXT_RESTRICTED) == CONTEXT_RESTRICTED; 2156 if (packageName.equals("system") || packageName.equals("android")) { 2157 return new ContextImpl(this, mMainThread, mPackageInfo, mActivityToken, 2158 user, restricted, mDisplay, mOverrideConfiguration); 2159 } 2160 2161 LoadedApk pi = mMainThread.getPackageInfo(packageName, mResources.getCompatibilityInfo(), 2162 flags | CONTEXT_REGISTER_PACKAGE, user.getIdentifier()); 2163 if (pi != null) { 2164 ContextImpl c = new ContextImpl(this, mMainThread, pi, mActivityToken, 2165 user, restricted, mDisplay, mOverrideConfiguration); 2166 if (c.mResources != null) { 2167 return c; 2168 } 2169 } 2170 2171 // Should be a better exception. 2172 throw new PackageManager.NameNotFoundException( 2173 "Application package " + packageName + " not found"); 2174 } 2175 2176 @Override 2177 public Context createConfigurationContext(Configuration overrideConfiguration) { 2178 if (overrideConfiguration == null) { 2179 throw new IllegalArgumentException("overrideConfiguration must not be null"); 2180 } 2181 2182 return new ContextImpl(this, mMainThread, mPackageInfo, mActivityToken, 2183 mUser, mRestricted, mDisplay, overrideConfiguration); 2184 } 2185 2186 @Override 2187 public Context createDisplayContext(Display display) { 2188 if (display == null) { 2189 throw new IllegalArgumentException("display must not be null"); 2190 } 2191 2192 return new ContextImpl(this, mMainThread, mPackageInfo, mActivityToken, 2193 mUser, mRestricted, display, mOverrideConfiguration); 2194 } 2195 2196 private int getDisplayId() { 2197 return mDisplay != null ? mDisplay.getDisplayId() : Display.DEFAULT_DISPLAY; 2198 } 2199 2200 @Override 2201 public boolean isRestricted() { 2202 return mRestricted; 2203 } 2204 2205 @Override 2206 public DisplayAdjustments getDisplayAdjustments(int displayId) { 2207 return mDisplayAdjustments; 2208 } 2209 2210 private File getDataDirFile() { 2211 if (mPackageInfo != null) { 2212 return mPackageInfo.getDataDirFile(); 2213 } 2214 throw new RuntimeException("Not supported in system context"); 2215 } 2216 2217 @Override 2218 public File getDir(String name, int mode) { 2219 name = "app_" + name; 2220 File file = makeFilename(getDataDirFile(), name); 2221 if (!file.exists()) { 2222 file.mkdir(); 2223 setFilePermissionsFromMode(file.getPath(), mode, 2224 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH); 2225 } 2226 return file; 2227 } 2228 2229 /** {@hide} */ 2230 public int getUserId() { 2231 return mUser.getIdentifier(); 2232 } 2233 2234 static ContextImpl createSystemContext(ActivityThread mainThread) { 2235 LoadedApk packageInfo = new LoadedApk(mainThread); 2236 ContextImpl context = new ContextImpl(null, mainThread, 2237 packageInfo, null, null, false, null, null); 2238 context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(), 2239 context.mResourcesManager.getDisplayMetricsLocked(Display.DEFAULT_DISPLAY)); 2240 return context; 2241 } 2242 2243 static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo) { 2244 if (packageInfo == null) throw new IllegalArgumentException("packageInfo"); 2245 return new ContextImpl(null, mainThread, 2246 packageInfo, null, null, false, null, null); 2247 } 2248 2249 static ContextImpl createActivityContext(ActivityThread mainThread, 2250 LoadedApk packageInfo, IBinder activityToken) { 2251 if (packageInfo == null) throw new IllegalArgumentException("packageInfo"); 2252 if (activityToken == null) throw new IllegalArgumentException("activityInfo"); 2253 return new ContextImpl(null, mainThread, 2254 packageInfo, activityToken, null, false, null, null); 2255 } 2256 2257 private ContextImpl(ContextImpl container, ActivityThread mainThread, 2258 LoadedApk packageInfo, IBinder activityToken, UserHandle user, boolean restricted, 2259 Display display, Configuration overrideConfiguration) { 2260 mOuterContext = this; 2261 2262 mMainThread = mainThread; 2263 mActivityToken = activityToken; 2264 mRestricted = restricted; 2265 2266 if (user == null) { 2267 user = Process.myUserHandle(); 2268 } 2269 mUser = user; 2270 2271 mPackageInfo = packageInfo; 2272 mResourcesManager = ResourcesManager.getInstance(); 2273 mDisplay = display; 2274 mOverrideConfiguration = overrideConfiguration; 2275 2276 final int displayId = getDisplayId(); 2277 CompatibilityInfo compatInfo = null; 2278 if (container != null) { 2279 compatInfo = container.getDisplayAdjustments(displayId).getCompatibilityInfo(); 2280 } 2281 if (compatInfo == null && displayId == Display.DEFAULT_DISPLAY) { 2282 compatInfo = packageInfo.getCompatibilityInfo(); 2283 } 2284 mDisplayAdjustments.setCompatibilityInfo(compatInfo); 2285 mDisplayAdjustments.setActivityToken(activityToken); 2286 2287 Resources resources = packageInfo.getResources(mainThread); 2288 if (resources != null) { 2289 if (activityToken != null 2290 || displayId != Display.DEFAULT_DISPLAY 2291 || overrideConfiguration != null 2292 || (compatInfo != null && compatInfo.applicationScale 2293 != resources.getCompatibilityInfo().applicationScale)) { 2294 resources = mResourcesManager.getTopLevelResources(packageInfo.getResDir(), 2295 packageInfo.getSplitResDirs(), packageInfo.getOverlayDirs(), 2296 packageInfo.getApplicationInfo().sharedLibraryFiles, displayId, 2297 overrideConfiguration, compatInfo, activityToken); 2298 } 2299 } 2300 mResources = resources; 2301 2302 if (container != null) { 2303 mBasePackageName = container.mBasePackageName; 2304 mOpPackageName = container.mOpPackageName; 2305 } else { 2306 mBasePackageName = packageInfo.mPackageName; 2307 ApplicationInfo ainfo = packageInfo.getApplicationInfo(); 2308 if (ainfo.uid == Process.SYSTEM_UID && ainfo.uid != Process.myUid()) { 2309 // Special case: system components allow themselves to be loaded in to other 2310 // processes. For purposes of app ops, we must then consider the context as 2311 // belonging to the package of this process, not the system itself, otherwise 2312 // the package+uid verifications in app ops will fail. 2313 mOpPackageName = ActivityThread.currentPackageName(); 2314 } else { 2315 mOpPackageName = mBasePackageName; 2316 } 2317 } 2318 2319 mContentResolver = new ApplicationContentResolver(this, mainThread, user); 2320 } 2321 2322 void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) { 2323 mPackageInfo.installSystemApplicationInfo(info, classLoader); 2324 } 2325 2326 final void scheduleFinalCleanup(String who, String what) { 2327 mMainThread.scheduleContextCleanup(this, who, what); 2328 } 2329 2330 final void performFinalCleanup(String who, String what) { 2331 //Log.i(TAG, "Cleanup up context: " + this); 2332 mPackageInfo.removeContextRegistrations(getOuterContext(), who, what); 2333 } 2334 2335 final Context getReceiverRestrictedContext() { 2336 if (mReceiverRestrictedContext != null) { 2337 return mReceiverRestrictedContext; 2338 } 2339 return mReceiverRestrictedContext = new ReceiverRestrictedContext(getOuterContext()); 2340 } 2341 2342 final void setOuterContext(Context context) { 2343 mOuterContext = context; 2344 } 2345 2346 final Context getOuterContext() { 2347 return mOuterContext; 2348 } 2349 2350 final IBinder getActivityToken() { 2351 return mActivityToken; 2352 } 2353 2354 static void setFilePermissionsFromMode(String name, int mode, 2355 int extraPermissions) { 2356 int perms = FileUtils.S_IRUSR|FileUtils.S_IWUSR 2357 |FileUtils.S_IRGRP|FileUtils.S_IWGRP 2358 |extraPermissions; 2359 if ((mode&MODE_WORLD_READABLE) != 0) { 2360 perms |= FileUtils.S_IROTH; 2361 } 2362 if ((mode&MODE_WORLD_WRITEABLE) != 0) { 2363 perms |= FileUtils.S_IWOTH; 2364 } 2365 if (DEBUG) { 2366 Log.i(TAG, "File " + name + ": mode=0x" + Integer.toHexString(mode) 2367 + ", perms=0x" + Integer.toHexString(perms)); 2368 } 2369 FileUtils.setPermissions(name, perms, -1, -1); 2370 } 2371 2372 private File validateFilePath(String name, boolean createDirectory) { 2373 File dir; 2374 File f; 2375 2376 if (name.charAt(0) == File.separatorChar) { 2377 String dirPath = name.substring(0, name.lastIndexOf(File.separatorChar)); 2378 dir = new File(dirPath); 2379 name = name.substring(name.lastIndexOf(File.separatorChar)); 2380 f = new File(dir, name); 2381 } else { 2382 dir = getDatabasesDir(); 2383 f = makeFilename(dir, name); 2384 } 2385 2386 if (createDirectory && !dir.isDirectory() && dir.mkdir()) { 2387 FileUtils.setPermissions(dir.getPath(), 2388 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, 2389 -1, -1); 2390 } 2391 2392 return f; 2393 } 2394 2395 private File makeFilename(File base, String name) { 2396 if (name.indexOf(File.separatorChar) < 0) { 2397 return new File(base, name); 2398 } 2399 throw new IllegalArgumentException( 2400 "File " + name + " contains a path separator"); 2401 } 2402 2403 /** 2404 * Ensure that given directories exist, trying to create them if missing. If 2405 * unable to create, they are filtered by replacing with {@code null}. 2406 */ 2407 private File[] ensureDirsExistOrFilter(File[] dirs) { 2408 File[] result = new File[dirs.length]; 2409 for (int i = 0; i < dirs.length; i++) { 2410 File dir = dirs[i]; 2411 if (!dir.exists()) { 2412 if (!dir.mkdirs()) { 2413 // recheck existence in case of cross-process race 2414 if (!dir.exists()) { 2415 // Failing to mkdir() may be okay, since we might not have 2416 // enough permissions; ask vold to create on our behalf. 2417 final IMountService mount = IMountService.Stub.asInterface( 2418 ServiceManager.getService("mount")); 2419 int res = -1; 2420 try { 2421 res = mount.mkdirs(getPackageName(), dir.getAbsolutePath()); 2422 } catch (Exception ignored) { 2423 } 2424 if (res != 0) { 2425 Log.w(TAG, "Failed to ensure directory: " + dir); 2426 dir = null; 2427 } 2428 } 2429 } 2430 } 2431 result[i] = dir; 2432 } 2433 return result; 2434 } 2435 2436 // ---------------------------------------------------------------------- 2437 // ---------------------------------------------------------------------- 2438 // ---------------------------------------------------------------------- 2439 2440 private static final class ApplicationContentResolver extends ContentResolver { 2441 private final ActivityThread mMainThread; 2442 private final UserHandle mUser; 2443 2444 public ApplicationContentResolver( 2445 Context context, ActivityThread mainThread, UserHandle user) { 2446 super(context); 2447 mMainThread = Preconditions.checkNotNull(mainThread); 2448 mUser = Preconditions.checkNotNull(user); 2449 } 2450 2451 @Override 2452 protected IContentProvider acquireProvider(Context context, String auth) { 2453 return mMainThread.acquireProvider(context, 2454 ContentProvider.getAuthorityWithoutUserId(auth), 2455 resolveUserIdFromAuthority(auth), true); 2456 } 2457 2458 @Override 2459 protected IContentProvider acquireExistingProvider(Context context, String auth) { 2460 return mMainThread.acquireExistingProvider(context, 2461 ContentProvider.getAuthorityWithoutUserId(auth), 2462 resolveUserIdFromAuthority(auth), true); 2463 } 2464 2465 @Override 2466 public boolean releaseProvider(IContentProvider provider) { 2467 return mMainThread.releaseProvider(provider, true); 2468 } 2469 2470 @Override 2471 protected IContentProvider acquireUnstableProvider(Context c, String auth) { 2472 return mMainThread.acquireProvider(c, 2473 ContentProvider.getAuthorityWithoutUserId(auth), 2474 resolveUserIdFromAuthority(auth), false); 2475 } 2476 2477 @Override 2478 public boolean releaseUnstableProvider(IContentProvider icp) { 2479 return mMainThread.releaseProvider(icp, false); 2480 } 2481 2482 @Override 2483 public void unstableProviderDied(IContentProvider icp) { 2484 mMainThread.handleUnstableProviderDied(icp.asBinder(), true); 2485 } 2486 2487 @Override 2488 public void appNotRespondingViaProvider(IContentProvider icp) { 2489 mMainThread.appNotRespondingViaProvider(icp.asBinder()); 2490 } 2491 2492 /** @hide */ 2493 protected int resolveUserIdFromAuthority(String auth) { 2494 return ContentProvider.getUserIdFromAuthority(auth, mUser.getIdentifier()); 2495 } 2496 } 2497 } 2498