ContextImpl.java revision 6d51571835737c7502a2e111ee9dc2527ebad984
1e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard/* 2e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * Copyright (C) 2006 The Android Open Source Project 3e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * 4e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * Licensed under the Apache License, Version 2.0 (the "License"); 5e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * you may not use this file except in compliance with the License. 6e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * You may obtain a copy of the License at 7e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * 8e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * http://www.apache.org/licenses/LICENSE-2.0 9e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * 10e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * Unless required by applicable law or agreed to in writing, software 11e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * distributed under the License is distributed on an "AS IS" BASIS, 12e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * See the License for the specific language governing permissions and 14e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard * limitations under the License. 15e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard */ 16e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard 17e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgardpackage android.app; 18e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgard 19e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgardimport com.android.internal.policy.PolicyManager; 20e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgardimport com.android.internal.util.Preconditions; 21956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dong 22956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.bluetooth.BluetoothAdapter; 23956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.BroadcastReceiver; 24956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.ComponentName; 25956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.ContentResolver; 26956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.Context; 27956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.ContextWrapper; 28956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.IContentProvider; 29b676a05348e4c516fa8b57e33b10548e6142c3f8Mans Rullgardimport android.content.Intent; 30956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.IntentFilter; 31956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.IIntentReceiver; 32956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.IntentSender; 33956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.ReceiverCallNotAllowedException; 34956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.ServiceConnection; 35956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.SharedPreferences; 36956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.pm.ApplicationInfo; 37956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.pm.IPackageManager; 38956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.pm.PackageManager; 39956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.pm.PackageManager.NameNotFoundException; 40956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.res.AssetManager; 41956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.res.CompatibilityInfo; 42956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.res.Configuration; 43956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.content.res.Resources; 44956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.database.DatabaseErrorHandler; 45e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgardimport android.database.sqlite.SQLiteDatabase; 46e2e838afcf03e603a41a0455846eaf9614537c16Mans Rullgardimport android.database.sqlite.SQLiteDatabase.CursorFactory; 47956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.graphics.Bitmap; 48956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.graphics.drawable.Drawable; 49956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.hardware.ISerialManager; 50956c553ab0ce72f8074ad0fda2ffd66a0305700cJames Dongimport android.hardware.SensorManager; 51import android.hardware.SerialManager; 52import android.hardware.SystemSensorManager; 53import android.hardware.display.DisplayManager; 54import android.hardware.input.IInputManager; 55import android.hardware.input.InputManager; 56import android.hardware.usb.IUsbManager; 57import android.hardware.usb.UsbManager; 58import android.location.CountryDetector; 59import android.location.ICountryDetector; 60import android.location.ILocationManager; 61import android.location.LocationManager; 62import android.media.AudioManager; 63import android.media.MediaRouter; 64import android.net.ConnectivityManager; 65import android.net.IConnectivityManager; 66import android.net.INetworkPolicyManager; 67import android.net.NetworkPolicyManager; 68import android.net.ThrottleManager; 69import android.net.IThrottleManager; 70import android.net.Uri; 71import android.net.nsd.INsdManager; 72import android.net.nsd.NsdManager; 73import android.net.wifi.IWifiManager; 74import android.net.wifi.WifiManager; 75import android.net.wifi.p2p.IWifiP2pManager; 76import android.net.wifi.p2p.WifiP2pManager; 77import android.nfc.NfcManager; 78import android.os.Binder; 79import android.os.Bundle; 80import android.os.DropBoxManager; 81import android.os.Environment; 82import android.os.FileUtils; 83import android.os.Handler; 84import android.os.IBinder; 85import android.os.IPowerManager; 86import android.os.IUserManager; 87import android.os.Looper; 88import android.os.PowerManager; 89import android.os.Process; 90import android.os.RemoteException; 91import android.os.ServiceManager; 92import android.os.UserHandle; 93import android.os.SystemVibrator; 94import android.os.UserManager; 95import android.os.storage.StorageManager; 96import android.telephony.TelephonyManager; 97import android.content.ClipboardManager; 98import android.util.AndroidRuntimeException; 99import android.util.Log; 100import android.view.CompatibilityInfoHolder; 101import android.view.ContextThemeWrapper; 102import android.view.Display; 103import android.view.WindowManagerImpl; 104import android.view.accessibility.AccessibilityManager; 105import android.view.inputmethod.InputMethodManager; 106import android.view.textservice.TextServicesManager; 107import android.accounts.AccountManager; 108import android.accounts.IAccountManager; 109import android.app.admin.DevicePolicyManager; 110import com.android.internal.os.IDropBoxManagerService; 111 112import java.io.File; 113import java.io.FileInputStream; 114import java.io.FileNotFoundException; 115import java.io.FileOutputStream; 116import java.io.IOException; 117import java.io.InputStream; 118import java.util.ArrayList; 119import java.util.HashMap; 120 121class ReceiverRestrictedContext extends ContextWrapper { 122 ReceiverRestrictedContext(Context base) { 123 super(base); 124 } 125 126 @Override 127 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { 128 return registerReceiver(receiver, filter, null, null); 129 } 130 131 @Override 132 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, 133 String broadcastPermission, Handler scheduler) { 134 if (receiver == null) { 135 // Allow retrieving current sticky broadcast; this is safe since we 136 // aren't actually registering a receiver. 137 return super.registerReceiver(null, filter, broadcastPermission, scheduler); 138 } else { 139 throw new ReceiverCallNotAllowedException( 140 "BroadcastReceiver components are not allowed to register to receive intents"); 141 } 142 } 143 144 @Override 145 public Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user, 146 IntentFilter filter, String broadcastPermission, Handler scheduler) { 147 if (receiver == null) { 148 // Allow retrieving current sticky broadcast; this is safe since we 149 // aren't actually registering a receiver. 150 return super.registerReceiverAsUser(null, user, filter, broadcastPermission, scheduler); 151 } else { 152 throw new ReceiverCallNotAllowedException( 153 "BroadcastReceiver components are not allowed to register to receive intents"); 154 } 155 } 156 157 @Override 158 public boolean bindService(Intent service, ServiceConnection conn, int flags) { 159 throw new ReceiverCallNotAllowedException( 160 "BroadcastReceiver components are not allowed to bind to services"); 161 } 162} 163 164/** 165 * Common implementation of Context API, which provides the base 166 * context object for Activity and other application components. 167 */ 168class ContextImpl extends Context { 169 private final static String TAG = "ApplicationContext"; 170 private final static boolean DEBUG = false; 171 172 private static final HashMap<String, SharedPreferencesImpl> sSharedPrefs = 173 new HashMap<String, SharedPreferencesImpl>(); 174 175 /*package*/ LoadedApk mPackageInfo; 176 private String mBasePackageName; 177 private Resources mResources; 178 /*package*/ ActivityThread mMainThread; 179 private Context mOuterContext; 180 private IBinder mActivityToken = null; 181 private ApplicationContentResolver mContentResolver; 182 private int mThemeResource = 0; 183 private Resources.Theme mTheme = null; 184 private PackageManager mPackageManager; 185 private Display mDisplay; // may be null if default display 186 private Context mReceiverRestrictedContext = null; 187 private boolean mRestricted; 188 private UserHandle mUser; 189 190 private final Object mSync = new Object(); 191 192 private File mDatabasesDir; 193 private File mPreferencesDir; 194 private File mFilesDir; 195 private File mCacheDir; 196 private File mObbDir; 197 private File mExternalFilesDir; 198 private File mExternalCacheDir; 199 200 private static final String[] EMPTY_FILE_LIST = {}; 201 202 /** 203 * Override this class when the system service constructor needs a 204 * ContextImpl. Else, use StaticServiceFetcher below. 205 */ 206 /*package*/ static class ServiceFetcher { 207 int mContextCacheIndex = -1; 208 209 /** 210 * Main entrypoint; only override if you don't need caching. 211 */ 212 public Object getService(ContextImpl ctx) { 213 ArrayList<Object> cache = ctx.mServiceCache; 214 Object service; 215 synchronized (cache) { 216 if (cache.size() == 0) { 217 // Initialize the cache vector on first access. 218 // At this point sNextPerContextServiceCacheIndex 219 // is the number of potential services that are 220 // cached per-Context. 221 for (int i = 0; i < sNextPerContextServiceCacheIndex; i++) { 222 cache.add(null); 223 } 224 } else { 225 service = cache.get(mContextCacheIndex); 226 if (service != null) { 227 return service; 228 } 229 } 230 service = createService(ctx); 231 cache.set(mContextCacheIndex, service); 232 return service; 233 } 234 } 235 236 /** 237 * Override this to create a new per-Context instance of the 238 * service. getService() will handle locking and caching. 239 */ 240 public Object createService(ContextImpl ctx) { 241 throw new RuntimeException("Not implemented"); 242 } 243 } 244 245 /** 246 * Override this class for services to be cached process-wide. 247 */ 248 abstract static class StaticServiceFetcher extends ServiceFetcher { 249 private Object mCachedInstance; 250 251 @Override 252 public final Object getService(ContextImpl unused) { 253 synchronized (StaticServiceFetcher.this) { 254 Object service = mCachedInstance; 255 if (service != null) { 256 return service; 257 } 258 return mCachedInstance = createStaticService(); 259 } 260 } 261 262 public abstract Object createStaticService(); 263 } 264 265 private static final HashMap<String, ServiceFetcher> SYSTEM_SERVICE_MAP = 266 new HashMap<String, ServiceFetcher>(); 267 268 private static int sNextPerContextServiceCacheIndex = 0; 269 private static void registerService(String serviceName, ServiceFetcher fetcher) { 270 if (!(fetcher instanceof StaticServiceFetcher)) { 271 fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++; 272 } 273 SYSTEM_SERVICE_MAP.put(serviceName, fetcher); 274 } 275 276 // This one's defined separately and given a variable name so it 277 // can be re-used by getWallpaperManager(), avoiding a HashMap 278 // lookup. 279 private static ServiceFetcher WALLPAPER_FETCHER = new ServiceFetcher() { 280 public Object createService(ContextImpl ctx) { 281 return new WallpaperManager(ctx.getOuterContext(), 282 ctx.mMainThread.getHandler()); 283 }}; 284 285 static { 286 registerService(ACCESSIBILITY_SERVICE, new ServiceFetcher() { 287 public Object getService(ContextImpl ctx) { 288 return AccessibilityManager.getInstance(ctx); 289 }}); 290 291 registerService(ACCOUNT_SERVICE, new ServiceFetcher() { 292 public Object createService(ContextImpl ctx) { 293 IBinder b = ServiceManager.getService(ACCOUNT_SERVICE); 294 IAccountManager service = IAccountManager.Stub.asInterface(b); 295 return new AccountManager(ctx, service); 296 }}); 297 298 registerService(ACTIVITY_SERVICE, new ServiceFetcher() { 299 public Object createService(ContextImpl ctx) { 300 return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler()); 301 }}); 302 303 registerService(ALARM_SERVICE, new StaticServiceFetcher() { 304 public Object createStaticService() { 305 IBinder b = ServiceManager.getService(ALARM_SERVICE); 306 IAlarmManager service = IAlarmManager.Stub.asInterface(b); 307 return new AlarmManager(service); 308 }}); 309 310 registerService(AUDIO_SERVICE, new ServiceFetcher() { 311 public Object createService(ContextImpl ctx) { 312 return new AudioManager(ctx); 313 }}); 314 315 registerService(MEDIA_ROUTER_SERVICE, new ServiceFetcher() { 316 public Object createService(ContextImpl ctx) { 317 return new MediaRouter(ctx); 318 }}); 319 320 registerService(BLUETOOTH_SERVICE, new ServiceFetcher() { 321 public Object createService(ContextImpl ctx) { 322 return BluetoothAdapter.getDefaultAdapter(); 323 }}); 324 325 registerService(CLIPBOARD_SERVICE, new ServiceFetcher() { 326 public Object createService(ContextImpl ctx) { 327 return new ClipboardManager(ctx.getOuterContext(), 328 ctx.mMainThread.getHandler()); 329 }}); 330 331 registerService(CONNECTIVITY_SERVICE, new StaticServiceFetcher() { 332 public Object createStaticService() { 333 IBinder b = ServiceManager.getService(CONNECTIVITY_SERVICE); 334 return new ConnectivityManager(IConnectivityManager.Stub.asInterface(b)); 335 }}); 336 337 registerService(COUNTRY_DETECTOR, new StaticServiceFetcher() { 338 public Object createStaticService() { 339 IBinder b = ServiceManager.getService(COUNTRY_DETECTOR); 340 return new CountryDetector(ICountryDetector.Stub.asInterface(b)); 341 }}); 342 343 registerService(DEVICE_POLICY_SERVICE, new ServiceFetcher() { 344 public Object createService(ContextImpl ctx) { 345 return DevicePolicyManager.create(ctx, ctx.mMainThread.getHandler()); 346 }}); 347 348 registerService(DOWNLOAD_SERVICE, new ServiceFetcher() { 349 public Object createService(ContextImpl ctx) { 350 return new DownloadManager(ctx.getContentResolver(), ctx.getPackageName()); 351 }}); 352 353 registerService(NFC_SERVICE, new ServiceFetcher() { 354 public Object createService(ContextImpl ctx) { 355 return new NfcManager(ctx); 356 }}); 357 358 registerService(DROPBOX_SERVICE, new StaticServiceFetcher() { 359 public Object createStaticService() { 360 return createDropBoxManager(); 361 }}); 362 363 registerService(INPUT_SERVICE, new StaticServiceFetcher() { 364 public Object createStaticService() { 365 return InputManager.getInstance(); 366 }}); 367 368 registerService(DISPLAY_SERVICE, new ServiceFetcher() { 369 @Override 370 public Object createService(ContextImpl ctx) { 371 return new DisplayManager(ctx.getOuterContext()); 372 }}); 373 374 registerService(INPUT_METHOD_SERVICE, new ServiceFetcher() { 375 public Object createService(ContextImpl ctx) { 376 return InputMethodManager.getInstance(ctx); 377 }}); 378 379 registerService(TEXT_SERVICES_MANAGER_SERVICE, new ServiceFetcher() { 380 public Object createService(ContextImpl ctx) { 381 return TextServicesManager.getInstance(); 382 }}); 383 384 registerService(KEYGUARD_SERVICE, new ServiceFetcher() { 385 public Object getService(ContextImpl ctx) { 386 // TODO: why isn't this caching it? It wasn't 387 // before, so I'm preserving the old behavior and 388 // using getService(), instead of createService() 389 // which would do the caching. 390 return new KeyguardManager(); 391 }}); 392 393 registerService(LAYOUT_INFLATER_SERVICE, new ServiceFetcher() { 394 public Object createService(ContextImpl ctx) { 395 return PolicyManager.makeNewLayoutInflater(ctx.getOuterContext()); 396 }}); 397 398 registerService(LOCATION_SERVICE, new ServiceFetcher() { 399 public Object createService(ContextImpl ctx) { 400 IBinder b = ServiceManager.getService(LOCATION_SERVICE); 401 return new LocationManager(ctx, ILocationManager.Stub.asInterface(b)); 402 }}); 403 404 registerService(NETWORK_POLICY_SERVICE, new ServiceFetcher() { 405 @Override 406 public Object createService(ContextImpl ctx) { 407 return new NetworkPolicyManager(INetworkPolicyManager.Stub.asInterface( 408 ServiceManager.getService(NETWORK_POLICY_SERVICE))); 409 } 410 }); 411 412 registerService(NOTIFICATION_SERVICE, new ServiceFetcher() { 413 public Object createService(ContextImpl ctx) { 414 final Context outerContext = ctx.getOuterContext(); 415 return new NotificationManager( 416 new ContextThemeWrapper(outerContext, 417 Resources.selectSystemTheme(0, 418 outerContext.getApplicationInfo().targetSdkVersion, 419 com.android.internal.R.style.Theme_Dialog, 420 com.android.internal.R.style.Theme_Holo_Dialog, 421 com.android.internal.R.style.Theme_DeviceDefault_Dialog)), 422 ctx.mMainThread.getHandler()); 423 }}); 424 425 registerService(NSD_SERVICE, new ServiceFetcher() { 426 @Override 427 public Object createService(ContextImpl ctx) { 428 IBinder b = ServiceManager.getService(NSD_SERVICE); 429 INsdManager service = INsdManager.Stub.asInterface(b); 430 return new NsdManager(ctx.getOuterContext(), service); 431 }}); 432 433 // Note: this was previously cached in a static variable, but 434 // constructed using mMainThread.getHandler(), so converting 435 // it to be a regular Context-cached service... 436 registerService(POWER_SERVICE, new ServiceFetcher() { 437 public Object createService(ContextImpl ctx) { 438 IBinder b = ServiceManager.getService(POWER_SERVICE); 439 IPowerManager service = IPowerManager.Stub.asInterface(b); 440 return new PowerManager(ctx.getOuterContext(), 441 service, ctx.mMainThread.getHandler()); 442 }}); 443 444 registerService(SEARCH_SERVICE, new ServiceFetcher() { 445 public Object createService(ContextImpl ctx) { 446 return new SearchManager(ctx.getOuterContext(), 447 ctx.mMainThread.getHandler()); 448 }}); 449 450 registerService(SENSOR_SERVICE, new ServiceFetcher() { 451 public Object createService(ContextImpl ctx) { 452 return new SystemSensorManager(ctx.mMainThread.getHandler().getLooper()); 453 }}); 454 455 registerService(STATUS_BAR_SERVICE, new ServiceFetcher() { 456 public Object createService(ContextImpl ctx) { 457 return new StatusBarManager(ctx.getOuterContext()); 458 }}); 459 460 registerService(STORAGE_SERVICE, new ServiceFetcher() { 461 public Object createService(ContextImpl ctx) { 462 try { 463 return new StorageManager(ctx.mMainThread.getHandler().getLooper()); 464 } catch (RemoteException rex) { 465 Log.e(TAG, "Failed to create StorageManager", rex); 466 return null; 467 } 468 }}); 469 470 registerService(TELEPHONY_SERVICE, new ServiceFetcher() { 471 public Object createService(ContextImpl ctx) { 472 return new TelephonyManager(ctx.getOuterContext()); 473 }}); 474 475 registerService(THROTTLE_SERVICE, new StaticServiceFetcher() { 476 public Object createStaticService() { 477 IBinder b = ServiceManager.getService(THROTTLE_SERVICE); 478 return new ThrottleManager(IThrottleManager.Stub.asInterface(b)); 479 }}); 480 481 registerService(UI_MODE_SERVICE, new ServiceFetcher() { 482 public Object createService(ContextImpl ctx) { 483 return new UiModeManager(); 484 }}); 485 486 registerService(USB_SERVICE, new ServiceFetcher() { 487 public Object createService(ContextImpl ctx) { 488 IBinder b = ServiceManager.getService(USB_SERVICE); 489 return new UsbManager(ctx, IUsbManager.Stub.asInterface(b)); 490 }}); 491 492 registerService(SERIAL_SERVICE, new ServiceFetcher() { 493 public Object createService(ContextImpl ctx) { 494 IBinder b = ServiceManager.getService(SERIAL_SERVICE); 495 return new SerialManager(ctx, ISerialManager.Stub.asInterface(b)); 496 }}); 497 498 registerService(VIBRATOR_SERVICE, new ServiceFetcher() { 499 public Object createService(ContextImpl ctx) { 500 return new SystemVibrator(); 501 }}); 502 503 registerService(WALLPAPER_SERVICE, WALLPAPER_FETCHER); 504 505 registerService(WIFI_SERVICE, new ServiceFetcher() { 506 public Object createService(ContextImpl ctx) { 507 IBinder b = ServiceManager.getService(WIFI_SERVICE); 508 IWifiManager service = IWifiManager.Stub.asInterface(b); 509 return new WifiManager(ctx.getOuterContext(), service); 510 }}); 511 512 registerService(WIFI_P2P_SERVICE, new ServiceFetcher() { 513 public Object createService(ContextImpl ctx) { 514 IBinder b = ServiceManager.getService(WIFI_P2P_SERVICE); 515 IWifiP2pManager service = IWifiP2pManager.Stub.asInterface(b); 516 return new WifiP2pManager(service); 517 }}); 518 519 registerService(WINDOW_SERVICE, new ServiceFetcher() { 520 public Object getService(ContextImpl ctx) { 521 Display display = ctx.mDisplay; 522 if (display == null) { 523 DisplayManager dm = (DisplayManager)ctx.getOuterContext().getSystemService( 524 Context.DISPLAY_SERVICE); 525 display = dm.getDisplay(Display.DEFAULT_DISPLAY); 526 } 527 return new WindowManagerImpl(display); 528 }}); 529 530 registerService(USER_SERVICE, new ServiceFetcher() { 531 public Object getService(ContextImpl ctx) { 532 IBinder b = ServiceManager.getService(USER_SERVICE); 533 IUserManager service = IUserManager.Stub.asInterface(b); 534 return new UserManager(ctx, service); 535 }}); 536 } 537 538 static ContextImpl getImpl(Context context) { 539 Context nextContext; 540 while ((context instanceof ContextWrapper) && 541 (nextContext=((ContextWrapper)context).getBaseContext()) != null) { 542 context = nextContext; 543 } 544 return (ContextImpl)context; 545 } 546 547 // The system service cache for the system services that are 548 // cached per-ContextImpl. Package-scoped to avoid accessor 549 // methods. 550 final ArrayList<Object> mServiceCache = new ArrayList<Object>(); 551 552 @Override 553 public AssetManager getAssets() { 554 return getResources().getAssets(); 555 } 556 557 @Override 558 public Resources getResources() { 559 return mResources; 560 } 561 562 @Override 563 public PackageManager getPackageManager() { 564 if (mPackageManager != null) { 565 return mPackageManager; 566 } 567 568 IPackageManager pm = ActivityThread.getPackageManager(); 569 if (pm != null) { 570 // Doesn't matter if we make more than one instance. 571 return (mPackageManager = new ApplicationPackageManager(this, pm)); 572 } 573 574 return null; 575 } 576 577 @Override 578 public ContentResolver getContentResolver() { 579 return mContentResolver; 580 } 581 582 @Override 583 public Looper getMainLooper() { 584 return mMainThread.getLooper(); 585 } 586 587 @Override 588 public Context getApplicationContext() { 589 return (mPackageInfo != null) ? 590 mPackageInfo.getApplication() : mMainThread.getApplication(); 591 } 592 593 @Override 594 public void setTheme(int resid) { 595 mThemeResource = resid; 596 } 597 598 @Override 599 public int getThemeResId() { 600 return mThemeResource; 601 } 602 603 @Override 604 public Resources.Theme getTheme() { 605 if (mTheme == null) { 606 mThemeResource = Resources.selectDefaultTheme(mThemeResource, 607 getOuterContext().getApplicationInfo().targetSdkVersion); 608 mTheme = mResources.newTheme(); 609 mTheme.applyStyle(mThemeResource, true); 610 } 611 return mTheme; 612 } 613 614 @Override 615 public ClassLoader getClassLoader() { 616 return mPackageInfo != null ? 617 mPackageInfo.getClassLoader() : ClassLoader.getSystemClassLoader(); 618 } 619 620 @Override 621 public String getPackageName() { 622 if (mPackageInfo != null) { 623 return mPackageInfo.getPackageName(); 624 } 625 throw new RuntimeException("Not supported in system context"); 626 } 627 628 @Override 629 public ApplicationInfo getApplicationInfo() { 630 if (mPackageInfo != null) { 631 return mPackageInfo.getApplicationInfo(); 632 } 633 throw new RuntimeException("Not supported in system context"); 634 } 635 636 @Override 637 public String getPackageResourcePath() { 638 if (mPackageInfo != null) { 639 return mPackageInfo.getResDir(); 640 } 641 throw new RuntimeException("Not supported in system context"); 642 } 643 644 @Override 645 public String getPackageCodePath() { 646 if (mPackageInfo != null) { 647 return mPackageInfo.getAppDir(); 648 } 649 throw new RuntimeException("Not supported in system context"); 650 } 651 652 public File getSharedPrefsFile(String name) { 653 return makeFilename(getPreferencesDir(), name + ".xml"); 654 } 655 656 @Override 657 public SharedPreferences getSharedPreferences(String name, int mode) { 658 SharedPreferencesImpl sp; 659 synchronized (sSharedPrefs) { 660 sp = sSharedPrefs.get(name); 661 if (sp == null) { 662 File prefsFile = getSharedPrefsFile(name); 663 sp = new SharedPreferencesImpl(prefsFile, mode); 664 sSharedPrefs.put(name, sp); 665 return sp; 666 } 667 } 668 if ((mode & Context.MODE_MULTI_PROCESS) != 0 || 669 getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) { 670 // If somebody else (some other process) changed the prefs 671 // file behind our back, we reload it. This has been the 672 // historical (if undocumented) behavior. 673 sp.startReloadIfChangedUnexpectedly(); 674 } 675 return sp; 676 } 677 678 private File getPreferencesDir() { 679 synchronized (mSync) { 680 if (mPreferencesDir == null) { 681 mPreferencesDir = new File(getDataDirFile(), "shared_prefs"); 682 } 683 return mPreferencesDir; 684 } 685 } 686 687 @Override 688 public FileInputStream openFileInput(String name) 689 throws FileNotFoundException { 690 File f = makeFilename(getFilesDir(), name); 691 return new FileInputStream(f); 692 } 693 694 @Override 695 public FileOutputStream openFileOutput(String name, int mode) 696 throws FileNotFoundException { 697 final boolean append = (mode&MODE_APPEND) != 0; 698 File f = makeFilename(getFilesDir(), name); 699 try { 700 FileOutputStream fos = new FileOutputStream(f, append); 701 setFilePermissionsFromMode(f.getPath(), mode, 0); 702 return fos; 703 } catch (FileNotFoundException e) { 704 } 705 706 File parent = f.getParentFile(); 707 parent.mkdir(); 708 FileUtils.setPermissions( 709 parent.getPath(), 710 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, 711 -1, -1); 712 FileOutputStream fos = new FileOutputStream(f, append); 713 setFilePermissionsFromMode(f.getPath(), mode, 0); 714 return fos; 715 } 716 717 @Override 718 public boolean deleteFile(String name) { 719 File f = makeFilename(getFilesDir(), name); 720 return f.delete(); 721 } 722 723 @Override 724 public File getFilesDir() { 725 synchronized (mSync) { 726 if (mFilesDir == null) { 727 mFilesDir = new File(getDataDirFile(), "files"); 728 } 729 if (!mFilesDir.exists()) { 730 if(!mFilesDir.mkdirs()) { 731 Log.w(TAG, "Unable to create files directory " + mFilesDir.getPath()); 732 return null; 733 } 734 FileUtils.setPermissions( 735 mFilesDir.getPath(), 736 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, 737 -1, -1); 738 } 739 return mFilesDir; 740 } 741 } 742 743 @Override 744 public File getExternalFilesDir(String type) { 745 synchronized (mSync) { 746 if (mExternalFilesDir == null) { 747 mExternalFilesDir = Environment.getExternalStorageAppFilesDirectory( 748 getPackageName()); 749 } 750 if (!mExternalFilesDir.exists()) { 751 try { 752 (new File(Environment.getExternalStorageAndroidDataDir(), 753 ".nomedia")).createNewFile(); 754 } catch (IOException e) { 755 } 756 if (!mExternalFilesDir.mkdirs()) { 757 Log.w(TAG, "Unable to create external files directory"); 758 return null; 759 } 760 } 761 if (type == null) { 762 return mExternalFilesDir; 763 } 764 File dir = new File(mExternalFilesDir, type); 765 if (!dir.exists()) { 766 if (!dir.mkdirs()) { 767 Log.w(TAG, "Unable to create external media directory " + dir); 768 return null; 769 } 770 } 771 return dir; 772 } 773 } 774 775 @Override 776 public File getObbDir() { 777 synchronized (mSync) { 778 if (mObbDir == null) { 779 mObbDir = Environment.getExternalStorageAppObbDirectory( 780 getPackageName()); 781 } 782 return mObbDir; 783 } 784 } 785 786 @Override 787 public File getCacheDir() { 788 synchronized (mSync) { 789 if (mCacheDir == null) { 790 mCacheDir = new File(getDataDirFile(), "cache"); 791 } 792 if (!mCacheDir.exists()) { 793 if(!mCacheDir.mkdirs()) { 794 Log.w(TAG, "Unable to create cache directory " + mCacheDir.getAbsolutePath()); 795 return null; 796 } 797 FileUtils.setPermissions( 798 mCacheDir.getPath(), 799 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, 800 -1, -1); 801 } 802 } 803 return mCacheDir; 804 } 805 806 @Override 807 public File getExternalCacheDir() { 808 synchronized (mSync) { 809 if (mExternalCacheDir == null) { 810 mExternalCacheDir = Environment.getExternalStorageAppCacheDirectory( 811 getPackageName()); 812 } 813 if (!mExternalCacheDir.exists()) { 814 try { 815 (new File(Environment.getExternalStorageAndroidDataDir(), 816 ".nomedia")).createNewFile(); 817 } catch (IOException e) { 818 } 819 if (!mExternalCacheDir.mkdirs()) { 820 Log.w(TAG, "Unable to create external cache directory"); 821 return null; 822 } 823 } 824 return mExternalCacheDir; 825 } 826 } 827 828 @Override 829 public File getFileStreamPath(String name) { 830 return makeFilename(getFilesDir(), name); 831 } 832 833 @Override 834 public String[] fileList() { 835 final String[] list = getFilesDir().list(); 836 return (list != null) ? list : EMPTY_FILE_LIST; 837 } 838 839 @Override 840 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) { 841 return openOrCreateDatabase(name, mode, factory, null); 842 } 843 844 @Override 845 public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory, 846 DatabaseErrorHandler errorHandler) { 847 File f = validateFilePath(name, true); 848 int flags = SQLiteDatabase.CREATE_IF_NECESSARY; 849 if ((mode & MODE_ENABLE_WRITE_AHEAD_LOGGING) != 0) { 850 flags |= SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING; 851 } 852 SQLiteDatabase db = SQLiteDatabase.openDatabase(f.getPath(), factory, flags, errorHandler); 853 setFilePermissionsFromMode(f.getPath(), mode, 0); 854 return db; 855 } 856 857 @Override 858 public boolean deleteDatabase(String name) { 859 try { 860 File f = validateFilePath(name, false); 861 return SQLiteDatabase.deleteDatabase(f); 862 } catch (Exception e) { 863 } 864 return false; 865 } 866 867 @Override 868 public File getDatabasePath(String name) { 869 return validateFilePath(name, false); 870 } 871 872 @Override 873 public String[] databaseList() { 874 final String[] list = getDatabasesDir().list(); 875 return (list != null) ? list : EMPTY_FILE_LIST; 876 } 877 878 879 private File getDatabasesDir() { 880 synchronized (mSync) { 881 if (mDatabasesDir == null) { 882 mDatabasesDir = new File(getDataDirFile(), "databases"); 883 } 884 if (mDatabasesDir.getPath().equals("databases")) { 885 mDatabasesDir = new File("/data/system"); 886 } 887 return mDatabasesDir; 888 } 889 } 890 891 @Override 892 public Drawable getWallpaper() { 893 return getWallpaperManager().getDrawable(); 894 } 895 896 @Override 897 public Drawable peekWallpaper() { 898 return getWallpaperManager().peekDrawable(); 899 } 900 901 @Override 902 public int getWallpaperDesiredMinimumWidth() { 903 return getWallpaperManager().getDesiredMinimumWidth(); 904 } 905 906 @Override 907 public int getWallpaperDesiredMinimumHeight() { 908 return getWallpaperManager().getDesiredMinimumHeight(); 909 } 910 911 @Override 912 public void setWallpaper(Bitmap bitmap) throws IOException { 913 getWallpaperManager().setBitmap(bitmap); 914 } 915 916 @Override 917 public void setWallpaper(InputStream data) throws IOException { 918 getWallpaperManager().setStream(data); 919 } 920 921 @Override 922 public void clearWallpaper() throws IOException { 923 getWallpaperManager().clear(); 924 } 925 926 @Override 927 public void startActivity(Intent intent) { 928 startActivity(intent, null); 929 } 930 931 /** @hide */ 932 @Override 933 public void startActivityAsUser(Intent intent, UserHandle user) { 934 startActivityAsUser(intent, null, user); 935 } 936 937 @Override 938 public void startActivity(Intent intent, Bundle options) { 939 if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { 940 throw new AndroidRuntimeException( 941 "Calling startActivity() from outside of an Activity " 942 + " context requires the FLAG_ACTIVITY_NEW_TASK flag." 943 + " Is this really what you want?"); 944 } 945 mMainThread.getInstrumentation().execStartActivity( 946 getOuterContext(), mMainThread.getApplicationThread(), null, 947 (Activity)null, intent, -1, options); 948 } 949 950 /** @hide */ 951 @Override 952 public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) { 953 try { 954 ActivityManagerNative.getDefault().startActivityAsUser( 955 mMainThread.getApplicationThread(), intent, 956 intent.resolveTypeIfNeeded(getContentResolver()), 957 null, null, 0, Intent.FLAG_ACTIVITY_NEW_TASK, null, null, options, 958 user.getIdentifier()); 959 } catch (RemoteException re) { 960 } 961 } 962 963 @Override 964 public void startActivities(Intent[] intents) { 965 startActivities(intents, null); 966 } 967 968 @Override 969 public void startActivities(Intent[] intents, Bundle options) { 970 if ((intents[0].getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { 971 throw new AndroidRuntimeException( 972 "Calling startActivities() from outside of an Activity " 973 + " context requires the FLAG_ACTIVITY_NEW_TASK flag on first Intent." 974 + " Is this really what you want?"); 975 } 976 mMainThread.getInstrumentation().execStartActivities( 977 getOuterContext(), mMainThread.getApplicationThread(), null, 978 (Activity)null, intents, options); 979 } 980 981 @Override 982 public void startIntentSender(IntentSender intent, 983 Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags) 984 throws IntentSender.SendIntentException { 985 startIntentSender(intent, fillInIntent, flagsMask, flagsValues, extraFlags, null); 986 } 987 988 @Override 989 public void startIntentSender(IntentSender intent, Intent fillInIntent, 990 int flagsMask, int flagsValues, int extraFlags, Bundle options) 991 throws IntentSender.SendIntentException { 992 try { 993 String resolvedType = null; 994 if (fillInIntent != null) { 995 fillInIntent.setAllowFds(false); 996 resolvedType = fillInIntent.resolveTypeIfNeeded(getContentResolver()); 997 } 998 int result = ActivityManagerNative.getDefault() 999 .startActivityIntentSender(mMainThread.getApplicationThread(), intent, 1000 fillInIntent, resolvedType, null, null, 1001 0, flagsMask, flagsValues, options); 1002 if (result == ActivityManager.START_CANCELED) { 1003 throw new IntentSender.SendIntentException(); 1004 } 1005 Instrumentation.checkStartActivityResult(result, null); 1006 } catch (RemoteException e) { 1007 } 1008 } 1009 1010 @Override 1011 public void sendBroadcast(Intent intent) { 1012 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1013 try { 1014 intent.setAllowFds(false); 1015 ActivityManagerNative.getDefault().broadcastIntent( 1016 mMainThread.getApplicationThread(), intent, resolvedType, null, 1017 Activity.RESULT_OK, null, null, null, false, false, 1018 UserHandle.myUserId()); 1019 } catch (RemoteException e) { 1020 } 1021 } 1022 1023 @Override 1024 public void sendBroadcast(Intent intent, String receiverPermission) { 1025 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1026 try { 1027 intent.setAllowFds(false); 1028 ActivityManagerNative.getDefault().broadcastIntent( 1029 mMainThread.getApplicationThread(), intent, resolvedType, null, 1030 Activity.RESULT_OK, null, null, receiverPermission, false, false, 1031 UserHandle.myUserId()); 1032 } catch (RemoteException e) { 1033 } 1034 } 1035 1036 @Override 1037 public void sendOrderedBroadcast(Intent intent, 1038 String receiverPermission) { 1039 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1040 try { 1041 intent.setAllowFds(false); 1042 ActivityManagerNative.getDefault().broadcastIntent( 1043 mMainThread.getApplicationThread(), intent, resolvedType, null, 1044 Activity.RESULT_OK, null, null, receiverPermission, true, false, 1045 UserHandle.myUserId()); 1046 } catch (RemoteException e) { 1047 } 1048 } 1049 1050 @Override 1051 public void sendOrderedBroadcast(Intent intent, 1052 String receiverPermission, BroadcastReceiver resultReceiver, 1053 Handler scheduler, int initialCode, String initialData, 1054 Bundle initialExtras) { 1055 IIntentReceiver rd = null; 1056 if (resultReceiver != null) { 1057 if (mPackageInfo != null) { 1058 if (scheduler == null) { 1059 scheduler = mMainThread.getHandler(); 1060 } 1061 rd = mPackageInfo.getReceiverDispatcher( 1062 resultReceiver, getOuterContext(), scheduler, 1063 mMainThread.getInstrumentation(), false); 1064 } else { 1065 if (scheduler == null) { 1066 scheduler = mMainThread.getHandler(); 1067 } 1068 rd = new LoadedApk.ReceiverDispatcher( 1069 resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver(); 1070 } 1071 } 1072 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1073 try { 1074 intent.setAllowFds(false); 1075 ActivityManagerNative.getDefault().broadcastIntent( 1076 mMainThread.getApplicationThread(), intent, resolvedType, rd, 1077 initialCode, initialData, initialExtras, receiverPermission, 1078 true, false, UserHandle.myUserId()); 1079 } catch (RemoteException e) { 1080 } 1081 } 1082 1083 @Override 1084 public void sendBroadcastAsUser(Intent intent, UserHandle user) { 1085 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1086 try { 1087 intent.setAllowFds(false); 1088 ActivityManagerNative.getDefault().broadcastIntent(mMainThread.getApplicationThread(), 1089 intent, resolvedType, null, Activity.RESULT_OK, null, null, null, false, false, 1090 user.getIdentifier()); 1091 } catch (RemoteException e) { 1092 } 1093 } 1094 1095 @Override 1096 public void sendBroadcastAsUser(Intent intent, UserHandle user, 1097 String receiverPermission) { 1098 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1099 try { 1100 intent.setAllowFds(false); 1101 ActivityManagerNative.getDefault().broadcastIntent( 1102 mMainThread.getApplicationThread(), intent, resolvedType, null, 1103 Activity.RESULT_OK, null, null, receiverPermission, false, false, 1104 user.getIdentifier()); 1105 } catch (RemoteException e) { 1106 } 1107 } 1108 1109 @Override 1110 public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user, 1111 String receiverPermission, BroadcastReceiver resultReceiver, Handler scheduler, 1112 int initialCode, String initialData, Bundle initialExtras) { 1113 IIntentReceiver rd = null; 1114 if (resultReceiver != null) { 1115 if (mPackageInfo != null) { 1116 if (scheduler == null) { 1117 scheduler = mMainThread.getHandler(); 1118 } 1119 rd = mPackageInfo.getReceiverDispatcher( 1120 resultReceiver, getOuterContext(), scheduler, 1121 mMainThread.getInstrumentation(), false); 1122 } else { 1123 if (scheduler == null) { 1124 scheduler = mMainThread.getHandler(); 1125 } 1126 rd = new LoadedApk.ReceiverDispatcher( 1127 resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver(); 1128 } 1129 } 1130 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1131 try { 1132 intent.setAllowFds(false); 1133 ActivityManagerNative.getDefault().broadcastIntent( 1134 mMainThread.getApplicationThread(), intent, resolvedType, rd, 1135 initialCode, initialData, initialExtras, receiverPermission, 1136 true, false, user.getIdentifier()); 1137 } catch (RemoteException e) { 1138 } 1139 } 1140 1141 @Override 1142 public void sendStickyBroadcast(Intent intent) { 1143 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1144 try { 1145 intent.setAllowFds(false); 1146 ActivityManagerNative.getDefault().broadcastIntent( 1147 mMainThread.getApplicationThread(), intent, resolvedType, null, 1148 Activity.RESULT_OK, null, null, null, false, true, 1149 UserHandle.myUserId()); 1150 } catch (RemoteException e) { 1151 } 1152 } 1153 1154 @Override 1155 public void sendStickyOrderedBroadcast(Intent intent, 1156 BroadcastReceiver resultReceiver, 1157 Handler scheduler, int initialCode, String initialData, 1158 Bundle initialExtras) { 1159 IIntentReceiver rd = null; 1160 if (resultReceiver != null) { 1161 if (mPackageInfo != null) { 1162 if (scheduler == null) { 1163 scheduler = mMainThread.getHandler(); 1164 } 1165 rd = mPackageInfo.getReceiverDispatcher( 1166 resultReceiver, getOuterContext(), scheduler, 1167 mMainThread.getInstrumentation(), false); 1168 } else { 1169 if (scheduler == null) { 1170 scheduler = mMainThread.getHandler(); 1171 } 1172 rd = new LoadedApk.ReceiverDispatcher( 1173 resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver(); 1174 } 1175 } 1176 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1177 try { 1178 intent.setAllowFds(false); 1179 ActivityManagerNative.getDefault().broadcastIntent( 1180 mMainThread.getApplicationThread(), intent, resolvedType, rd, 1181 initialCode, initialData, initialExtras, null, 1182 true, true, UserHandle.myUserId()); 1183 } catch (RemoteException e) { 1184 } 1185 } 1186 1187 @Override 1188 public void removeStickyBroadcast(Intent intent) { 1189 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1190 if (resolvedType != null) { 1191 intent = new Intent(intent); 1192 intent.setDataAndType(intent.getData(), resolvedType); 1193 } 1194 try { 1195 intent.setAllowFds(false); 1196 ActivityManagerNative.getDefault().unbroadcastIntent( 1197 mMainThread.getApplicationThread(), intent, UserHandle.myUserId()); 1198 } catch (RemoteException e) { 1199 } 1200 } 1201 1202 @Override 1203 public void sendStickyBroadcastAsUser(Intent intent, UserHandle user) { 1204 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1205 try { 1206 intent.setAllowFds(false); 1207 ActivityManagerNative.getDefault().broadcastIntent( 1208 mMainThread.getApplicationThread(), intent, resolvedType, null, 1209 Activity.RESULT_OK, null, null, null, false, true, user.getIdentifier()); 1210 } catch (RemoteException e) { 1211 } 1212 } 1213 1214 @Override 1215 public void sendStickyOrderedBroadcastAsUser(Intent intent, 1216 UserHandle user, BroadcastReceiver resultReceiver, 1217 Handler scheduler, int initialCode, String initialData, 1218 Bundle initialExtras) { 1219 IIntentReceiver rd = null; 1220 if (resultReceiver != null) { 1221 if (mPackageInfo != null) { 1222 if (scheduler == null) { 1223 scheduler = mMainThread.getHandler(); 1224 } 1225 rd = mPackageInfo.getReceiverDispatcher( 1226 resultReceiver, getOuterContext(), scheduler, 1227 mMainThread.getInstrumentation(), false); 1228 } else { 1229 if (scheduler == null) { 1230 scheduler = mMainThread.getHandler(); 1231 } 1232 rd = new LoadedApk.ReceiverDispatcher( 1233 resultReceiver, getOuterContext(), scheduler, null, false).getIIntentReceiver(); 1234 } 1235 } 1236 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1237 try { 1238 intent.setAllowFds(false); 1239 ActivityManagerNative.getDefault().broadcastIntent( 1240 mMainThread.getApplicationThread(), intent, resolvedType, rd, 1241 initialCode, initialData, initialExtras, null, 1242 true, true, user.getIdentifier()); 1243 } catch (RemoteException e) { 1244 } 1245 } 1246 1247 @Override 1248 public void removeStickyBroadcastAsUser(Intent intent, UserHandle user) { 1249 String resolvedType = intent.resolveTypeIfNeeded(getContentResolver()); 1250 if (resolvedType != null) { 1251 intent = new Intent(intent); 1252 intent.setDataAndType(intent.getData(), resolvedType); 1253 } 1254 try { 1255 intent.setAllowFds(false); 1256 ActivityManagerNative.getDefault().unbroadcastIntent( 1257 mMainThread.getApplicationThread(), intent, user.getIdentifier()); 1258 } catch (RemoteException e) { 1259 } 1260 } 1261 1262 @Override 1263 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { 1264 return registerReceiver(receiver, filter, null, null); 1265 } 1266 1267 @Override 1268 public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, 1269 String broadcastPermission, Handler scheduler) { 1270 return registerReceiverInternal(receiver, UserHandle.myUserId(), 1271 filter, broadcastPermission, scheduler, getOuterContext()); 1272 } 1273 1274 @Override 1275 public Intent registerReceiverAsUser(BroadcastReceiver receiver, UserHandle user, 1276 IntentFilter filter, String broadcastPermission, Handler scheduler) { 1277 return registerReceiverInternal(receiver, user.getIdentifier(), 1278 filter, broadcastPermission, scheduler, getOuterContext()); 1279 } 1280 1281 private Intent registerReceiverInternal(BroadcastReceiver receiver, int userId, 1282 IntentFilter filter, String broadcastPermission, 1283 Handler scheduler, Context context) { 1284 IIntentReceiver rd = null; 1285 if (receiver != null) { 1286 if (mPackageInfo != null && context != null) { 1287 if (scheduler == null) { 1288 scheduler = mMainThread.getHandler(); 1289 } 1290 rd = mPackageInfo.getReceiverDispatcher( 1291 receiver, context, scheduler, 1292 mMainThread.getInstrumentation(), true); 1293 } else { 1294 if (scheduler == null) { 1295 scheduler = mMainThread.getHandler(); 1296 } 1297 rd = new LoadedApk.ReceiverDispatcher( 1298 receiver, context, scheduler, null, true).getIIntentReceiver(); 1299 } 1300 } 1301 try { 1302 return ActivityManagerNative.getDefault().registerReceiver( 1303 mMainThread.getApplicationThread(), mBasePackageName, 1304 rd, filter, broadcastPermission, userId); 1305 } catch (RemoteException e) { 1306 return null; 1307 } 1308 } 1309 1310 @Override 1311 public void unregisterReceiver(BroadcastReceiver receiver) { 1312 if (mPackageInfo != null) { 1313 IIntentReceiver rd = mPackageInfo.forgetReceiverDispatcher( 1314 getOuterContext(), receiver); 1315 try { 1316 ActivityManagerNative.getDefault().unregisterReceiver(rd); 1317 } catch (RemoteException e) { 1318 } 1319 } else { 1320 throw new RuntimeException("Not supported in system context"); 1321 } 1322 } 1323 1324 @Override 1325 public ComponentName startService(Intent service) { 1326 return startServiceAsUser(service, Process.myUserHandle()); 1327 } 1328 1329 @Override 1330 public boolean stopService(Intent service) { 1331 return stopServiceAsUser(service, Process.myUserHandle()); 1332 } 1333 1334 @Override 1335 public ComponentName startServiceAsUser(Intent service, UserHandle user) { 1336 try { 1337 service.setAllowFds(false); 1338 ComponentName cn = ActivityManagerNative.getDefault().startService( 1339 mMainThread.getApplicationThread(), service, 1340 service.resolveTypeIfNeeded(getContentResolver()), user.getIdentifier()); 1341 if (cn != null && cn.getPackageName().equals("!")) { 1342 throw new SecurityException( 1343 "Not allowed to start service " + service 1344 + " without permission " + cn.getClassName()); 1345 } 1346 return cn; 1347 } catch (RemoteException e) { 1348 return null; 1349 } 1350 } 1351 1352 @Override 1353 public boolean stopServiceAsUser(Intent service, UserHandle user) { 1354 try { 1355 service.setAllowFds(false); 1356 int res = ActivityManagerNative.getDefault().stopService( 1357 mMainThread.getApplicationThread(), service, 1358 service.resolveTypeIfNeeded(getContentResolver()), user.getIdentifier()); 1359 if (res < 0) { 1360 throw new SecurityException( 1361 "Not allowed to stop service " + service); 1362 } 1363 return res != 0; 1364 } catch (RemoteException e) { 1365 return false; 1366 } 1367 } 1368 1369 @Override 1370 public boolean bindService(Intent service, ServiceConnection conn, 1371 int flags) { 1372 return bindService(service, conn, flags, UserHandle.getUserId(Process.myUid())); 1373 } 1374 1375 /** @hide */ 1376 @Override 1377 public boolean bindService(Intent service, ServiceConnection conn, int flags, int userHandle) { 1378 IServiceConnection sd; 1379 if (conn == null) { 1380 throw new IllegalArgumentException("connection is null"); 1381 } 1382 if (mPackageInfo != null) { 1383 sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), 1384 mMainThread.getHandler(), flags); 1385 } else { 1386 throw new RuntimeException("Not supported in system context"); 1387 } 1388 try { 1389 IBinder token = getActivityToken(); 1390 if (token == null && (flags&BIND_AUTO_CREATE) == 0 && mPackageInfo != null 1391 && mPackageInfo.getApplicationInfo().targetSdkVersion 1392 < android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH) { 1393 flags |= BIND_WAIVE_PRIORITY; 1394 } 1395 service.setAllowFds(false); 1396 int res = ActivityManagerNative.getDefault().bindService( 1397 mMainThread.getApplicationThread(), getActivityToken(), 1398 service, service.resolveTypeIfNeeded(getContentResolver()), 1399 sd, flags, userHandle); 1400 if (res < 0) { 1401 throw new SecurityException( 1402 "Not allowed to bind to service " + service); 1403 } 1404 return res != 0; 1405 } catch (RemoteException e) { 1406 return false; 1407 } 1408 } 1409 1410 @Override 1411 public void unbindService(ServiceConnection conn) { 1412 if (conn == null) { 1413 throw new IllegalArgumentException("connection is null"); 1414 } 1415 if (mPackageInfo != null) { 1416 IServiceConnection sd = mPackageInfo.forgetServiceDispatcher( 1417 getOuterContext(), conn); 1418 try { 1419 ActivityManagerNative.getDefault().unbindService(sd); 1420 } catch (RemoteException e) { 1421 } 1422 } else { 1423 throw new RuntimeException("Not supported in system context"); 1424 } 1425 } 1426 1427 @Override 1428 public boolean startInstrumentation(ComponentName className, 1429 String profileFile, Bundle arguments) { 1430 try { 1431 if (arguments != null) { 1432 arguments.setAllowFds(false); 1433 } 1434 return ActivityManagerNative.getDefault().startInstrumentation( 1435 className, profileFile, 0, arguments, null, UserHandle.myUserId()); 1436 } catch (RemoteException e) { 1437 // System has crashed, nothing we can do. 1438 } 1439 return false; 1440 } 1441 1442 @Override 1443 public Object getSystemService(String name) { 1444 ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name); 1445 return fetcher == null ? null : fetcher.getService(this); 1446 } 1447 1448 private WallpaperManager getWallpaperManager() { 1449 return (WallpaperManager) WALLPAPER_FETCHER.getService(this); 1450 } 1451 1452 /* package */ static DropBoxManager createDropBoxManager() { 1453 IBinder b = ServiceManager.getService(DROPBOX_SERVICE); 1454 IDropBoxManagerService service = IDropBoxManagerService.Stub.asInterface(b); 1455 if (service == null) { 1456 // Don't return a DropBoxManager that will NPE upon use. 1457 // This also avoids caching a broken DropBoxManager in 1458 // getDropBoxManager during early boot, before the 1459 // DROPBOX_SERVICE is registered. 1460 return null; 1461 } 1462 return new DropBoxManager(service); 1463 } 1464 1465 @Override 1466 public int checkPermission(String permission, int pid, int uid) { 1467 if (permission == null) { 1468 throw new IllegalArgumentException("permission is null"); 1469 } 1470 1471 try { 1472 return ActivityManagerNative.getDefault().checkPermission( 1473 permission, pid, uid); 1474 } catch (RemoteException e) { 1475 return PackageManager.PERMISSION_DENIED; 1476 } 1477 } 1478 1479 @Override 1480 public int checkCallingPermission(String permission) { 1481 if (permission == null) { 1482 throw new IllegalArgumentException("permission is null"); 1483 } 1484 1485 int pid = Binder.getCallingPid(); 1486 if (pid != Process.myPid()) { 1487 return checkPermission(permission, pid, Binder.getCallingUid()); 1488 } 1489 return PackageManager.PERMISSION_DENIED; 1490 } 1491 1492 @Override 1493 public int checkCallingOrSelfPermission(String permission) { 1494 if (permission == null) { 1495 throw new IllegalArgumentException("permission is null"); 1496 } 1497 1498 return checkPermission(permission, Binder.getCallingPid(), 1499 Binder.getCallingUid()); 1500 } 1501 1502 private void enforce( 1503 String permission, int resultOfCheck, 1504 boolean selfToo, int uid, String message) { 1505 if (resultOfCheck != PackageManager.PERMISSION_GRANTED) { 1506 throw new SecurityException( 1507 (message != null ? (message + ": ") : "") + 1508 (selfToo 1509 ? "Neither user " + uid + " nor current process has " 1510 : "uid " + uid + " does not have ") + 1511 permission + 1512 "."); 1513 } 1514 } 1515 1516 public void enforcePermission( 1517 String permission, int pid, int uid, String message) { 1518 enforce(permission, 1519 checkPermission(permission, pid, uid), 1520 false, 1521 uid, 1522 message); 1523 } 1524 1525 public void enforceCallingPermission(String permission, String message) { 1526 enforce(permission, 1527 checkCallingPermission(permission), 1528 false, 1529 Binder.getCallingUid(), 1530 message); 1531 } 1532 1533 public void enforceCallingOrSelfPermission( 1534 String permission, String message) { 1535 enforce(permission, 1536 checkCallingOrSelfPermission(permission), 1537 true, 1538 Binder.getCallingUid(), 1539 message); 1540 } 1541 1542 @Override 1543 public void grantUriPermission(String toPackage, Uri uri, int modeFlags) { 1544 try { 1545 ActivityManagerNative.getDefault().grantUriPermission( 1546 mMainThread.getApplicationThread(), toPackage, uri, 1547 modeFlags); 1548 } catch (RemoteException e) { 1549 } 1550 } 1551 1552 @Override 1553 public void revokeUriPermission(Uri uri, int modeFlags) { 1554 try { 1555 ActivityManagerNative.getDefault().revokeUriPermission( 1556 mMainThread.getApplicationThread(), uri, 1557 modeFlags); 1558 } catch (RemoteException e) { 1559 } 1560 } 1561 1562 @Override 1563 public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { 1564 try { 1565 return ActivityManagerNative.getDefault().checkUriPermission( 1566 uri, pid, uid, modeFlags); 1567 } catch (RemoteException e) { 1568 return PackageManager.PERMISSION_DENIED; 1569 } 1570 } 1571 1572 @Override 1573 public int checkCallingUriPermission(Uri uri, int modeFlags) { 1574 int pid = Binder.getCallingPid(); 1575 if (pid != Process.myPid()) { 1576 return checkUriPermission(uri, pid, 1577 Binder.getCallingUid(), modeFlags); 1578 } 1579 return PackageManager.PERMISSION_DENIED; 1580 } 1581 1582 @Override 1583 public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) { 1584 return checkUriPermission(uri, Binder.getCallingPid(), 1585 Binder.getCallingUid(), modeFlags); 1586 } 1587 1588 @Override 1589 public int checkUriPermission(Uri uri, String readPermission, 1590 String writePermission, int pid, int uid, int modeFlags) { 1591 if (DEBUG) { 1592 Log.i("foo", "checkUriPermission: uri=" + uri + "readPermission=" 1593 + readPermission + " writePermission=" + writePermission 1594 + " pid=" + pid + " uid=" + uid + " mode" + modeFlags); 1595 } 1596 if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { 1597 if (readPermission == null 1598 || checkPermission(readPermission, pid, uid) 1599 == PackageManager.PERMISSION_GRANTED) { 1600 return PackageManager.PERMISSION_GRANTED; 1601 } 1602 } 1603 if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { 1604 if (writePermission == null 1605 || checkPermission(writePermission, pid, uid) 1606 == PackageManager.PERMISSION_GRANTED) { 1607 return PackageManager.PERMISSION_GRANTED; 1608 } 1609 } 1610 return uri != null ? checkUriPermission(uri, pid, uid, modeFlags) 1611 : PackageManager.PERMISSION_DENIED; 1612 } 1613 1614 private String uriModeFlagToString(int uriModeFlags) { 1615 switch (uriModeFlags) { 1616 case Intent.FLAG_GRANT_READ_URI_PERMISSION | 1617 Intent.FLAG_GRANT_WRITE_URI_PERMISSION: 1618 return "read and write"; 1619 case Intent.FLAG_GRANT_READ_URI_PERMISSION: 1620 return "read"; 1621 case Intent.FLAG_GRANT_WRITE_URI_PERMISSION: 1622 return "write"; 1623 } 1624 throw new IllegalArgumentException( 1625 "Unknown permission mode flags: " + uriModeFlags); 1626 } 1627 1628 private void enforceForUri( 1629 int modeFlags, int resultOfCheck, boolean selfToo, 1630 int uid, Uri uri, String message) { 1631 if (resultOfCheck != PackageManager.PERMISSION_GRANTED) { 1632 throw new SecurityException( 1633 (message != null ? (message + ": ") : "") + 1634 (selfToo 1635 ? "Neither user " + uid + " nor current process has " 1636 : "User " + uid + " does not have ") + 1637 uriModeFlagToString(modeFlags) + 1638 " permission on " + 1639 uri + 1640 "."); 1641 } 1642 } 1643 1644 public void enforceUriPermission( 1645 Uri uri, int pid, int uid, int modeFlags, String message) { 1646 enforceForUri( 1647 modeFlags, checkUriPermission(uri, pid, uid, modeFlags), 1648 false, uid, uri, message); 1649 } 1650 1651 public void enforceCallingUriPermission( 1652 Uri uri, int modeFlags, String message) { 1653 enforceForUri( 1654 modeFlags, checkCallingUriPermission(uri, modeFlags), 1655 false, 1656 Binder.getCallingUid(), uri, message); 1657 } 1658 1659 public void enforceCallingOrSelfUriPermission( 1660 Uri uri, int modeFlags, String message) { 1661 enforceForUri( 1662 modeFlags, 1663 checkCallingOrSelfUriPermission(uri, modeFlags), true, 1664 Binder.getCallingUid(), uri, message); 1665 } 1666 1667 public void enforceUriPermission( 1668 Uri uri, String readPermission, String writePermission, 1669 int pid, int uid, int modeFlags, String message) { 1670 enforceForUri(modeFlags, 1671 checkUriPermission( 1672 uri, readPermission, writePermission, pid, uid, 1673 modeFlags), 1674 false, 1675 uid, 1676 uri, 1677 message); 1678 } 1679 1680 @Override 1681 public Context createPackageContext(String packageName, int flags) 1682 throws NameNotFoundException { 1683 return createPackageContextAsUser(packageName, flags, Process.myUserHandle()); 1684 } 1685 1686 @Override 1687 public Context createPackageContextAsUser(String packageName, int flags, UserHandle user) 1688 throws NameNotFoundException { 1689 if (packageName.equals("system") || packageName.equals("android")) { 1690 final ContextImpl context = new ContextImpl(mMainThread.getSystemContext()); 1691 context.mBasePackageName = mBasePackageName; 1692 return context; 1693 } 1694 1695 LoadedApk pi = 1696 mMainThread.getPackageInfo(packageName, mResources.getCompatibilityInfo(), flags); 1697 if (pi != null) { 1698 ContextImpl c = new ContextImpl(); 1699 c.mRestricted = (flags & CONTEXT_RESTRICTED) == CONTEXT_RESTRICTED; 1700 c.init(pi, null, mMainThread, mResources, mBasePackageName, user); 1701 if (c.mResources != null) { 1702 return c; 1703 } 1704 } 1705 1706 // Should be a better exception. 1707 throw new PackageManager.NameNotFoundException( 1708 "Application package " + packageName + " not found"); 1709 } 1710 1711 @Override 1712 public Context createConfigurationContext(Configuration overrideConfiguration) { 1713 if (overrideConfiguration == null) { 1714 throw new IllegalArgumentException("overrideConfiguration must not be null"); 1715 } 1716 1717 ContextImpl c = new ContextImpl(); 1718 c.init(mPackageInfo, null, mMainThread); 1719 c.mResources = mMainThread.getTopLevelResources( 1720 mPackageInfo.getResDir(), 1721 getDisplayId(), overrideConfiguration, 1722 mResources.getCompatibilityInfo()); 1723 return c; 1724 } 1725 1726 @Override 1727 public Context createDisplayContext(Display display) { 1728 if (display == null) { 1729 throw new IllegalArgumentException("display must not be null"); 1730 } 1731 1732 int displayId = display.getDisplayId(); 1733 CompatibilityInfo ci = CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO; 1734 CompatibilityInfoHolder cih = getCompatibilityInfo(displayId); 1735 if (cih != null) { 1736 ci = cih.get(); 1737 } 1738 1739 ContextImpl context = new ContextImpl(); 1740 context.init(mPackageInfo, null, mMainThread); 1741 context.mDisplay = display; 1742 context.mResources = mMainThread.getTopLevelResources( 1743 mPackageInfo.getResDir(), displayId, null, ci); 1744 return context; 1745 } 1746 1747 private int getDisplayId() { 1748 return mDisplay != null ? mDisplay.getDisplayId() : Display.DEFAULT_DISPLAY; 1749 } 1750 1751 @Override 1752 public boolean isRestricted() { 1753 return mRestricted; 1754 } 1755 1756 @Override 1757 public CompatibilityInfoHolder getCompatibilityInfo(int displayId) { 1758 return displayId == Display.DEFAULT_DISPLAY ? mPackageInfo.mCompatibilityInfo : null; 1759 } 1760 1761 private File getDataDirFile() { 1762 if (mPackageInfo != null) { 1763 return mPackageInfo.getDataDirFile(); 1764 } 1765 throw new RuntimeException("Not supported in system context"); 1766 } 1767 1768 @Override 1769 public File getDir(String name, int mode) { 1770 name = "app_" + name; 1771 File file = makeFilename(getDataDirFile(), name); 1772 if (!file.exists()) { 1773 file.mkdir(); 1774 setFilePermissionsFromMode(file.getPath(), mode, 1775 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH); 1776 } 1777 return file; 1778 } 1779 1780 static ContextImpl createSystemContext(ActivityThread mainThread) { 1781 final ContextImpl context = new ContextImpl(); 1782 context.init(Resources.getSystem(), mainThread, Process.myUserHandle()); 1783 return context; 1784 } 1785 1786 ContextImpl() { 1787 mOuterContext = this; 1788 } 1789 1790 /** 1791 * Create a new ApplicationContext from an existing one. The new one 1792 * works and operates the same as the one it is copying. 1793 * 1794 * @param context Existing application context. 1795 */ 1796 public ContextImpl(ContextImpl context) { 1797 mPackageInfo = context.mPackageInfo; 1798 mBasePackageName = context.mBasePackageName; 1799 mResources = context.mResources; 1800 mMainThread = context.mMainThread; 1801 mContentResolver = context.mContentResolver; 1802 mUser = context.mUser; 1803 mDisplay = context.mDisplay; 1804 mOuterContext = this; 1805 } 1806 1807 final void init(LoadedApk packageInfo, IBinder activityToken, ActivityThread mainThread) { 1808 init(packageInfo, activityToken, mainThread, null, null, Process.myUserHandle()); 1809 } 1810 1811 final void init(LoadedApk packageInfo, IBinder activityToken, ActivityThread mainThread, 1812 Resources container, String basePackageName, UserHandle user) { 1813 mPackageInfo = packageInfo; 1814 mBasePackageName = basePackageName != null ? basePackageName : packageInfo.mPackageName; 1815 mResources = mPackageInfo.getResources(mainThread); 1816 1817 if (mResources != null && container != null 1818 && container.getCompatibilityInfo().applicationScale != 1819 mResources.getCompatibilityInfo().applicationScale) { 1820 if (DEBUG) { 1821 Log.d(TAG, "loaded context has different scaling. Using container's" + 1822 " compatiblity info:" + container.getDisplayMetrics()); 1823 } 1824 mResources = mainThread.getTopLevelResources( 1825 mPackageInfo.getResDir(), Display.DEFAULT_DISPLAY, 1826 null, container.getCompatibilityInfo()); 1827 } 1828 mMainThread = mainThread; 1829 mActivityToken = activityToken; 1830 mContentResolver = new ApplicationContentResolver(this, mainThread, user); 1831 mUser = user; 1832 } 1833 1834 final void init(Resources resources, ActivityThread mainThread, UserHandle user) { 1835 mPackageInfo = null; 1836 mBasePackageName = null; 1837 mResources = resources; 1838 mMainThread = mainThread; 1839 mContentResolver = new ApplicationContentResolver(this, mainThread, user); 1840 mUser = user; 1841 } 1842 1843 final void scheduleFinalCleanup(String who, String what) { 1844 mMainThread.scheduleContextCleanup(this, who, what); 1845 } 1846 1847 final void performFinalCleanup(String who, String what) { 1848 //Log.i(TAG, "Cleanup up context: " + this); 1849 mPackageInfo.removeContextRegistrations(getOuterContext(), who, what); 1850 } 1851 1852 final Context getReceiverRestrictedContext() { 1853 if (mReceiverRestrictedContext != null) { 1854 return mReceiverRestrictedContext; 1855 } 1856 return mReceiverRestrictedContext = new ReceiverRestrictedContext(getOuterContext()); 1857 } 1858 1859 final void setOuterContext(Context context) { 1860 mOuterContext = context; 1861 } 1862 1863 final Context getOuterContext() { 1864 return mOuterContext; 1865 } 1866 1867 final IBinder getActivityToken() { 1868 return mActivityToken; 1869 } 1870 1871 static void setFilePermissionsFromMode(String name, int mode, 1872 int extraPermissions) { 1873 int perms = FileUtils.S_IRUSR|FileUtils.S_IWUSR 1874 |FileUtils.S_IRGRP|FileUtils.S_IWGRP 1875 |extraPermissions; 1876 if ((mode&MODE_WORLD_READABLE) != 0) { 1877 perms |= FileUtils.S_IROTH; 1878 } 1879 if ((mode&MODE_WORLD_WRITEABLE) != 0) { 1880 perms |= FileUtils.S_IWOTH; 1881 } 1882 if (DEBUG) { 1883 Log.i(TAG, "File " + name + ": mode=0x" + Integer.toHexString(mode) 1884 + ", perms=0x" + Integer.toHexString(perms)); 1885 } 1886 FileUtils.setPermissions(name, perms, -1, -1); 1887 } 1888 1889 private File validateFilePath(String name, boolean createDirectory) { 1890 File dir; 1891 File f; 1892 1893 if (name.charAt(0) == File.separatorChar) { 1894 String dirPath = name.substring(0, name.lastIndexOf(File.separatorChar)); 1895 dir = new File(dirPath); 1896 name = name.substring(name.lastIndexOf(File.separatorChar)); 1897 f = new File(dir, name); 1898 } else { 1899 dir = getDatabasesDir(); 1900 f = makeFilename(dir, name); 1901 } 1902 1903 if (createDirectory && !dir.isDirectory() && dir.mkdir()) { 1904 FileUtils.setPermissions(dir.getPath(), 1905 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, 1906 -1, -1); 1907 } 1908 1909 return f; 1910 } 1911 1912 private File makeFilename(File base, String name) { 1913 if (name.indexOf(File.separatorChar) < 0) { 1914 return new File(base, name); 1915 } 1916 throw new IllegalArgumentException( 1917 "File " + name + " contains a path separator"); 1918 } 1919 1920 // ---------------------------------------------------------------------- 1921 // ---------------------------------------------------------------------- 1922 // ---------------------------------------------------------------------- 1923 1924 private static final class ApplicationContentResolver extends ContentResolver { 1925 private final ActivityThread mMainThread; 1926 private final UserHandle mUser; 1927 1928 public ApplicationContentResolver( 1929 Context context, ActivityThread mainThread, UserHandle user) { 1930 super(context); 1931 mMainThread = Preconditions.checkNotNull(mainThread); 1932 mUser = Preconditions.checkNotNull(user); 1933 } 1934 1935 @Override 1936 protected IContentProvider acquireProvider(Context context, String auth) { 1937 return mMainThread.acquireProvider(context, auth, mUser.getIdentifier(), true); 1938 } 1939 1940 @Override 1941 protected IContentProvider acquireExistingProvider(Context context, String auth) { 1942 return mMainThread.acquireExistingProvider(context, auth, mUser.getIdentifier(), true); 1943 } 1944 1945 @Override 1946 public boolean releaseProvider(IContentProvider provider) { 1947 return mMainThread.releaseProvider(provider, true); 1948 } 1949 1950 @Override 1951 protected IContentProvider acquireUnstableProvider(Context c, String auth) { 1952 return mMainThread.acquireProvider(c, auth, mUser.getIdentifier(), false); 1953 } 1954 1955 @Override 1956 public boolean releaseUnstableProvider(IContentProvider icp) { 1957 return mMainThread.releaseProvider(icp, false); 1958 } 1959 1960 @Override 1961 public void unstableProviderDied(IContentProvider icp) { 1962 mMainThread.handleUnstableProviderDied(icp.asBinder(), true); 1963 } 1964 } 1965} 1966