LauncherAppsService.java revision df7db074b5e6a19c8a33c2cc6be88f85eb5ee47c 
1/*
2 * Copyright (C) 2014 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 com.android.server.pm;
18
19import android.app.AppGlobals;
20import android.content.ComponentName;
21import android.content.Context;
22import android.content.Intent;
23import android.content.pm.ActivityInfo;
24import android.content.pm.ILauncherApps;
25import android.content.pm.IOnAppsChangedListener;
26import android.content.pm.IPackageManager;
27import android.content.pm.PackageManager;
28import android.content.pm.PackageInfo;
29import android.content.pm.ResolveInfo;
30import android.content.pm.UserInfo;
31import android.graphics.Rect;
32import android.os.Binder;
33import android.os.Bundle;
34import android.os.IInterface;
35import android.os.RemoteCallbackList;
36import android.os.RemoteException;
37import android.os.UserHandle;
38import android.os.UserManager;
39import android.util.Log;
40import android.util.Slog;
41
42import com.android.internal.content.PackageMonitor;
43import com.android.server.SystemService;
44
45import java.util.ArrayList;
46import java.util.List;
47
48/**
49 * Service that manages requests and callbacks for launchers that support
50 * managed profiles.
51 */
52
53public class LauncherAppsService extends SystemService {
54
55    private final LauncherAppsImpl mLauncherAppsImpl;
56
57    public LauncherAppsService(Context context) {
58        super(context);
59        mLauncherAppsImpl = new LauncherAppsImpl(context);
60    }
61
62    @Override
63    public void onStart() {
64        publishBinderService(Context.LAUNCHER_APPS_SERVICE, mLauncherAppsImpl);
65    }
66
67    class LauncherAppsImpl extends ILauncherApps.Stub {
68        private static final boolean DEBUG = false;
69        private static final String TAG = "LauncherAppsService";
70        private final Context mContext;
71        private final PackageManager mPm;
72        private final UserManager mUm;
73        private final PackageCallbackList<IOnAppsChangedListener> mListeners
74                = new PackageCallbackList<IOnAppsChangedListener>();
75
76        private MyPackageMonitor mPackageMonitor = new MyPackageMonitor();
77
78        public LauncherAppsImpl(Context context) {
79            mContext = context;
80            mPm = mContext.getPackageManager();
81            mUm = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
82        }
83
84        /*
85         * @see android.content.pm.ILauncherApps#addOnAppsChangedListener(
86         *          android.content.pm.IOnAppsChangedListener)
87         */
88        @Override
89        public void addOnAppsChangedListener(IOnAppsChangedListener listener) throws RemoteException {
90            synchronized (mListeners) {
91                if (DEBUG) {
92                    Log.d(TAG, "Adding listener from " + Binder.getCallingUserHandle());
93                }
94                if (mListeners.getRegisteredCallbackCount() == 0) {
95                    if (DEBUG) {
96                        Log.d(TAG, "Starting package monitoring");
97                    }
98                    startWatchingPackageBroadcasts();
99                }
100                mListeners.unregister(listener);
101                mListeners.register(listener, Binder.getCallingUserHandle());
102            }
103        }
104
105        /*
106         * @see android.content.pm.ILauncherApps#removeOnAppsChangedListener(
107         *          android.content.pm.IOnAppsChangedListener)
108         */
109        @Override
110        public void removeOnAppsChangedListener(IOnAppsChangedListener listener)
111                throws RemoteException {
112            synchronized (mListeners) {
113                if (DEBUG) {
114                    Log.d(TAG, "Removing listener from " + Binder.getCallingUserHandle());
115                }
116                mListeners.unregister(listener);
117                if (mListeners.getRegisteredCallbackCount() == 0) {
118                    stopWatchingPackageBroadcasts();
119                }
120            }
121        }
122
123        /**
124         * Register a receiver to watch for package broadcasts
125         */
126        private void startWatchingPackageBroadcasts() {
127            mPackageMonitor.register(mContext, null, UserHandle.ALL, true);
128        }
129
130        /**
131         * Unregister package broadcast receiver
132         */
133        private void stopWatchingPackageBroadcasts() {
134            if (DEBUG) {
135                Log.d(TAG, "Stopped watching for packages");
136            }
137            mPackageMonitor.unregister();
138        }
139
140        void checkCallbackCount() {
141            synchronized (mListeners) {
142                if (DEBUG) {
143                    Log.d(TAG, "Callback count = " + mListeners.getRegisteredCallbackCount());
144                }
145                if (mListeners.getRegisteredCallbackCount() == 0) {
146                    stopWatchingPackageBroadcasts();
147                }
148            }
149        }
150
151        /**
152         * Checks if the caller is in the same group as the userToCheck.
153         */
154        private void ensureInUserProfiles(UserHandle userToCheck, String message) {
155            final int callingUserId = UserHandle.getCallingUserId();
156            final int targetUserId = userToCheck.getIdentifier();
157
158            if (targetUserId == callingUserId) return;
159
160            long ident = Binder.clearCallingIdentity();
161            try {
162                UserInfo callingUserInfo = mUm.getUserInfo(callingUserId);
163                UserInfo targetUserInfo = mUm.getUserInfo(targetUserId);
164                if (targetUserInfo == null
165                        || targetUserInfo.profileGroupId == UserInfo.NO_PROFILE_GROUP_ID
166                        || targetUserInfo.profileGroupId != callingUserInfo.profileGroupId) {
167                    throw new SecurityException(message);
168                }
169            } finally {
170                Binder.restoreCallingIdentity(ident);
171            }
172        }
173
174        /**
175         * Checks if the user is enabled.
176         */
177        private boolean isUserEnabled(UserHandle user) {
178            long ident = Binder.clearCallingIdentity();
179            try {
180                UserInfo targetUserInfo = mUm.getUserInfo(user.getIdentifier());
181                return targetUserInfo != null && targetUserInfo.isEnabled();
182            } finally {
183                Binder.restoreCallingIdentity(ident);
184            }
185        }
186
187        @Override
188        public List<ResolveInfo> getLauncherActivities(String packageName, UserHandle user)
189                throws RemoteException {
190            ensureInUserProfiles(user, "Cannot retrieve activities for unrelated profile " + user);
191            if (!isUserEnabled(user)) {
192                return new ArrayList<ResolveInfo>();
193            }
194
195            final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
196            mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
197            mainIntent.setPackage(packageName);
198            long ident = Binder.clearCallingIdentity();
199            try {
200                List<ResolveInfo> apps = mPm.queryIntentActivitiesAsUser(mainIntent, 0,
201                        user.getIdentifier());
202                return apps;
203            } finally {
204                Binder.restoreCallingIdentity(ident);
205            }
206        }
207
208        @Override
209        public ResolveInfo resolveActivity(Intent intent, UserHandle user)
210                throws RemoteException {
211            ensureInUserProfiles(user, "Cannot resolve activity for unrelated profile " + user);
212            if (!isUserEnabled(user)) {
213                return null;
214            }
215
216            long ident = Binder.clearCallingIdentity();
217            try {
218                ResolveInfo app = mPm.resolveActivityAsUser(intent, 0, user.getIdentifier());
219                return app;
220            } finally {
221                Binder.restoreCallingIdentity(ident);
222            }
223        }
224
225        @Override
226        public boolean isPackageEnabled(String packageName, UserHandle user)
227                throws RemoteException {
228            ensureInUserProfiles(user, "Cannot check package for unrelated profile " + user);
229            if (!isUserEnabled(user)) {
230                return false;
231            }
232
233            long ident = Binder.clearCallingIdentity();
234            try {
235                IPackageManager pm = AppGlobals.getPackageManager();
236                PackageInfo info = pm.getPackageInfo(packageName, 0, user.getIdentifier());
237                return info != null && info.applicationInfo.enabled;
238            } finally {
239                Binder.restoreCallingIdentity(ident);
240            }
241        }
242
243        @Override
244        public boolean isActivityEnabled(ComponentName component, UserHandle user)
245                throws RemoteException {
246            ensureInUserProfiles(user, "Cannot check component for unrelated profile " + user);
247            if (!isUserEnabled(user)) {
248                return false;
249            }
250
251            long ident = Binder.clearCallingIdentity();
252            try {
253                IPackageManager pm = AppGlobals.getPackageManager();
254                ActivityInfo info = pm.getActivityInfo(component, 0, user.getIdentifier());
255                return info != null && info.isEnabled();
256            } finally {
257                Binder.restoreCallingIdentity(ident);
258            }
259        }
260
261        @Override
262        public void startActivityAsUser(ComponentName component, Rect sourceBounds,
263                Bundle opts, UserHandle user) throws RemoteException {
264            ensureInUserProfiles(user, "Cannot start activity for unrelated profile " + user);
265            if (!isUserEnabled(user)) {
266                throw new IllegalStateException("Cannot start activity for disabled profile "  + user);
267            }
268
269            Intent launchIntent = new Intent(Intent.ACTION_MAIN);
270            launchIntent.addCategory(Intent.CATEGORY_LAUNCHER);
271            launchIntent.setComponent(component);
272            launchIntent.setSourceBounds(sourceBounds);
273            launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
274
275            long ident = Binder.clearCallingIdentity();
276            try {
277                mContext.startActivityAsUser(launchIntent, opts, user);
278            } finally {
279                Binder.restoreCallingIdentity(ident);
280            }
281        }
282
283        private class MyPackageMonitor extends PackageMonitor {
284
285            /** Checks if user is a profile of or same as listeningUser.
286              * and the user is enabled. */
287            private boolean isEnabledProfileOf(UserHandle user, UserHandle listeningUser,
288                    String debugMsg) {
289                if (user.getIdentifier() == listeningUser.getIdentifier()) {
290                    if (DEBUG) Log.d(TAG, "Delivering msg to same user " + debugMsg);
291                    return true;
292                }
293                long ident = Binder.clearCallingIdentity();
294                try {
295                    UserInfo userInfo = mUm.getUserInfo(user.getIdentifier());
296                    UserInfo listeningUserInfo = mUm.getUserInfo(listeningUser.getIdentifier());
297                    if (userInfo == null || listeningUserInfo == null
298                            || userInfo.profileGroupId == UserInfo.NO_PROFILE_GROUP_ID
299                            || userInfo.profileGroupId != listeningUserInfo.profileGroupId
300                            || !userInfo.isEnabled()) {
301                        if (DEBUG) {
302                            Log.d(TAG, "Not delivering msg from " + user + " to " + listeningUser + ":"
303                                    + debugMsg);
304                        }
305                        return false;
306                    } else {
307                        if (DEBUG) {
308                            Log.d(TAG, "Delivering msg from " + user + " to " + listeningUser + ":"
309                                    + debugMsg);
310                        }
311                        return true;
312                    }
313                } finally {
314                    Binder.restoreCallingIdentity(ident);
315                }
316            }
317
318            @Override
319            public void onPackageAdded(String packageName, int uid) {
320                UserHandle user = new UserHandle(getChangingUserId());
321                final int n = mListeners.beginBroadcast();
322                for (int i = 0; i < n; i++) {
323                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
324                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
325                    if (!isEnabledProfileOf(user, listeningUser, "onPackageAdded")) continue;
326                    try {
327                        listener.onPackageAdded(user, packageName);
328                    } catch (RemoteException re) {
329                        Slog.d(TAG, "Callback failed ", re);
330                    }
331                }
332                mListeners.finishBroadcast();
333
334                super.onPackageAdded(packageName, uid);
335            }
336
337            @Override
338            public void onPackageRemoved(String packageName, int uid) {
339                UserHandle user = new UserHandle(getChangingUserId());
340                final int n = mListeners.beginBroadcast();
341                for (int i = 0; i < n; i++) {
342                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
343                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
344                    if (!isEnabledProfileOf(user, listeningUser, "onPackageRemoved")) continue;
345                    try {
346                        listener.onPackageRemoved(user, packageName);
347                    } catch (RemoteException re) {
348                        Slog.d(TAG, "Callback failed ", re);
349                    }
350                }
351                mListeners.finishBroadcast();
352
353                super.onPackageRemoved(packageName, uid);
354            }
355
356            @Override
357            public void onPackageModified(String packageName) {
358                UserHandle user = new UserHandle(getChangingUserId());
359                final int n = mListeners.beginBroadcast();
360                for (int i = 0; i < n; i++) {
361                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
362                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
363                    if (!isEnabledProfileOf(user, listeningUser, "onPackageModified")) continue;
364                    try {
365                        listener.onPackageChanged(user, packageName);
366                    } catch (RemoteException re) {
367                        Slog.d(TAG, "Callback failed ", re);
368                    }
369                }
370                mListeners.finishBroadcast();
371
372                super.onPackageModified(packageName);
373            }
374
375            @Override
376            public void onPackagesAvailable(String[] packages) {
377                UserHandle user = new UserHandle(getChangingUserId());
378                final int n = mListeners.beginBroadcast();
379                for (int i = 0; i < n; i++) {
380                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
381                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
382                    if (!isEnabledProfileOf(user, listeningUser, "onPackagesAvailable")) continue;
383                    try {
384                        listener.onPackagesAvailable(user, packages, isReplacing());
385                    } catch (RemoteException re) {
386                        Slog.d(TAG, "Callback failed ", re);
387                    }
388                }
389                mListeners.finishBroadcast();
390
391                super.onPackagesAvailable(packages);
392            }
393
394            @Override
395            public void onPackagesUnavailable(String[] packages) {
396                UserHandle user = new UserHandle(getChangingUserId());
397                final int n = mListeners.beginBroadcast();
398                for (int i = 0; i < n; i++) {
399                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
400                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
401                    if (!isEnabledProfileOf(user, listeningUser, "onPackagesUnavailable")) continue;
402                    try {
403                        listener.onPackagesUnavailable(user, packages, isReplacing());
404                    } catch (RemoteException re) {
405                        Slog.d(TAG, "Callback failed ", re);
406                    }
407                }
408                mListeners.finishBroadcast();
409
410                super.onPackagesUnavailable(packages);
411            }
412
413        }
414
415        class PackageCallbackList<T extends IInterface> extends RemoteCallbackList<T> {
416            @Override
417            public void onCallbackDied(T callback, Object cookie) {
418                checkCallbackCount();
419            }
420        }
421    }
422}