LauncherAppsService.java revision fa4533f3a07ebed479d2a0e7af7d6e03d4417d41 
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,
201                        PackageManager.NO_CROSS_PROFILE, // We only want the apps for this user
202                        user.getIdentifier());
203                return apps;
204            } finally {
205                Binder.restoreCallingIdentity(ident);
206            }
207        }
208
209        @Override
210        public ResolveInfo resolveActivity(Intent intent, UserHandle user)
211                throws RemoteException {
212            ensureInUserProfiles(user, "Cannot resolve activity for unrelated profile " + user);
213            if (!isUserEnabled(user)) {
214                return null;
215            }
216
217            long ident = Binder.clearCallingIdentity();
218            try {
219                ResolveInfo app = mPm.resolveActivityAsUser(intent, 0, user.getIdentifier());
220                return app;
221            } finally {
222                Binder.restoreCallingIdentity(ident);
223            }
224        }
225
226        @Override
227        public boolean isPackageEnabled(String packageName, UserHandle user)
228                throws RemoteException {
229            ensureInUserProfiles(user, "Cannot check package for unrelated profile " + user);
230            if (!isUserEnabled(user)) {
231                return false;
232            }
233
234            long ident = Binder.clearCallingIdentity();
235            try {
236                IPackageManager pm = AppGlobals.getPackageManager();
237                PackageInfo info = pm.getPackageInfo(packageName, 0, user.getIdentifier());
238                return info != null && info.applicationInfo.enabled;
239            } finally {
240                Binder.restoreCallingIdentity(ident);
241            }
242        }
243
244        @Override
245        public boolean isActivityEnabled(ComponentName component, UserHandle user)
246                throws RemoteException {
247            ensureInUserProfiles(user, "Cannot check component for unrelated profile " + user);
248            if (!isUserEnabled(user)) {
249                return false;
250            }
251
252            long ident = Binder.clearCallingIdentity();
253            try {
254                IPackageManager pm = AppGlobals.getPackageManager();
255                ActivityInfo info = pm.getActivityInfo(component, 0, user.getIdentifier());
256                return info != null && info.isEnabled();
257            } finally {
258                Binder.restoreCallingIdentity(ident);
259            }
260        }
261
262        @Override
263        public void startActivityAsUser(ComponentName component, Rect sourceBounds,
264                Bundle opts, UserHandle user) throws RemoteException {
265            ensureInUserProfiles(user, "Cannot start activity for unrelated profile " + user);
266            if (!isUserEnabled(user)) {
267                throw new IllegalStateException("Cannot start activity for disabled profile "  + user);
268            }
269
270            Intent launchIntent = new Intent(Intent.ACTION_MAIN);
271            launchIntent.addCategory(Intent.CATEGORY_LAUNCHER);
272            launchIntent.setComponent(component);
273            launchIntent.setSourceBounds(sourceBounds);
274            launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
275
276            long ident = Binder.clearCallingIdentity();
277            try {
278                mContext.startActivityAsUser(launchIntent, opts, user);
279            } finally {
280                Binder.restoreCallingIdentity(ident);
281            }
282        }
283
284        private class MyPackageMonitor extends PackageMonitor {
285
286            /** Checks if user is a profile of or same as listeningUser.
287              * and the user is enabled. */
288            private boolean isEnabledProfileOf(UserHandle user, UserHandle listeningUser,
289                    String debugMsg) {
290                if (user.getIdentifier() == listeningUser.getIdentifier()) {
291                    if (DEBUG) Log.d(TAG, "Delivering msg to same user " + debugMsg);
292                    return true;
293                }
294                long ident = Binder.clearCallingIdentity();
295                try {
296                    UserInfo userInfo = mUm.getUserInfo(user.getIdentifier());
297                    UserInfo listeningUserInfo = mUm.getUserInfo(listeningUser.getIdentifier());
298                    if (userInfo == null || listeningUserInfo == null
299                            || userInfo.profileGroupId == UserInfo.NO_PROFILE_GROUP_ID
300                            || userInfo.profileGroupId != listeningUserInfo.profileGroupId
301                            || !userInfo.isEnabled()) {
302                        if (DEBUG) {
303                            Log.d(TAG, "Not delivering msg from " + user + " to " + listeningUser + ":"
304                                    + debugMsg);
305                        }
306                        return false;
307                    } else {
308                        if (DEBUG) {
309                            Log.d(TAG, "Delivering msg from " + user + " to " + listeningUser + ":"
310                                    + debugMsg);
311                        }
312                        return true;
313                    }
314                } finally {
315                    Binder.restoreCallingIdentity(ident);
316                }
317            }
318
319            @Override
320            public void onPackageAdded(String packageName, int uid) {
321                UserHandle user = new UserHandle(getChangingUserId());
322                final int n = mListeners.beginBroadcast();
323                for (int i = 0; i < n; i++) {
324                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
325                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
326                    if (!isEnabledProfileOf(user, listeningUser, "onPackageAdded")) continue;
327                    try {
328                        listener.onPackageAdded(user, packageName);
329                    } catch (RemoteException re) {
330                        Slog.d(TAG, "Callback failed ", re);
331                    }
332                }
333                mListeners.finishBroadcast();
334
335                super.onPackageAdded(packageName, uid);
336            }
337
338            @Override
339            public void onPackageRemoved(String packageName, int uid) {
340                UserHandle user = new UserHandle(getChangingUserId());
341                final int n = mListeners.beginBroadcast();
342                for (int i = 0; i < n; i++) {
343                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
344                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
345                    if (!isEnabledProfileOf(user, listeningUser, "onPackageRemoved")) continue;
346                    try {
347                        listener.onPackageRemoved(user, packageName);
348                    } catch (RemoteException re) {
349                        Slog.d(TAG, "Callback failed ", re);
350                    }
351                }
352                mListeners.finishBroadcast();
353
354                super.onPackageRemoved(packageName, uid);
355            }
356
357            @Override
358            public void onPackageModified(String packageName) {
359                UserHandle user = new UserHandle(getChangingUserId());
360                final int n = mListeners.beginBroadcast();
361                for (int i = 0; i < n; i++) {
362                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
363                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
364                    if (!isEnabledProfileOf(user, listeningUser, "onPackageModified")) continue;
365                    try {
366                        listener.onPackageChanged(user, packageName);
367                    } catch (RemoteException re) {
368                        Slog.d(TAG, "Callback failed ", re);
369                    }
370                }
371                mListeners.finishBroadcast();
372
373                super.onPackageModified(packageName);
374            }
375
376            @Override
377            public void onPackagesAvailable(String[] packages) {
378                UserHandle user = new UserHandle(getChangingUserId());
379                final int n = mListeners.beginBroadcast();
380                for (int i = 0; i < n; i++) {
381                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
382                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
383                    if (!isEnabledProfileOf(user, listeningUser, "onPackagesAvailable")) continue;
384                    try {
385                        listener.onPackagesAvailable(user, packages, isReplacing());
386                    } catch (RemoteException re) {
387                        Slog.d(TAG, "Callback failed ", re);
388                    }
389                }
390                mListeners.finishBroadcast();
391
392                super.onPackagesAvailable(packages);
393            }
394
395            @Override
396            public void onPackagesUnavailable(String[] packages) {
397                UserHandle user = new UserHandle(getChangingUserId());
398                final int n = mListeners.beginBroadcast();
399                for (int i = 0; i < n; i++) {
400                    IOnAppsChangedListener listener = mListeners.getBroadcastItem(i);
401                    UserHandle listeningUser = (UserHandle) mListeners.getBroadcastCookie(i);
402                    if (!isEnabledProfileOf(user, listeningUser, "onPackagesUnavailable")) continue;
403                    try {
404                        listener.onPackagesUnavailable(user, packages, isReplacing());
405                    } catch (RemoteException re) {
406                        Slog.d(TAG, "Callback failed ", re);
407                    }
408                }
409                mListeners.finishBroadcast();
410
411                super.onPackagesUnavailable(packages);
412            }
413
414        }
415
416        class PackageCallbackList<T extends IInterface> extends RemoteCallbackList<T> {
417            @Override
418            public void onCallbackDied(T callback, Object cookie) {
419                checkCallbackCount();
420            }
421        }
422    }
423}