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