• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2010 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.internal.content;
18 
19 import android.app.Activity;
20 import android.content.Context;
21 import android.content.Intent;
22 import android.content.IntentFilter;
23 import android.net.Uri;
24 import android.os.Handler;
25 import android.os.HandlerThread;
26 import android.os.Looper;
27 import android.os.UserHandle;
28 
29 import java.util.HashSet;
30 
31 /**
32  * Helper class for monitoring the state of packages: adding, removing,
33  * updating, and disappearing and reappearing on the SD card.
34  */
35 public abstract class PackageMonitor extends android.content.BroadcastReceiver {
36     static final IntentFilter sPackageFilt = new IntentFilter();
37     static final IntentFilter sNonDataFilt = new IntentFilter();
38     static final IntentFilter sExternalFilt = new IntentFilter();
39 
40     static final Object sLock = new Object();
41     static HandlerThread sBackgroundThread;
42     static Handler sBackgroundHandler;
43 
44     static {
45         sPackageFilt.addAction(Intent.ACTION_PACKAGE_ADDED);
46         sPackageFilt.addAction(Intent.ACTION_PACKAGE_REMOVED);
47         sPackageFilt.addAction(Intent.ACTION_PACKAGE_CHANGED);
48         sPackageFilt.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART);
49         sPackageFilt.addAction(Intent.ACTION_PACKAGE_RESTARTED);
50         sPackageFilt.addAction(Intent.ACTION_UID_REMOVED);
51         sPackageFilt.addDataScheme("package");
52         sNonDataFilt.addAction(Intent.ACTION_UID_REMOVED);
53         sNonDataFilt.addAction(Intent.ACTION_USER_STOPPED);
54         sExternalFilt.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);
55         sExternalFilt.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
56     }
57 
58     final HashSet<String> mUpdatingPackages = new HashSet<String>();
59 
60     Context mRegisteredContext;
61     Handler mRegisteredHandler;
62     String[] mDisappearingPackages;
63     String[] mAppearingPackages;
64     String[] mModifiedPackages;
65     int mChangeType;
66     int mChangeUserId = UserHandle.USER_NULL;
67     boolean mSomePackagesChanged;
68 
69     String[] mTempArray = new String[1];
70 
register(Context context, Looper thread, boolean externalStorage)71     public void register(Context context, Looper thread, boolean externalStorage) {
72         register(context, thread, null, externalStorage);
73     }
74 
register(Context context, Looper thread, UserHandle user, boolean externalStorage)75     public void register(Context context, Looper thread, UserHandle user,
76             boolean externalStorage) {
77         if (mRegisteredContext != null) {
78             throw new IllegalStateException("Already registered");
79         }
80         mRegisteredContext = context;
81         if (thread == null) {
82             synchronized (sLock) {
83                 if (sBackgroundThread == null) {
84                     sBackgroundThread = new HandlerThread("PackageMonitor",
85                             android.os.Process.THREAD_PRIORITY_BACKGROUND);
86                     sBackgroundThread.start();
87                     sBackgroundHandler = new Handler(sBackgroundThread.getLooper());
88                 }
89                 mRegisteredHandler = sBackgroundHandler;
90             }
91         } else {
92             mRegisteredHandler = new Handler(thread);
93         }
94         if (user != null) {
95             context.registerReceiverAsUser(this, user, sPackageFilt, null, mRegisteredHandler);
96             context.registerReceiverAsUser(this, user, sNonDataFilt, null, mRegisteredHandler);
97             if (externalStorage) {
98                 context.registerReceiverAsUser(this, user, sExternalFilt, null,
99                         mRegisteredHandler);
100             }
101         } else {
102             context.registerReceiver(this, sPackageFilt, null, mRegisteredHandler);
103             context.registerReceiver(this, sNonDataFilt, null, mRegisteredHandler);
104             if (externalStorage) {
105                 context.registerReceiver(this, sExternalFilt, null, mRegisteredHandler);
106             }
107         }
108     }
109 
getRegisteredHandler()110     public Handler getRegisteredHandler() {
111         return mRegisteredHandler;
112     }
113 
unregister()114     public void unregister() {
115         if (mRegisteredContext == null) {
116             throw new IllegalStateException("Not registered");
117         }
118         mRegisteredContext.unregisterReceiver(this);
119         mRegisteredContext = null;
120     }
121 
122     //not yet implemented
isPackageUpdating(String packageName)123     boolean isPackageUpdating(String packageName) {
124         synchronized (mUpdatingPackages) {
125             return mUpdatingPackages.contains(packageName);
126         }
127     }
128 
onBeginPackageChanges()129     public void onBeginPackageChanges() {
130     }
131 
132     /**
133      * Called when a package is really added (and not replaced).
134      */
onPackageAdded(String packageName, int uid)135     public void onPackageAdded(String packageName, int uid) {
136     }
137 
138     /**
139      * Called when a package is really removed (and not replaced).
140      */
onPackageRemoved(String packageName, int uid)141     public void onPackageRemoved(String packageName, int uid) {
142     }
143 
144     /**
145      * Called when a package is really removed (and not replaced) for
146      * all users on the device.
147      */
onPackageRemovedAllUsers(String packageName, int uid)148     public void onPackageRemovedAllUsers(String packageName, int uid) {
149     }
150 
onPackageUpdateStarted(String packageName, int uid)151     public void onPackageUpdateStarted(String packageName, int uid) {
152     }
153 
onPackageUpdateFinished(String packageName, int uid)154     public void onPackageUpdateFinished(String packageName, int uid) {
155     }
156 
157     /**
158      * Direct reflection of {@link Intent#ACTION_PACKAGE_CHANGED
159      * Intent.ACTION_PACKAGE_CHANGED} being received, informing you of
160      * changes to the enabled/disabled state of components in a package
161      * and/or of the overall package.
162      *
163      * @param packageName The name of the package that is changing.
164      * @param uid The user ID the package runs under.
165      * @param components Any components in the package that are changing.  If
166      * the overall package is changing, this will contain an entry of the
167      * package name itself.
168      * @return Return true to indicate you care about this change, which will
169      * result in {@link #onSomePackagesChanged()} being called later.  If you
170      * return false, no further callbacks will happen about this change.  The
171      * default implementation returns true if this is a change to the entire
172      * package.
173      */
onPackageChanged(String packageName, int uid, String[] components)174     public boolean onPackageChanged(String packageName, int uid, String[] components) {
175         if (components != null) {
176             for (String name : components) {
177                 if (packageName.equals(name)) {
178                     return true;
179                 }
180             }
181         }
182         return false;
183     }
184 
onHandleForceStop(Intent intent, String[] packages, int uid, boolean doit)185     public boolean onHandleForceStop(Intent intent, String[] packages, int uid, boolean doit) {
186         return false;
187     }
188 
onHandleUserStop(Intent intent, int userHandle)189     public void onHandleUserStop(Intent intent, int userHandle) {
190     }
191 
onUidRemoved(int uid)192     public void onUidRemoved(int uid) {
193     }
194 
onPackagesAvailable(String[] packages)195     public void onPackagesAvailable(String[] packages) {
196     }
197 
onPackagesUnavailable(String[] packages)198     public void onPackagesUnavailable(String[] packages) {
199     }
200 
201     public static final int PACKAGE_UNCHANGED = 0;
202     public static final int PACKAGE_UPDATING = 1;
203     public static final int PACKAGE_TEMPORARY_CHANGE = 2;
204     public static final int PACKAGE_PERMANENT_CHANGE = 3;
205 
206     /**
207      * Called when a package disappears for any reason.
208      */
onPackageDisappeared(String packageName, int reason)209     public void onPackageDisappeared(String packageName, int reason) {
210     }
211 
212     /**
213      * Called when a package appears for any reason.
214      */
onPackageAppeared(String packageName, int reason)215     public void onPackageAppeared(String packageName, int reason) {
216     }
217 
218     /**
219      * Called when an existing package is updated or its disabled state changes.
220      */
onPackageModified(String packageName)221     public void onPackageModified(String packageName) {
222     }
223 
didSomePackagesChange()224     public boolean didSomePackagesChange() {
225         return mSomePackagesChanged;
226     }
227 
isPackageAppearing(String packageName)228     public int isPackageAppearing(String packageName) {
229         if (mAppearingPackages != null) {
230             for (int i=mAppearingPackages.length-1; i>=0; i--) {
231                 if (packageName.equals(mAppearingPackages[i])) {
232                     return mChangeType;
233                 }
234             }
235         }
236         return PACKAGE_UNCHANGED;
237     }
238 
anyPackagesAppearing()239     public boolean anyPackagesAppearing() {
240         return mAppearingPackages != null;
241     }
242 
isPackageDisappearing(String packageName)243     public int isPackageDisappearing(String packageName) {
244         if (mDisappearingPackages != null) {
245             for (int i=mDisappearingPackages.length-1; i>=0; i--) {
246                 if (packageName.equals(mDisappearingPackages[i])) {
247                     return mChangeType;
248                 }
249             }
250         }
251         return PACKAGE_UNCHANGED;
252     }
253 
anyPackagesDisappearing()254     public boolean anyPackagesDisappearing() {
255         return mDisappearingPackages != null;
256     }
257 
isPackageModified(String packageName)258     public boolean isPackageModified(String packageName) {
259         if (mModifiedPackages != null) {
260             for (int i=mModifiedPackages.length-1; i>=0; i--) {
261                 if (packageName.equals(mModifiedPackages[i])) {
262                     return true;
263                 }
264             }
265         }
266         return false;
267     }
268 
onSomePackagesChanged()269     public void onSomePackagesChanged() {
270     }
271 
onFinishPackageChanges()272     public void onFinishPackageChanges() {
273     }
274 
getChangingUserId()275     public int getChangingUserId() {
276         return mChangeUserId;
277     }
278 
getPackageName(Intent intent)279     String getPackageName(Intent intent) {
280         Uri uri = intent.getData();
281         String pkg = uri != null ? uri.getSchemeSpecificPart() : null;
282         return pkg;
283     }
284 
285     @Override
onReceive(Context context, Intent intent)286     public void onReceive(Context context, Intent intent) {
287         mChangeUserId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE,
288                 UserHandle.USER_NULL);
289         if (mChangeUserId == UserHandle.USER_NULL) {
290             throw new IllegalArgumentException(
291                     "Intent broadcast does not contain user handle: " + intent);
292         }
293         onBeginPackageChanges();
294 
295         mDisappearingPackages = mAppearingPackages = null;
296         mSomePackagesChanged = false;
297 
298         String action = intent.getAction();
299         if (Intent.ACTION_PACKAGE_ADDED.equals(action)) {
300             String pkg = getPackageName(intent);
301             int uid = intent.getIntExtra(Intent.EXTRA_UID, 0);
302             // We consider something to have changed regardless of whether
303             // this is just an update, because the update is now finished
304             // and the contents of the package may have changed.
305             mSomePackagesChanged = true;
306             if (pkg != null) {
307                 mAppearingPackages = mTempArray;
308                 mTempArray[0] = pkg;
309                 if (intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) {
310                     mModifiedPackages = mTempArray;
311                     mChangeType = PACKAGE_UPDATING;
312                     onPackageUpdateFinished(pkg, uid);
313                     onPackageModified(pkg);
314                 } else {
315                     mChangeType = PACKAGE_PERMANENT_CHANGE;
316                     onPackageAdded(pkg, uid);
317                 }
318                 onPackageAppeared(pkg, mChangeType);
319                 if (mChangeType == PACKAGE_UPDATING) {
320                     synchronized (mUpdatingPackages) {
321                         mUpdatingPackages.remove(pkg);
322                     }
323                 }
324             }
325         } else if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) {
326             String pkg = getPackageName(intent);
327             int uid = intent.getIntExtra(Intent.EXTRA_UID, 0);
328             if (pkg != null) {
329                 mDisappearingPackages = mTempArray;
330                 mTempArray[0] = pkg;
331                 if (intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) {
332                     mChangeType = PACKAGE_UPDATING;
333                     synchronized (mUpdatingPackages) {
334                         //not used for now
335                         //mUpdatingPackages.add(pkg);
336                     }
337                     onPackageUpdateStarted(pkg, uid);
338                 } else {
339                     mChangeType = PACKAGE_PERMANENT_CHANGE;
340                     // We only consider something to have changed if this is
341                     // not a replace; for a replace, we just need to consider
342                     // it when it is re-added.
343                     mSomePackagesChanged = true;
344                     onPackageRemoved(pkg, uid);
345                     if (intent.getBooleanExtra(Intent.EXTRA_REMOVED_FOR_ALL_USERS, false)) {
346                         onPackageRemovedAllUsers(pkg, uid);
347                     }
348                 }
349                 onPackageDisappeared(pkg, mChangeType);
350             }
351         } else if (Intent.ACTION_PACKAGE_CHANGED.equals(action)) {
352             String pkg = getPackageName(intent);
353             int uid = intent.getIntExtra(Intent.EXTRA_UID, 0);
354             String[] components = intent.getStringArrayExtra(
355                     Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST);
356             if (pkg != null) {
357                 mModifiedPackages = mTempArray;
358                 mTempArray[0] = pkg;
359                 mChangeType = PACKAGE_PERMANENT_CHANGE;
360                 if (onPackageChanged(pkg, uid, components)) {
361                     mSomePackagesChanged = true;
362                 }
363                 onPackageModified(pkg);
364             }
365         } else if (Intent.ACTION_QUERY_PACKAGE_RESTART.equals(action)) {
366             mDisappearingPackages = intent.getStringArrayExtra(Intent.EXTRA_PACKAGES);
367             mChangeType = PACKAGE_TEMPORARY_CHANGE;
368             boolean canRestart = onHandleForceStop(intent,
369                     mDisappearingPackages,
370                     intent.getIntExtra(Intent.EXTRA_UID, 0), false);
371             if (canRestart) setResultCode(Activity.RESULT_OK);
372         } else if (Intent.ACTION_PACKAGE_RESTARTED.equals(action)) {
373             mDisappearingPackages = new String[] {getPackageName(intent)};
374             mChangeType = PACKAGE_TEMPORARY_CHANGE;
375             onHandleForceStop(intent, mDisappearingPackages,
376                     intent.getIntExtra(Intent.EXTRA_UID, 0), true);
377         } else if (Intent.ACTION_UID_REMOVED.equals(action)) {
378             onUidRemoved(intent.getIntExtra(Intent.EXTRA_UID, 0));
379         } else if (Intent.ACTION_USER_STOPPED.equals(action)) {
380             if (intent.hasExtra(Intent.EXTRA_USER_HANDLE)) {
381                 onHandleUserStop(intent, intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 0));
382             }
383         } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(action)) {
384             String[] pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
385             mAppearingPackages = pkgList;
386             mChangeType = PACKAGE_TEMPORARY_CHANGE;
387             mSomePackagesChanged = true;
388             if (pkgList != null) {
389                 onPackagesAvailable(pkgList);
390                 for (int i=0; i<pkgList.length; i++) {
391                     onPackageAppeared(pkgList[i], PACKAGE_TEMPORARY_CHANGE);
392                 }
393             }
394         } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(action)) {
395             String[] pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
396             mDisappearingPackages = pkgList;
397             mChangeType = PACKAGE_TEMPORARY_CHANGE;
398             mSomePackagesChanged = true;
399             if (pkgList != null) {
400                 onPackagesUnavailable(pkgList);
401                 for (int i=0; i<pkgList.length; i++) {
402                     onPackageDisappeared(pkgList[i], PACKAGE_TEMPORARY_CHANGE);
403                 }
404             }
405         }
406 
407         if (mSomePackagesChanged) {
408             onSomePackagesChanged();
409         }
410 
411         onFinishPackageChanges();
412         mChangeUserId = UserHandle.USER_NULL;
413     }
414 }
415