core/java/android/app/ContextImpl.java

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