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