frameworks/base/core/tests/coretests/src/android/content/pm/ComponentTest.java

   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
  17 package android.content.pm;
  18
  19 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
  20 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
  21 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
  22 import static android.content.pm.PackageManager.GET_DISABLED_COMPONENTS;
  23
  24 import com.android.frameworks.coretests.enabled_app.DisabledActivity;
  25 import com.android.frameworks.coretests.enabled_app.DisabledProvider;
  26 import com.android.frameworks.coretests.enabled_app.DisabledReceiver;
  27 import com.android.frameworks.coretests.enabled_app.DisabledService;
  28 import com.android.frameworks.coretests.enabled_app.EnabledActivity;
  29 import com.android.frameworks.coretests.enabled_app.EnabledProvider;
  30 import com.android.frameworks.coretests.enabled_app.EnabledReceiver;
  31 import com.android.frameworks.coretests.enabled_app.EnabledService;
  32
  33 import android.content.ComponentName;
  34 import android.content.Intent;
  35 import android.test.AndroidTestCase;
  36 import android.test.suitebuilder.annotation.MediumTest;
  37 import android.test.suitebuilder.annotation.SmallTest;
  38
  39 import 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
  49 public 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 }