ComponentTest.java revision 0dc59e78e18493aecd37427531d093e800846c3e 
1/*
2 * Copyright (C) 2008 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.pm;
18
19import com.android.frameworks.coretests.enabled_app.DisabledActivity;
20import com.android.frameworks.coretests.enabled_app.DisabledProvider;
21import com.android.frameworks.coretests.enabled_app.DisabledReceiver;
22import com.android.frameworks.coretests.enabled_app.DisabledService;
23import com.android.frameworks.coretests.enabled_app.EnabledActivity;
24import com.android.frameworks.coretests.enabled_app.EnabledProvider;
25import com.android.frameworks.coretests.enabled_app.EnabledReceiver;
26import com.android.frameworks.coretests.enabled_app.EnabledService;
27
28import android.content.ComponentName;
29import android.content.Intent;
30import android.content.pm.ActivityInfo;
31import android.content.pm.ComponentInfo;
32import android.content.pm.PackageInfo;
33import android.content.pm.PackageManager;
34import android.test.suitebuilder.annotation.LargeTest;
35import android.test.suitebuilder.annotation.MediumTest;
36import android.test.suitebuilder.annotation.SmallTest;
37import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
38import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
39import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
40import static android.content.pm.PackageManager.GET_DISABLED_COMPONENTS;
41import android.content.pm.ProviderInfo;
42import android.content.pm.ResolveInfo;
43import android.content.pm.ServiceInfo;
44import android.test.AndroidTestCase;
45
46import java.util.List;
47
48/**
49 * Tests for disabling and enabling application components.
50 *
51 * Note: These tests are on the slow side.  This is probably because most of the tests trigger the
52 * package settings file to get written out by the PackageManagerService.  Better, more unit-y test
53 * would fix this.
54 */
55
56public class ComponentTest extends AndroidTestCase {
57
58    private PackageManager mPackageManager;
59    private Intent mDisabledActivityIntent;
60    private Intent mEnabledActivityIntent;
61    private Intent mDisabledServiceIntent;
62    private Intent mEnabledServiceIntent;
63    private Intent mDisabledReceiverIntent;
64    private Intent mEnabledReceiverIntent;
65    private Intent mDisabledAppEnabledActivityIntent;
66
67    private static final String ENABLED_PACKAGENAME =
68            "com.android.frameworks.coretests.enabled_app";
69    private static final String DISABLED_PACKAGENAME =
70            "com.android.frameworks.coretests.disabled_app";
71    private static final String DISABLED_ACTIVITY_CLASSNAME =
72            DisabledActivity.class.getName();
73    private static final ComponentName DISABLED_ACTIVITY_COMPONENTNAME =
74            new ComponentName(ENABLED_PACKAGENAME, DISABLED_ACTIVITY_CLASSNAME);
75    private static final String ENABLED_ACTIVITY_CLASSNAME =
76            EnabledActivity.class.getName();
77    private static final ComponentName ENABLED_ACTIVITY_COMPONENTNAME =
78            new ComponentName(ENABLED_PACKAGENAME, ENABLED_ACTIVITY_CLASSNAME);
79    private static final String DISABLED_SERVICE_CLASSNAME =
80            DisabledService.class.getName();
81    private static final ComponentName DISABLED_SERVICE_COMPONENTNAME =
82            new ComponentName(ENABLED_PACKAGENAME, DISABLED_SERVICE_CLASSNAME);
83    private static final String DISABLED_PROVIDER_CLASSNAME =
84            DisabledProvider.class.getName();
85    private static final ComponentName DISABLED_PROVIDER_COMPONENTNAME =
86            new ComponentName(ENABLED_PACKAGENAME, DISABLED_PROVIDER_CLASSNAME);
87    private static final String DISABLED_PROVIDER_NAME = DisabledProvider.class.getName();
88    private static final String ENABLED_SERVICE_CLASSNAME =
89            EnabledService.class.getName();
90    private static final ComponentName ENABLED_SERVICE_COMPONENTNAME =
91            new ComponentName(ENABLED_PACKAGENAME, ENABLED_SERVICE_CLASSNAME);
92    private static final String DISABLED_RECEIVER_CLASSNAME =
93            DisabledReceiver.class.getName();
94    private static final ComponentName DISABLED_RECEIVER_COMPONENTNAME =
95            new ComponentName(ENABLED_PACKAGENAME, DISABLED_RECEIVER_CLASSNAME);
96    private static final String ENABLED_RECEIVER_CLASSNAME =
97            EnabledReceiver.class.getName();
98    private static final ComponentName ENABLED_RECEIVER_COMPONENTNAME =
99            new ComponentName(ENABLED_PACKAGENAME, ENABLED_RECEIVER_CLASSNAME);
100    private static final String ENABLED_PROVIDER_CLASSNAME =
101            EnabledProvider.class.getName();
102    private static final ComponentName ENABLED_PROVIDER_COMPONENTNAME =
103            new ComponentName(ENABLED_PACKAGENAME, ENABLED_PROVIDER_CLASSNAME);
104    private static final String ENABLED_PROVIDER_NAME = EnabledProvider.class.getName();
105    private static final String DISABLED_APP_ENABLED_ACTIVITY_CLASSNAME =
106            com.android.frameworks.coretests.disabled_app.EnabledActivity.class.getName();
107    private static final ComponentName DISABLED_APP_ENABLED_ACTIVITY_COMPONENTNAME =
108            new ComponentName(DISABLED_PACKAGENAME, DISABLED_APP_ENABLED_ACTIVITY_CLASSNAME);
109    private static final String TEST_CATEGORY =
110            "com.android.frameworks.coretests.enabled_app.TEST_CATEGORY";
111
112    @Override
113    protected void setUp() throws Exception {
114        super.setUp();
115        mPackageManager = mContext.getPackageManager();
116        mDisabledActivityIntent = new Intent();
117        mDisabledActivityIntent.setComponent(DISABLED_ACTIVITY_COMPONENTNAME);
118        mEnabledActivityIntent = new Intent();
119        mEnabledActivityIntent.setComponent(ENABLED_ACTIVITY_COMPONENTNAME);
120        mDisabledServiceIntent = new Intent();
121        mDisabledServiceIntent.setComponent(DISABLED_SERVICE_COMPONENTNAME);
122        mEnabledServiceIntent = new Intent();
123        mEnabledServiceIntent.setComponent(ENABLED_SERVICE_COMPONENTNAME);
124        mDisabledReceiverIntent = new Intent("android.intent.action.ENABLED_APP_DISABLED_RECEIVER");
125        mDisabledReceiverIntent.setComponent(DISABLED_RECEIVER_COMPONENTNAME);
126        mEnabledReceiverIntent = new Intent("android.intent.action.ENABLED_APP_ENABLED_RECEIVER");
127        mEnabledReceiverIntent.setComponent(ENABLED_RECEIVER_COMPONENTNAME);
128        mDisabledAppEnabledActivityIntent = new Intent();
129        mDisabledAppEnabledActivityIntent.setComponent(DISABLED_APP_ENABLED_ACTIVITY_COMPONENTNAME);
130    }
131
132    @SmallTest
133    public void testContextNotNull() throws Exception {
134        assertNotNull(mContext);
135    }
136
137    @MediumTest
138    public void testResolveDisabledActivity() throws Exception {
139        mPackageManager.setComponentEnabledSetting(DISABLED_ACTIVITY_COMPONENTNAME,
140                                                   COMPONENT_ENABLED_STATE_DEFAULT,
141                                                   PackageManager.DONT_KILL_APP);
142
143        final ResolveInfo info = mPackageManager.resolveActivity(mDisabledActivityIntent, 0);
144        assertNull(info);
145
146        final ResolveInfo info2 = mPackageManager.resolveActivity(
147                mDisabledActivityIntent, GET_DISABLED_COMPONENTS);
148        assertNotNull(info2);
149        assertNotNull(info2.activityInfo);
150        assertFalse(info2.activityInfo.enabled);
151    }
152
153    @MediumTest
154    public void testResolveEnabledActivity() throws Exception {
155        mPackageManager.setComponentEnabledSetting(ENABLED_ACTIVITY_COMPONENTNAME,
156                                                   COMPONENT_ENABLED_STATE_DEFAULT,
157                                                   PackageManager.DONT_KILL_APP);
158
159        final ResolveInfo info = mPackageManager.resolveActivity(mEnabledActivityIntent, 0);
160        assertNotNull(info);
161        assertNotNull(info);
162        assertNotNull(info.activityInfo);
163        assertTrue(info.activityInfo.enabled);
164    }
165
166    @MediumTest
167    public void testQueryDisabledActivity() throws Exception {
168        mPackageManager.setComponentEnabledSetting(DISABLED_ACTIVITY_COMPONENTNAME,
169                                                   COMPONENT_ENABLED_STATE_DEFAULT,
170                                                   PackageManager.DONT_KILL_APP);
171
172        final List<ResolveInfo> infoList =
173                mPackageManager.queryIntentActivities(mDisabledActivityIntent, 0);
174        assertEquals(0, infoList.size());
175
176        final List<ResolveInfo> infoList2 =
177                mPackageManager.queryIntentActivities(mDisabledActivityIntent,
178                                                      GET_DISABLED_COMPONENTS);
179        assertEquals(1, infoList2.size());
180        final ResolveInfo info = infoList2.get(0);
181        assertNotNull(info);
182        assertNotNull(info.activityInfo);
183        assertFalse(info.activityInfo.enabled);
184    }
185
186    @MediumTest
187    public void testQueryEnabledActivity() throws Exception {
188        mPackageManager.setComponentEnabledSetting(ENABLED_ACTIVITY_COMPONENTNAME,
189                                                   COMPONENT_ENABLED_STATE_DEFAULT,
190                                                   PackageManager.DONT_KILL_APP);
191
192        final List<ResolveInfo> infoList =
193                mPackageManager.queryIntentActivities(mEnabledActivityIntent, 0);
194        assertEquals(1, infoList.size());
195        final ResolveInfo info = infoList.get(0);
196        assertNotNull(info);
197        assertNotNull(info.activityInfo);
198        assertTrue(info.activityInfo.enabled);
199    }
200
201    @MediumTest
202    public void testGetDisabledActivityInfo() throws Exception {
203        mPackageManager.setComponentEnabledSetting(DISABLED_ACTIVITY_COMPONENTNAME,
204                                                   COMPONENT_ENABLED_STATE_DEFAULT,
205                                                   PackageManager.DONT_KILL_APP);
206
207        try {
208            mPackageManager.getActivityInfo(DISABLED_ACTIVITY_COMPONENTNAME, 0);
209            fail("Attempt to get info on disabled component should fail.");
210        } catch (PackageManager.NameNotFoundException e) {
211            // expected
212        }
213
214        final ActivityInfo activityInfo =
215              mPackageManager.getActivityInfo(DISABLED_ACTIVITY_COMPONENTNAME,
216                                              GET_DISABLED_COMPONENTS);
217        assertNotNull(activityInfo);
218        assertFalse(activityInfo.enabled);
219    }
220
221    @MediumTest
222    public void testGetEnabledActivityInfo() throws Exception {
223        mPackageManager.setComponentEnabledSetting(ENABLED_ACTIVITY_COMPONENTNAME,
224                                                   COMPONENT_ENABLED_STATE_DEFAULT,
225                                                   PackageManager.DONT_KILL_APP);
226
227        ActivityInfo activityInfo =
228              mPackageManager.getActivityInfo(ENABLED_ACTIVITY_COMPONENTNAME, 0);
229        assertNotNull(activityInfo);
230        assertTrue(activityInfo.enabled);
231    }
232
233    @MediumTest
234    public void testEnableActivity() throws Exception {
235        mPackageManager.setComponentEnabledSetting(DISABLED_ACTIVITY_COMPONENTNAME,
236                                                   COMPONENT_ENABLED_STATE_DEFAULT,
237                                                   PackageManager.DONT_KILL_APP);
238
239        final ResolveInfo info = mPackageManager.resolveActivity(mDisabledActivityIntent, 0);
240        assertNull(info);
241        mPackageManager.setComponentEnabledSetting(DISABLED_ACTIVITY_COMPONENTNAME,
242                                                   COMPONENT_ENABLED_STATE_ENABLED,
243                                                   PackageManager.DONT_KILL_APP);
244        final ResolveInfo info2 =
245                mPackageManager.resolveActivity(mDisabledActivityIntent,
246                                                0);
247        assertNotNull(info2);
248        assertNotNull(info2.activityInfo);
249        assertFalse(info2.activityInfo.enabled);
250
251        final List<ResolveInfo> infoList =
252                mPackageManager.queryIntentActivities(mDisabledActivityIntent, 0);
253        assertEquals(1, infoList.size());
254    }
255
256    @LargeTest
257    public void testDisableActivity() throws Exception {
258        mPackageManager.setComponentEnabledSetting(ENABLED_ACTIVITY_COMPONENTNAME,
259                                                   COMPONENT_ENABLED_STATE_DEFAULT,
260                                                   PackageManager.DONT_KILL_APP);
261
262        final ResolveInfo info = mPackageManager.resolveActivity(mEnabledActivityIntent, 0);
263        assertNotNull(info);
264        assertNotNull(info.activityInfo);
265        mPackageManager.setComponentEnabledSetting(ENABLED_ACTIVITY_COMPONENTNAME,
266                                                   COMPONENT_ENABLED_STATE_DISABLED,
267                                                   PackageManager.DONT_KILL_APP);
268        final ResolveInfo info2 =
269                mPackageManager.resolveActivity(mEnabledActivityIntent,
270                                                0);
271        assertNull(info2);
272
273        final ResolveInfo info3 = mPackageManager.resolveActivity(mEnabledActivityIntent,
274                                                                  GET_DISABLED_COMPONENTS);
275        assertNotNull(info3);
276        assertNotNull(info3.activityInfo);
277        assertTrue(info3.activityInfo.enabled);
278
279        final List<ResolveInfo> infoList =
280                mPackageManager.queryIntentActivities(mEnabledActivityIntent, 0);
281        assertEquals(0, infoList.size());
282    }
283
284    @MediumTest
285    public void testResolveDisabledService() throws Exception {
286        mPackageManager.setComponentEnabledSetting(DISABLED_SERVICE_COMPONENTNAME,
287                                                   COMPONENT_ENABLED_STATE_DEFAULT,
288                                                   PackageManager.DONT_KILL_APP);
289
290        final ResolveInfo info = mPackageManager.resolveService(mDisabledServiceIntent, 0);
291        assertNull(info);
292
293        final ResolveInfo info2 = mPackageManager.resolveService(
294                mDisabledServiceIntent, GET_DISABLED_COMPONENTS);
295        assertNotNull(info2);
296        assertNotNull(info2.serviceInfo);
297        assertFalse(info2.serviceInfo.enabled);
298    }
299
300    @MediumTest
301    public void testResolveEnabledService() throws Exception {
302        mPackageManager.setComponentEnabledSetting(ENABLED_SERVICE_COMPONENTNAME,
303                                                   COMPONENT_ENABLED_STATE_DEFAULT,
304                                                   PackageManager.DONT_KILL_APP);
305
306        final ResolveInfo info = mPackageManager.resolveService(mEnabledServiceIntent, 0);
307        assertNotNull(info);
308        assertNotNull(info);
309        assertNotNull(info.serviceInfo);
310        assertTrue(info.serviceInfo.enabled);
311    }
312
313    @MediumTest
314    public void testQueryDisabledService() throws Exception {
315        mPackageManager.setComponentEnabledSetting(DISABLED_SERVICE_COMPONENTNAME,
316                                                   COMPONENT_ENABLED_STATE_DEFAULT,
317                                                   PackageManager.DONT_KILL_APP);
318
319        final List<ResolveInfo> infoList =
320                mPackageManager.queryIntentServices(mDisabledServiceIntent, 0);
321        assertEquals(0, infoList.size());
322
323        final List<ResolveInfo> infoList2 =
324                mPackageManager.queryIntentServices(mDisabledServiceIntent,
325                                                      GET_DISABLED_COMPONENTS);
326        assertEquals(1, infoList2.size());
327        final ResolveInfo info = infoList2.get(0);
328        assertNotNull(info);
329        assertNotNull(info.serviceInfo);
330        assertFalse(info.serviceInfo.enabled);
331    }
332
333    @MediumTest
334    public void testQueryEnabledService() throws Exception {
335        mPackageManager.setComponentEnabledSetting(ENABLED_SERVICE_COMPONENTNAME,
336                                                   COMPONENT_ENABLED_STATE_DEFAULT,
337                                                   PackageManager.DONT_KILL_APP);
338
339        final List<ResolveInfo> infoList =
340                mPackageManager.queryIntentServices(mEnabledServiceIntent, 0);
341        assertEquals(1, infoList.size());
342        final ResolveInfo info = infoList.get(0);
343        assertNotNull(info);
344        assertNotNull(info.serviceInfo);
345        assertTrue(info.serviceInfo.enabled);
346    }
347
348    @MediumTest
349    public void testGetDisabledServiceInfo() throws Exception {
350        mPackageManager.setComponentEnabledSetting(DISABLED_SERVICE_COMPONENTNAME,
351                                                   COMPONENT_ENABLED_STATE_DEFAULT,
352                                                   PackageManager.DONT_KILL_APP);
353
354        try {
355            mPackageManager.getServiceInfo(DISABLED_SERVICE_COMPONENTNAME, 0);
356            fail("Attempt to get info on disabled component should fail.");
357        } catch (PackageManager.NameNotFoundException e) {
358            // expected
359        }
360
361        final ServiceInfo serviceInfo =
362              mPackageManager.getServiceInfo(DISABLED_SERVICE_COMPONENTNAME,
363                                              GET_DISABLED_COMPONENTS);
364        assertNotNull(serviceInfo);
365        assertFalse(serviceInfo.enabled);
366    }
367
368    @MediumTest
369    public void testGetEnabledServiceInfo() throws Exception {
370        mPackageManager.setComponentEnabledSetting(ENABLED_SERVICE_COMPONENTNAME,
371                                                   COMPONENT_ENABLED_STATE_DEFAULT,
372                                                   PackageManager.DONT_KILL_APP);
373
374        ServiceInfo serviceInfo =
375              mPackageManager.getServiceInfo(ENABLED_SERVICE_COMPONENTNAME, 0);
376        assertNotNull(serviceInfo);
377        assertTrue(serviceInfo.enabled);
378    }
379
380    @MediumTest
381    public void testEnableService() throws Exception {
382        mPackageManager.setComponentEnabledSetting(DISABLED_SERVICE_COMPONENTNAME,
383                                                   COMPONENT_ENABLED_STATE_DEFAULT,
384                                                   PackageManager.DONT_KILL_APP);
385
386        final ResolveInfo info = mPackageManager.resolveService(mDisabledServiceIntent, 0);
387        assertNull(info);
388        mPackageManager.setComponentEnabledSetting(DISABLED_SERVICE_COMPONENTNAME,
389                                                   COMPONENT_ENABLED_STATE_ENABLED,
390                                                   PackageManager.DONT_KILL_APP);
391        final ResolveInfo info2 =
392                mPackageManager.resolveService(mDisabledServiceIntent,
393                                                0);
394        assertNotNull(info2);
395        assertNotNull(info2.serviceInfo);
396        assertFalse(info2.serviceInfo.enabled);
397    }
398
399    @LargeTest
400    public void testDisableService() throws Exception {
401        mPackageManager.setComponentEnabledSetting(ENABLED_SERVICE_COMPONENTNAME,
402                                                   COMPONENT_ENABLED_STATE_DEFAULT,
403                                                   PackageManager.DONT_KILL_APP);
404
405        final ResolveInfo info = mPackageManager.resolveService(mEnabledServiceIntent, 0);
406        assertNotNull(info);
407        assertNotNull(info.serviceInfo);
408        mPackageManager.setComponentEnabledSetting(ENABLED_SERVICE_COMPONENTNAME,
409                                                   COMPONENT_ENABLED_STATE_DISABLED,
410                                                   PackageManager.DONT_KILL_APP);
411        final ResolveInfo info2 =
412                mPackageManager.resolveService(mEnabledServiceIntent,
413                                                0);
414        assertNull(info2);
415
416        final ResolveInfo info3 = mPackageManager.resolveService(mEnabledServiceIntent,
417                                                                  GET_DISABLED_COMPONENTS);
418        assertNotNull(info3);
419        assertNotNull(info3.serviceInfo);
420        assertTrue(info3.serviceInfo.enabled);
421    }
422
423    @MediumTest
424    public void testQueryDisabledReceiver() throws Exception {
425        mPackageManager.setComponentEnabledSetting(DISABLED_RECEIVER_COMPONENTNAME,
426                                                   COMPONENT_ENABLED_STATE_DEFAULT,
427                                                   PackageManager.DONT_KILL_APP);
428
429        final List<ResolveInfo> infoList =
430                mPackageManager.queryBroadcastReceivers(mDisabledReceiverIntent, 0);
431        assertEquals(0, infoList.size());
432
433        final List<ResolveInfo> infoList2 =
434                mPackageManager.queryBroadcastReceivers(mDisabledReceiverIntent,
435                                                      GET_DISABLED_COMPONENTS);
436        assertEquals(1, infoList2.size());
437        final ResolveInfo info = infoList2.get(0);
438        assertNotNull(info);
439        assertNotNull(info.activityInfo);
440        assertFalse(info.activityInfo.enabled);
441    }
442
443    @MediumTest
444    public void testQueryEnabledReceiver() throws Exception {
445        mPackageManager.setComponentEnabledSetting(ENABLED_RECEIVER_COMPONENTNAME,
446                                                   COMPONENT_ENABLED_STATE_DEFAULT,
447                                                   PackageManager.DONT_KILL_APP);
448
449        final List<ResolveInfo> infoList =
450                mPackageManager.queryBroadcastReceivers(mEnabledReceiverIntent, 0);
451        assertEquals(1, infoList.size());
452        final ResolveInfo info = infoList.get(0);
453        assertNotNull(info);
454        assertNotNull(info.activityInfo);
455        assertTrue(info.activityInfo.enabled);
456    }
457
458    @MediumTest
459    public void testGetDisabledReceiverInfo() throws Exception {
460        mPackageManager.setComponentEnabledSetting(DISABLED_RECEIVER_COMPONENTNAME,
461                                                   COMPONENT_ENABLED_STATE_DEFAULT,
462                                                   PackageManager.DONT_KILL_APP);
463
464        try {
465            mPackageManager.getReceiverInfo(DISABLED_RECEIVER_COMPONENTNAME, 0);
466            fail("Attempt to get info on disabled component should fail.");
467        } catch (PackageManager.NameNotFoundException e) {
468            // expected
469        }
470
471        final ActivityInfo activityInfo =
472              mPackageManager.getReceiverInfo(DISABLED_RECEIVER_COMPONENTNAME,
473                                              GET_DISABLED_COMPONENTS);
474        assertNotNull(activityInfo);
475        assertFalse(activityInfo.enabled);
476    }
477
478    @MediumTest
479    public void testGetEnabledReceiverInfo() throws Exception {
480        mPackageManager.setComponentEnabledSetting(ENABLED_RECEIVER_COMPONENTNAME,
481                                                   COMPONENT_ENABLED_STATE_DEFAULT,
482                                                   PackageManager.DONT_KILL_APP);
483
484        ActivityInfo activityInfo =
485              mPackageManager.getReceiverInfo(ENABLED_RECEIVER_COMPONENTNAME, 0);
486        assertNotNull(activityInfo);
487        assertTrue(activityInfo.enabled);
488    }
489
490    @MediumTest
491    public void testEnableReceiver() throws Exception {
492        mPackageManager.setComponentEnabledSetting(DISABLED_RECEIVER_COMPONENTNAME,
493                                                   COMPONENT_ENABLED_STATE_DEFAULT,
494                                                   PackageManager.DONT_KILL_APP);
495
496        try {
497            mPackageManager.getReceiverInfo(DISABLED_RECEIVER_COMPONENTNAME, 0);
498            fail("Attempt to get info on disabled component should fail.");
499        } catch (PackageManager.NameNotFoundException e) {
500            // expected
501        }
502
503        mPackageManager.setComponentEnabledSetting(DISABLED_RECEIVER_COMPONENTNAME,
504                                                   COMPONENT_ENABLED_STATE_ENABLED,
505                                                   PackageManager.DONT_KILL_APP);
506        ActivityInfo activityInfo =
507              mPackageManager.getReceiverInfo(DISABLED_RECEIVER_COMPONENTNAME, 0);
508        assertNotNull(activityInfo);
509        assertFalse(activityInfo.enabled);
510    }
511
512    @MediumTest
513    public void testDisableReceiver() throws Exception {
514        mPackageManager.setComponentEnabledSetting(ENABLED_RECEIVER_COMPONENTNAME,
515                                                   COMPONENT_ENABLED_STATE_DEFAULT,
516                                                   PackageManager.DONT_KILL_APP);
517
518        ActivityInfo activityInfo =
519              mPackageManager.getReceiverInfo(ENABLED_RECEIVER_COMPONENTNAME, 0);
520        assertNotNull(activityInfo);
521        assertTrue(activityInfo.enabled);
522        mPackageManager.setComponentEnabledSetting(DISABLED_RECEIVER_COMPONENTNAME,
523                                                   COMPONENT_ENABLED_STATE_DISABLED,
524                                                   PackageManager.DONT_KILL_APP);
525        try {
526            mPackageManager.getReceiverInfo(DISABLED_RECEIVER_COMPONENTNAME, 0);
527            fail("Attempt to get info on disabled component should fail.");
528        } catch (PackageManager.NameNotFoundException e) {
529            // expected
530        }
531    }
532
533    @MediumTest
534    public void testResolveEnabledProvider() throws Exception {
535        mPackageManager.setComponentEnabledSetting(ENABLED_PROVIDER_COMPONENTNAME,
536                                                   COMPONENT_ENABLED_STATE_DEFAULT,
537                                                   PackageManager.DONT_KILL_APP);
538
539        ProviderInfo providerInfo =
540                mPackageManager.resolveContentProvider(ENABLED_PROVIDER_NAME, 0);
541        assertNotNull(providerInfo);
542        assertTrue(providerInfo.enabled);
543    }
544
545    @MediumTest
546    public void testResolveDisabledProvider() throws Exception {
547        mPackageManager.setComponentEnabledSetting(DISABLED_PROVIDER_COMPONENTNAME,
548                                                   COMPONENT_ENABLED_STATE_DEFAULT,
549                                                   PackageManager.DONT_KILL_APP);
550
551        ProviderInfo providerInfo =
552                mPackageManager.resolveContentProvider(DISABLED_PROVIDER_NAME, 0);
553        assertNull(providerInfo);
554        ProviderInfo providerInfo2 =
555                mPackageManager.resolveContentProvider(DISABLED_PROVIDER_NAME,
556                                                       GET_DISABLED_COMPONENTS);
557        assertNotNull(providerInfo2);
558        assertFalse(providerInfo2.enabled);
559    }
560
561    @MediumTest
562    public void testEnableProvider() throws Exception {
563        mPackageManager.setComponentEnabledSetting(DISABLED_PROVIDER_COMPONENTNAME,
564                                                   COMPONENT_ENABLED_STATE_DEFAULT,
565                                                   PackageManager.DONT_KILL_APP);
566        ProviderInfo providerInfo =
567                mPackageManager.resolveContentProvider(DISABLED_PROVIDER_NAME, 0);
568        assertNull(providerInfo);
569
570        mPackageManager.setComponentEnabledSetting(DISABLED_PROVIDER_COMPONENTNAME,
571                                                   COMPONENT_ENABLED_STATE_ENABLED,
572                                                   PackageManager.DONT_KILL_APP);
573        ProviderInfo providerInfo2 =
574                mPackageManager.resolveContentProvider(DISABLED_PROVIDER_NAME, 0);
575        assertNotNull(providerInfo2);
576        assertFalse(providerInfo2.enabled);
577    }
578
579    @MediumTest
580    public void testDisableProvider() throws Exception {
581        mPackageManager.setComponentEnabledSetting(ENABLED_PROVIDER_COMPONENTNAME,
582                                                   COMPONENT_ENABLED_STATE_DEFAULT,
583                                                   PackageManager.DONT_KILL_APP);
584        ProviderInfo providerInfo =
585                mPackageManager.resolveContentProvider(ENABLED_PROVIDER_NAME, 0);
586        assertNotNull(providerInfo);
587        assertTrue(providerInfo.enabled);
588
589        mPackageManager.setComponentEnabledSetting(ENABLED_PROVIDER_COMPONENTNAME,
590                                                   COMPONENT_ENABLED_STATE_DISABLED,
591                                                   PackageManager.DONT_KILL_APP);
592        ProviderInfo providerInfo2 =
593                mPackageManager.resolveContentProvider(ENABLED_PROVIDER_NAME, 0);
594        assertNull(providerInfo2);
595    }
596
597    @MediumTest
598    public void testQueryEnabledProvider() throws Exception {
599        mPackageManager.setComponentEnabledSetting(ENABLED_PROVIDER_COMPONENTNAME,
600                                                   COMPONENT_ENABLED_STATE_DEFAULT,
601                                                   PackageManager.DONT_KILL_APP);
602
603        String enabledProviderProcessName = getComponentProcessName(ENABLED_PROVIDER_NAME);
604        PackageInfo pi = mPackageManager.getPackageInfo(ENABLED_PACKAGENAME, 0);
605        List<ProviderInfo> providerInfoList =
606                mPackageManager.queryContentProviders(enabledProviderProcessName,
607                        pi.applicationInfo.uid, 0);
608        assertNotNull(providerInfoList);
609        assertEquals(1, providerInfoList.size());
610        assertEquals(ENABLED_PROVIDER_CLASSNAME,
611                     providerInfoList.get(0).name);
612    }
613
614    @MediumTest
615    public void testQueryDisabledProvider() throws Exception {
616        mPackageManager.setComponentEnabledSetting(DISABLED_PROVIDER_COMPONENTNAME,
617                                                   COMPONENT_ENABLED_STATE_DEFAULT,
618                                                   PackageManager.DONT_KILL_APP);
619
620        PackageInfo pi = mPackageManager.getPackageInfo(ENABLED_PACKAGENAME, 0);
621
622        String disabledProviderProcessName = getComponentProcessName(DISABLED_PROVIDER_NAME);
623        List<ProviderInfo> providerInfoList =
624                mPackageManager.queryContentProviders(disabledProviderProcessName,
625                        pi.applicationInfo.uid, 0);
626        assertNull(providerInfoList);
627
628
629        List<ProviderInfo> providerInfoList2 =
630                mPackageManager.queryContentProviders(disabledProviderProcessName,
631                        pi.applicationInfo.uid, GET_DISABLED_COMPONENTS);
632        assertNotNull(providerInfoList2);
633        assertEquals(1, providerInfoList2.size());
634        assertEquals(DISABLED_PROVIDER_CLASSNAME,
635                     providerInfoList2.get(0).name);
636    }
637
638    private String getComponentProcessName(String componentNameStr) {
639        ComponentInfo providerInfo =
640                mPackageManager.resolveContentProvider(componentNameStr,
641                                                       GET_DISABLED_COMPONENTS);
642        return providerInfo.processName;
643    }
644
645    public void DISABLED_testResolveEnabledActivityInDisabledApp() throws Exception {
646        mPackageManager.setApplicationEnabledSetting(DISABLED_PACKAGENAME,
647                                                     COMPONENT_ENABLED_STATE_DEFAULT,
648                                                     0);
649        mPackageManager.setComponentEnabledSetting(DISABLED_APP_ENABLED_ACTIVITY_COMPONENTNAME,
650                                                   COMPONENT_ENABLED_STATE_DEFAULT,
651                                                   PackageManager.DONT_KILL_APP);
652
653        final ResolveInfo info =
654                mPackageManager.resolveActivity(mDisabledAppEnabledActivityIntent, 0);
655        assertNull(info);
656
657        final ResolveInfo info2 = mPackageManager.resolveActivity(
658                mDisabledAppEnabledActivityIntent, GET_DISABLED_COMPONENTS);
659        assertNotNull(info2);
660        assertNotNull(info2.activityInfo);
661        assertTrue(info2.activityInfo.enabled);
662    }
663
664    public void DISABLED_testEnableApplication() throws Exception {
665        mPackageManager.setApplicationEnabledSetting(DISABLED_PACKAGENAME,
666                                                     COMPONENT_ENABLED_STATE_DEFAULT,
667                                                     0);
668        mPackageManager.setComponentEnabledSetting(DISABLED_APP_ENABLED_ACTIVITY_COMPONENTNAME,
669                                                   COMPONENT_ENABLED_STATE_DEFAULT,
670                                                   PackageManager.DONT_KILL_APP);
671
672        final ResolveInfo info =
673                mPackageManager.resolveActivity(mDisabledAppEnabledActivityIntent, 0);
674        assertNull(info);
675
676        mPackageManager.setApplicationEnabledSetting(DISABLED_PACKAGENAME,
677                                                     COMPONENT_ENABLED_STATE_ENABLED,
678                                                     0);
679        final ResolveInfo info2 = mPackageManager.resolveActivity(
680                mDisabledAppEnabledActivityIntent, 0);
681        assertNotNull(info2);
682        assertNotNull(info2.activityInfo);
683        assertTrue(info2.activityInfo.enabled);
684
685    }
686
687    public void DISABLED_testDisableApplication() throws Exception {
688        mPackageManager.setApplicationEnabledSetting(ENABLED_PACKAGENAME,
689                                                     COMPONENT_ENABLED_STATE_DEFAULT,
690                                                     0);
691        mPackageManager.setComponentEnabledSetting(ENABLED_ACTIVITY_COMPONENTNAME,
692                                                   COMPONENT_ENABLED_STATE_DEFAULT,
693                                                   PackageManager.DONT_KILL_APP);
694
695        final ResolveInfo info = mPackageManager.resolveActivity(mEnabledActivityIntent, 0);
696        assertNotNull(info);
697        assertNotNull(info.activityInfo);
698        assertTrue(info.activityInfo.enabled);
699
700        mPackageManager.setApplicationEnabledSetting(ENABLED_PACKAGENAME,
701                                                     COMPONENT_ENABLED_STATE_DISABLED,
702                                                     0);
703        final ResolveInfo info2 = mPackageManager.resolveActivity(mEnabledActivityIntent, 0);
704        assertNull(info2);
705
706        // Clean up
707        mPackageManager.setApplicationEnabledSetting(ENABLED_PACKAGENAME,
708                                                     COMPONENT_ENABLED_STATE_DEFAULT,
709                                                     0);
710
711    }
712
713    @MediumTest
714    public void testNonExplicitResolveAfterEnabling() throws Exception {
715        mPackageManager.setComponentEnabledSetting(DISABLED_ACTIVITY_COMPONENTNAME,
716                                                   COMPONENT_ENABLED_STATE_DEFAULT,
717                                                   PackageManager.DONT_KILL_APP);
718
719        Intent intent = new Intent(Intent.ACTION_MAIN, null);
720        intent.addCategory(TEST_CATEGORY);
721
722        final List<ResolveInfo> launchables =
723                mPackageManager.queryIntentActivities(intent, 0);
724
725        int numItems = launchables.size();
726        assertEquals(0, numItems);
727
728        mPackageManager.setComponentEnabledSetting(DISABLED_ACTIVITY_COMPONENTNAME,
729                                                   COMPONENT_ENABLED_STATE_ENABLED,
730                                                   PackageManager.DONT_KILL_APP);
731
732        final List<ResolveInfo> launchables2 =
733                mPackageManager.queryIntentActivities(intent, 0);
734
735        int numItems2 = launchables2.size();
736        assertEquals(1, numItems2);
737    }
738}
739