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