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