ContextWrapper.java revision efa199f016985b0a9d0471e42c803ee9f7941f0e 
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.content;
18
19import android.content.pm.ApplicationInfo;
20import android.content.pm.PackageManager;
21import android.content.res.AssetManager;
22import android.content.res.Resources;
23import android.database.sqlite.SQLiteDatabase;
24import android.database.sqlite.SQLiteDatabase.CursorFactory;
25import android.graphics.Bitmap;
26import android.graphics.drawable.Drawable;
27import android.net.Uri;
28import android.os.Bundle;
29import android.os.Handler;
30import android.os.Looper;
31
32import java.io.File;
33import java.io.FileInputStream;
34import java.io.FileNotFoundException;
35import java.io.FileOutputStream;
36import java.io.IOException;
37import java.io.InputStream;
38
39/**
40 * Proxying implementation of Context that simply delegates all of its calls to
41 * another Context.  Can be subclassed to modify behavior without changing
42 * the original Context.
43 */
44public class ContextWrapper extends Context {
45    Context mBase;
46
47    public ContextWrapper(Context base) {
48        mBase = base;
49    }
50
51    /**
52     * Set the base context for this ContextWrapper.  All calls will then be
53     * delegated to the base context.  Throws
54     * IllegalStateException if a base context has already been set.
55     *
56     * @param base The new base context for this wrapper.
57     */
58    protected void attachBaseContext(Context base) {
59        if (mBase != null) {
60            throw new IllegalStateException("Base context already set");
61        }
62        mBase = base;
63    }
64
65    /**
66     * @return the base context as set by the constructor or setBaseContext
67     */
68    public Context getBaseContext() {
69        return mBase;
70    }
71
72    @Override
73    public AssetManager getAssets() {
74        return mBase.getAssets();
75    }
76
77    @Override
78    public Resources getResources()
79    {
80        return mBase.getResources();
81    }
82
83    @Override
84    public PackageManager getPackageManager() {
85        return mBase.getPackageManager();
86    }
87
88    @Override
89    public ContentResolver getContentResolver() {
90        return mBase.getContentResolver();
91    }
92
93    @Override
94    public Looper getMainLooper() {
95        return mBase.getMainLooper();
96    }
97
98    @Override
99    public Context getApplicationContext() {
100        return mBase.getApplicationContext();
101    }
102
103    @Override
104    public void setTheme(int resid) {
105        mBase.setTheme(resid);
106    }
107
108    @Override
109    public Resources.Theme getTheme() {
110        return mBase.getTheme();
111    }
112
113    @Override
114    public ClassLoader getClassLoader() {
115        return mBase.getClassLoader();
116    }
117
118    @Override
119    public String getPackageName() {
120        return mBase.getPackageName();
121    }
122
123    @Override
124    public ApplicationInfo getApplicationInfo() {
125        return mBase.getApplicationInfo();
126    }
127
128    @Override
129    public String getPackageResourcePath() {
130        return mBase.getPackageResourcePath();
131    }
132
133    @Override
134    public String getPackageCodePath() {
135        return mBase.getPackageCodePath();
136    }
137
138    /** @hide */
139    @Override
140    public File getSharedPrefsFile(String name) {
141        return mBase.getSharedPrefsFile(name);
142    }
143
144    @Override
145    public SharedPreferences getSharedPreferences(String name, int mode) {
146        return mBase.getSharedPreferences(name, mode);
147    }
148
149    @Override
150    public FileInputStream openFileInput(String name)
151        throws FileNotFoundException {
152        return mBase.openFileInput(name);
153    }
154
155    @Override
156    public FileOutputStream openFileOutput(String name, int mode)
157        throws FileNotFoundException {
158        return mBase.openFileOutput(name, mode);
159    }
160
161    @Override
162    public boolean deleteFile(String name) {
163        return mBase.deleteFile(name);
164    }
165
166    @Override
167    public File getFileStreamPath(String name) {
168        return mBase.getFileStreamPath(name);
169    }
170
171    @Override
172    public String[] fileList() {
173        return mBase.fileList();
174    }
175
176    @Override
177    public File getFilesDir() {
178        return mBase.getFilesDir();
179    }
180
181    @Override
182    public File getCacheDir() {
183        return mBase.getCacheDir();
184    }
185
186    @Override
187    public File getDir(String name, int mode) {
188        return mBase.getDir(name, mode);
189    }
190
191    @Override
192    public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory) {
193        return mBase.openOrCreateDatabase(name, mode, factory);
194    }
195
196    @Override
197    public boolean deleteDatabase(String name) {
198        return mBase.deleteDatabase(name);
199    }
200
201    @Override
202    public File getDatabasePath(String name) {
203        return mBase.getDatabasePath(name);
204    }
205
206    @Override
207    public String[] databaseList() {
208        return mBase.databaseList();
209    }
210
211    @Override
212    public Drawable getWallpaper() {
213        return mBase.getWallpaper();
214    }
215
216    @Override
217    public Drawable peekWallpaper() {
218        return mBase.peekWallpaper();
219    }
220
221    @Override
222    public int getWallpaperDesiredMinimumWidth() {
223        return mBase.getWallpaperDesiredMinimumWidth();
224    }
225
226    @Override
227    public int getWallpaperDesiredMinimumHeight() {
228        return mBase.getWallpaperDesiredMinimumHeight();
229    }
230
231    @Override
232    public void setWallpaper(Bitmap bitmap) throws IOException {
233        mBase.setWallpaper(bitmap);
234    }
235
236    @Override
237    public void setWallpaper(InputStream data) throws IOException {
238        mBase.setWallpaper(data);
239    }
240
241    @Override
242    public void clearWallpaper() throws IOException {
243        mBase.clearWallpaper();
244    }
245
246    @Override
247    public void startActivity(Intent intent) {
248        mBase.startActivity(intent);
249    }
250
251    @Override
252    public void startIntentSender(IntentSender intent,
253            Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags)
254            throws IntentSender.SendIntentException {
255        mBase.startIntentSender(intent, fillInIntent, flagsMask,
256                flagsValues, extraFlags);
257    }
258
259    @Override
260    public void sendBroadcast(Intent intent) {
261        mBase.sendBroadcast(intent);
262    }
263
264    @Override
265    public void sendBroadcast(Intent intent, String receiverPermission) {
266        mBase.sendBroadcast(intent, receiverPermission);
267    }
268
269    @Override
270    public void sendOrderedBroadcast(Intent intent,
271            String receiverPermission) {
272        mBase.sendOrderedBroadcast(intent, receiverPermission);
273    }
274
275    @Override
276    public void sendOrderedBroadcast(
277        Intent intent, String receiverPermission, BroadcastReceiver resultReceiver,
278        Handler scheduler, int initialCode, String initialData,
279        Bundle initialExtras) {
280        mBase.sendOrderedBroadcast(intent, receiverPermission,
281                resultReceiver, scheduler, initialCode,
282                initialData, initialExtras);
283    }
284
285    @Override
286    public void sendStickyBroadcast(Intent intent) {
287        mBase.sendStickyBroadcast(intent);
288    }
289
290    @Override
291    public void sendStickyOrderedBroadcast(
292        Intent intent, BroadcastReceiver resultReceiver,
293        Handler scheduler, int initialCode, String initialData,
294        Bundle initialExtras) {
295        mBase.sendStickyOrderedBroadcast(intent,
296                resultReceiver, scheduler, initialCode,
297                initialData, initialExtras);
298    }
299
300    @Override
301    public void removeStickyBroadcast(Intent intent) {
302        mBase.removeStickyBroadcast(intent);
303    }
304
305    @Override
306    public Intent registerReceiver(
307        BroadcastReceiver receiver, IntentFilter filter) {
308        return mBase.registerReceiver(receiver, filter);
309    }
310
311    @Override
312    public Intent registerReceiver(
313        BroadcastReceiver receiver, IntentFilter filter,
314        String broadcastPermission, Handler scheduler) {
315        return mBase.registerReceiver(receiver, filter, broadcastPermission,
316                scheduler);
317    }
318
319    @Override
320    public void unregisterReceiver(BroadcastReceiver receiver) {
321        mBase.unregisterReceiver(receiver);
322    }
323
324    @Override
325    public ComponentName startService(Intent service) {
326        return mBase.startService(service);
327    }
328
329    @Override
330    public boolean stopService(Intent name) {
331        return mBase.stopService(name);
332    }
333
334    @Override
335    public boolean bindService(Intent service, ServiceConnection conn,
336            int flags) {
337        return mBase.bindService(service, conn, flags);
338    }
339
340    @Override
341    public void unbindService(ServiceConnection conn) {
342        mBase.unbindService(conn);
343    }
344
345    @Override
346    public boolean startInstrumentation(ComponentName className,
347            String profileFile, Bundle arguments) {
348        return mBase.startInstrumentation(className, profileFile, arguments);
349    }
350
351    @Override
352    public Object getSystemService(String name) {
353        return mBase.getSystemService(name);
354    }
355
356    @Override
357    public int checkPermission(String permission, int pid, int uid) {
358        return mBase.checkPermission(permission, pid, uid);
359    }
360
361    @Override
362    public int checkCallingPermission(String permission) {
363        return mBase.checkCallingPermission(permission);
364    }
365
366    @Override
367    public int checkCallingOrSelfPermission(String permission) {
368        return mBase.checkCallingOrSelfPermission(permission);
369    }
370
371    @Override
372    public void enforcePermission(
373            String permission, int pid, int uid, String message) {
374        mBase.enforcePermission(permission, pid, uid, message);
375    }
376
377    @Override
378    public void enforceCallingPermission(String permission, String message) {
379        mBase.enforceCallingPermission(permission, message);
380    }
381
382    @Override
383    public void enforceCallingOrSelfPermission(
384            String permission, String message) {
385        mBase.enforceCallingOrSelfPermission(permission, message);
386    }
387
388    @Override
389    public void grantUriPermission(String toPackage, Uri uri, int modeFlags) {
390        mBase.grantUriPermission(toPackage, uri, modeFlags);
391    }
392
393    @Override
394    public void revokeUriPermission(Uri uri, int modeFlags) {
395        mBase.revokeUriPermission(uri, modeFlags);
396    }
397
398    @Override
399    public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) {
400        return mBase.checkUriPermission(uri, pid, uid, modeFlags);
401    }
402
403    @Override
404    public int checkCallingUriPermission(Uri uri, int modeFlags) {
405        return mBase.checkCallingUriPermission(uri, modeFlags);
406    }
407
408    @Override
409    public int checkCallingOrSelfUriPermission(Uri uri, int modeFlags) {
410        return mBase.checkCallingOrSelfUriPermission(uri, modeFlags);
411    }
412
413    @Override
414    public int checkUriPermission(Uri uri, String readPermission,
415            String writePermission, int pid, int uid, int modeFlags) {
416        return mBase.checkUriPermission(uri, readPermission, writePermission,
417                pid, uid, modeFlags);
418    }
419
420    @Override
421    public void enforceUriPermission(
422            Uri uri, int pid, int uid, int modeFlags, String message) {
423        mBase.enforceUriPermission(uri, pid, uid, modeFlags, message);
424    }
425
426    @Override
427    public void enforceCallingUriPermission(
428            Uri uri, int modeFlags, String message) {
429        mBase.enforceCallingUriPermission(uri, modeFlags, message);
430    }
431
432    @Override
433    public void enforceCallingOrSelfUriPermission(
434            Uri uri, int modeFlags, String message) {
435        mBase.enforceCallingOrSelfUriPermission(uri, modeFlags, message);
436    }
437
438    @Override
439    public void enforceUriPermission(
440            Uri uri, String readPermission, String writePermission,
441            int pid, int uid, int modeFlags, String message) {
442        mBase.enforceUriPermission(
443                uri, readPermission, writePermission, pid, uid, modeFlags,
444                message);
445    }
446
447    @Override
448    public Context createPackageContext(String packageName, int flags)
449        throws PackageManager.NameNotFoundException {
450        return mBase.createPackageContext(packageName, flags);
451    }
452
453    @Override
454    public boolean isRestricted() {
455        return mBase.isRestricted();
456    }
457}
458