AppWidgetTest.java (revision b7c941bb3fa97aba169d73cee0bed2de8ac964bf) - OpenGrok cross reference for /aosp_15_r20/cts/tests/tests/appwidget/src/android/appwidget/cts/AppWidgetTest.java

/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.appwidget.cts;

import static android.appwidget.AppWidgetProviderInfo.WIDGET_CATEGORY_HOME_SCREEN;
import static android.appwidget.AppWidgetProviderInfo.WIDGET_CATEGORY_KEYGUARD;

import static com.google.common.truth.Truth.assertThat;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.same;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.hamcrest.MockitoHamcrest.argThat;

import android.appwidget.AppWidgetHost;
import android.appwidget.AppWidgetHostView;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProviderInfo;
import android.appwidget.cts.provider.AppWidgetProviderCallbacks;
import android.appwidget.cts.provider.AppWidgetProviderWithFeatures;
import android.appwidget.cts.provider.FirstAppWidgetProvider;
import android.appwidget.cts.provider.SecondAppWidgetProvider;
import android.appwidget.cts.service.MyAppWidgetService;
import android.appwidget.flags.Flags;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Bundle;
import android.os.Process;
import android.os.StrictMode;
import android.os.SystemClock;
import android.os.UserHandle;
import android.os.UserManager;
import android.platform.test.annotations.AppModeFull;
import android.platform.test.annotations.AppModeInstant;
import android.platform.test.annotations.RequiresFlagsEnabled;
import android.platform.test.flag.junit.CheckFlagsRule;
import android.platform.test.flag.junit.DeviceFlagsValueProvider;
import android.provider.DeviceConfig;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.widget.RemoteViews;
import android.widget.RemoteViewsService.RemoteViewsFactory;

import com.android.compatibility.common.util.ApiTest;
import com.android.compatibility.common.util.DeviceConfigStateHelper;

import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.junit.After;
import org.junit.Assume;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.IntConsumer;

public class AppWidgetTest extends AppWidgetTestCase {

    @Rule(order = 0)
    public final CheckFlagsRule checkFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();

    private static final long OPERATION_TIMEOUT = 20 * 1000; // 20 sec

    private final Object mLock = new Object();
    private final DeviceConfigStateHelper mDeviceConfigStateHelper = new DeviceConfigStateHelper(
            DeviceConfig.NAMESPACE_SYSTEMUI);

    @Before
    public void setUpDexmaker() throws Exception {
        // Workaround for dexmaker bug: https://code.google.com/p/dexmaker/issues/detail?id=2
        // Dexmaker is used by mockito.
        System.setProperty("dexmaker.dexcache", getInstrumentation()
                .getTargetContext().getCacheDir().getPath());
    }

    @After
    public void cleanUp() throws Exception {
        mDeviceConfigStateHelper.close();
    }

    @AppModeInstant(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testInstantAppsCannotProvideAppWidgets() {
        Assume.assumeTrue(getInstrumentation().getTargetContext()
                .getPackageManager().isInstantApp());
        assertNull(getFirstAppWidgetProviderInfo());
    }

    @AppModeInstant(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testInstantAppsCannotHostAppWidgets() {
        Assume.assumeTrue(getInstrumentation().getTargetContext()
                .getPackageManager().isInstantApp());
        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(getInstrumentation().getTargetContext(), 0);
        // Allocate an app widget id to bind.
        assertSame(AppWidgetManager.INVALID_APPWIDGET_ID, host.allocateAppWidgetId());
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testGetAppInstalledProvidersForCurrentUserLegacy() throws Exception {
        // By default we should get only providers for the current user.
        List<AppWidgetProviderInfo> providers = getAppWidgetManager().getInstalledProviders();

        // Make sure we have our two providers in the list.
        assertExpectedInstalledProviders(providers);
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testGetAppInstalledProvidersForCurrentUserNewCurrentProfile() throws Exception {
        // We ask only for providers for the current user.
        List<AppWidgetProviderInfo> providers = getAppWidgetManager()
                .getInstalledProvidersForProfile(Process.myUserHandle());

        // Make sure we have our two providers in the list.
        assertExpectedInstalledProviders(providers);
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testGetAppInstalledProvidersForCurrentUserNewAllProfiles() throws Exception {
        // We ask only for providers for all current user's profiles
        UserManager userManager = (UserManager) getInstrumentation()
                .getTargetContext().getSystemService(Context.USER_SERVICE);

        List<AppWidgetProviderInfo> allProviders = new ArrayList<>();

        List<UserHandle> profiles = userManager.getUserProfiles();
        final int profileCount = profiles.size();
        for (int i = 0; i < profileCount; i++) {
            UserHandle profile = profiles.get(i);
            List<AppWidgetProviderInfo> providers = getAppWidgetManager()
                    .getInstalledProvidersForProfile(profile);
            allProviders.addAll(providers);
        }

        // Make sure we have our two providers in the list.
        assertExpectedInstalledProviders(allProviders);
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testBindAppWidget() throws Exception {
        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(getInstrumentation().getTargetContext(), 0);
        host.deleteHost();
        host.startListening();

        // Allocate an app widget id to bind.
        final int appWidgetId = host.allocateAppWidgetId();

        // Grab a provider we defined to be bound.
        AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

        // Bind the widget.
        boolean widgetBound = getAppWidgetManager().bindAppWidgetIdIfAllowed(appWidgetId,
                provider.getProfile(), provider.provider, null);
        assertFalse(widgetBound);

        // Well, app do not have this permission unless explicitly granted
        // by the user. Now we will pretend for the user and grant it.
        grantBindAppWidgetPermission();

        try {
            // Bind the widget as we have a permission for that.
            widgetBound = getAppWidgetManager().bindAppWidgetIdIfAllowed(
                    appWidgetId, provider.getProfile(), provider.provider, null);
            assertTrue(widgetBound);

            // Deallocate the app widget id.
            host.deleteAppWidgetId(appWidgetId);
        } finally {
            // Clean up.
            host.deleteAppWidgetId(appWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testGetAppWidgetIdsForHost() throws Exception {
        AppWidgetHost host1 = new AppWidgetHost(getInstrumentation().getTargetContext(), 1);
        AppWidgetHost host2 = new AppWidgetHost(getInstrumentation().getTargetContext(), 2);

        host1.deleteHost();
        host2.deleteHost();

        assertTrue(Arrays.equals(host1.getAppWidgetIds(), new int[]{}));
        assertTrue(Arrays.equals(host2.getAppWidgetIds(), new int[]{}));

        int id1 = host1.allocateAppWidgetId();
        assertTrue(Arrays.equals(host1.getAppWidgetIds(), new int[]{id1}));
        assertTrue(Arrays.equals(host2.getAppWidgetIds(), new int[]{}));

        int id2 = host1.allocateAppWidgetId();
        assertTrue(Arrays.equals(host1.getAppWidgetIds(), new int[]{id1, id2}));
        assertTrue(Arrays.equals(host2.getAppWidgetIds(), new int[]{}));

        int id3 = host2.allocateAppWidgetId();
        assertTrue(Arrays.equals(host1.getAppWidgetIds(), new int[]{id1, id2}));
        assertTrue(Arrays.equals(host2.getAppWidgetIds(), new int[]{id3}));

        host1.deleteHost();
        assertTrue(Arrays.equals(host1.getAppWidgetIds(), new int[]{}));
        assertTrue(Arrays.equals(host2.getAppWidgetIds(), new int[]{id3}));

        host2.deleteHost();
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testAppWidgetProviderCallbacks() throws Exception {
        AtomicInteger invocationCounter = new AtomicInteger();

        // Set a mock to intercept provider callbacks.
        AppWidgetProviderCallbacks callbacks = createAppWidgetProviderCallbacks(invocationCounter);
        FirstAppWidgetProvider.setCallbacks(callbacks);

        int firstAppWidgetId = 0;
        int secondAppWidgetId = 0;

        final Bundle firstOptions;
        final Bundle secondOptions;

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(getInstrumentation().getTargetContext(), 0);
        host.deleteHost();
        host.startListening();

        // We want to bind a widget.
        grantBindAppWidgetPermission();
        try {
            // Allocate the first widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();

            // Grab a provider we defined to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Bind the first widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Wait for onEnabled and onUpdate
            waitForCallCount(invocationCounter, 2);

            // Update the first widget options.
            firstOptions = new Bundle();
            firstOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH, 1);
            firstOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT, 2);
            firstOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH, 3);
            firstOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT, 4);
            getAppWidgetManager().updateAppWidgetOptions(firstAppWidgetId, firstOptions);

            // Wait for onAppWidgetOptionsChanged
            waitForCallCount(invocationCounter, 3);

            // Allocate the second app widget id to bind.
            secondAppWidgetId = host.allocateAppWidgetId();

            // Bind the second widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(secondAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Wait for onUpdate
            waitForCallCount(invocationCounter, 4);

            // Update the second widget options.
            secondOptions = new Bundle();
            secondOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH, 5);
            secondOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT, 6);
            secondOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH, 7);
            secondOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT, 8);
            getAppWidgetManager().updateAppWidgetOptions(secondAppWidgetId, secondOptions);

            // Wait for onAppWidgetOptionsChanged
            waitForCallCount(invocationCounter, 5);

            // Delete the first widget.
            host.deleteAppWidgetId(firstAppWidgetId);

            // Wait for onDeleted
            waitForCallCount(invocationCounter, 6);

            // Delete the second widget.
            host.deleteAppWidgetId(secondAppWidgetId);

            // Wait for onDeleted and onDisabled
            waitForCallCount(invocationCounter, 8);

            // Make sure the provider callbacks are correct.
            InOrder inOrder = inOrder(callbacks);

            inOrder.verify(callbacks).onEnabled(any(Context.class));
            inOrder.verify(callbacks).onUpdate(any(Context.class),
                    any(AppWidgetManager.class), eq(new int[] {firstAppWidgetId}));
            inOrder.verify(callbacks).onAppWidgetOptionsChanged(any(Context.class),
                    any(AppWidgetManager.class), eq(firstAppWidgetId), argThat(
                            new OptionsMatcher(firstOptions)));
            inOrder.verify(callbacks).onUpdate(any(Context.class),
                    any(AppWidgetManager.class), eq(new int[] {secondAppWidgetId}));
            inOrder.verify(callbacks).onAppWidgetOptionsChanged(any(Context.class),
                    any(AppWidgetManager.class), eq(secondAppWidgetId), argThat(
                            new OptionsMatcher(secondOptions)));
            inOrder.verify(callbacks).onDeleted(any(Context.class),
                    argThat(new WidgetIdsMatcher(new int[]{firstAppWidgetId})));
            inOrder.verify(callbacks).onDeleted(any(Context.class),
                    argThat(new WidgetIdsMatcher(new int[]{secondAppWidgetId})));
            inOrder.verify(callbacks).onDisabled(any(Context.class));
        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteAppWidgetId(secondAppWidgetId);
            host.deleteHost();
            FirstAppWidgetProvider.setCallbacks(null);
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testTwoAppWidgetProviderCallbacks() throws Exception {
        AtomicInteger invocationCounter = new AtomicInteger();

        // Set a mock to intercept first provider callbacks.
        AppWidgetProviderCallbacks firstCallbacks = createAppWidgetProviderCallbacks(
                invocationCounter);
        FirstAppWidgetProvider.setCallbacks(firstCallbacks);

        // Set a mock to intercept second provider callbacks.
        AppWidgetProviderCallbacks secondCallbacks = createAppWidgetProviderCallbacks(
                invocationCounter);
        SecondAppWidgetProvider.setCallbacks(secondCallbacks);

        int firstAppWidgetId = 0;
        int secondAppWidgetId = 0;

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(getInstrumentation().getTargetContext(), 0);
        host.deleteHost();
        host.startListening();

        // We want to bind widgets.
        grantBindAppWidgetPermission();
        try {
            // Allocate the first widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();

            // Allocate the second widget id to bind.
            secondAppWidgetId = host.allocateAppWidgetId();

            // Grab the first provider we defined to be bound.
            AppWidgetProviderInfo firstProvider = getFirstAppWidgetProviderInfo();

            // Bind the first widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    firstProvider.getProfile(), firstProvider.provider, null);

            // Wait for onEnabled and onUpdate
            waitForCallCount(invocationCounter, 2);

            // Grab the second provider we defined to be bound.
            AppWidgetProviderInfo secondProvider = getSecondAppWidgetProviderInfo();

            // Bind the second widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(secondAppWidgetId,
                    secondProvider.getProfile(), secondProvider.provider, null);

            // Wait for onEnabled and onUpdate
            waitForCallCount(invocationCounter, 4);

            // Delete the first widget.
            host.deleteAppWidgetId(firstAppWidgetId);

            // Wait for onDeleted and onDisabled
            waitForCallCount(invocationCounter, 6);

            // Delete the second widget.
            host.deleteAppWidgetId(secondAppWidgetId);

            // Wait for onDeleted and onDisabled
            waitForCallCount(invocationCounter, 8);

            // Make sure the first provider callbacks are correct.
            InOrder firstInOrder = inOrder(firstCallbacks);
            firstInOrder.verify(firstCallbacks).onEnabled(any(Context.class));
            firstInOrder.verify(firstCallbacks).onUpdate(any(Context.class),
                    any(AppWidgetManager.class), eq(new int[]{firstAppWidgetId}));
            firstInOrder.verify(firstCallbacks).onDeleted(any(Context.class),
                    argThat(new WidgetIdsMatcher(new int[]{firstAppWidgetId})));
            firstInOrder.verify(firstCallbacks).onDisabled(any(Context.class));

            // Make sure the second provider callbacks are correct.
            InOrder secondInOrder = inOrder(secondCallbacks);
            secondInOrder.verify(secondCallbacks).onEnabled(any(Context.class));
            secondInOrder.verify(secondCallbacks).onUpdate(any(Context.class),
                    any(AppWidgetManager.class), eq(new int[]{secondAppWidgetId}));
            secondInOrder.verify(secondCallbacks).onDeleted(any(Context.class),
                    argThat(new WidgetIdsMatcher(new int[] {secondAppWidgetId})));
            secondInOrder.verify(secondCallbacks).onDisabled(any(Context.class));
        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteAppWidgetId(secondAppWidgetId);
            host.deleteHost();
            FirstAppWidgetProvider.setCallbacks(null);
            SecondAppWidgetProvider.setCallbacks(null);
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testGetAppWidgetIdsForProvider() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0);
        host.deleteHost();
        host.startListening();

        int firstAppWidgetId = 0;
        int secondAppWidgetId = 0;

        try {
            // Grab the provider we defined to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Initially we have no widgets.
            int[] widgetsIds = getAppWidgetManager().getAppWidgetIds(provider.provider);
            assertTrue(widgetsIds.length == 0);

            // Allocate the first widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();

            // Bind the first widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Allocate the second widget id to bind.
            secondAppWidgetId = host.allocateAppWidgetId();

            // Bind the second widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(secondAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Now we have two widgets,
            widgetsIds = getAppWidgetManager().getAppWidgetIds(provider.provider);
            assertTrue(Arrays.equals(widgetsIds, new int[]{firstAppWidgetId, secondAppWidgetId}));
        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteAppWidgetId(secondAppWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testGetAppWidgetInfo() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0);
        host.deleteHost();
        host.startListening();

        int appWidgetId = 0;

        try {
            // Allocate an widget id to bind.
            appWidgetId = host.allocateAppWidgetId();

            // The widget is not bound, so no info.
            AppWidgetProviderInfo foundProvider = getAppWidgetManager()
                    .getAppWidgetInfo(appWidgetId);
            assertNull(foundProvider);

            // Grab the provider we defined to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Bind the app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(appWidgetId,
                    provider.getProfile(), provider.provider, null);

            // The widget is bound, so the provider info should be there.
            foundProvider = getAppWidgetManager().getAppWidgetInfo(appWidgetId);
            assertEquals(provider.provider, foundProvider.provider);
            assertEquals(provider.getProfile(), foundProvider.getProfile());

            Context context = getInstrumentation().getTargetContext();

            // Let us make sure the provider info is sane.
            String label = foundProvider.loadLabel(context.getPackageManager());
            assertTrue(!TextUtils.isEmpty(label));

            Drawable icon = foundProvider.loadIcon(context, DisplayMetrics.DENSITY_DEFAULT);
            assertNotNull(icon);

            Drawable previewImage = foundProvider.loadPreviewImage(context, 0);
            assertNotNull(previewImage);

            assertThat(foundProvider.loadDescription(context)).isEqualTo("Widget description");

            assertThat(foundProvider.previewLayout).isEqualTo(R.layout.preview_layout);
        } finally {
            // Clean up.
            host.deleteAppWidgetId(appWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testGetAppWidgetOptions() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0);
        host.deleteHost();
        host.startListening();

        int appWidgetId = 0;

        try {
            // Grab the provider we defined to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Allocate an widget id to bind.
            appWidgetId = host.allocateAppWidgetId();

            // Initially we have no options.
            Bundle foundOptions = getAppWidgetManager().getAppWidgetOptions(appWidgetId);
            assertTrue(foundOptions.isEmpty());

            // We want to set the options when binding.
            Bundle setOptions = new Bundle();
            setOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH, 1);
            setOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT, 2);
            setOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH, 3);
            setOptions.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT, 4);

            // Bind the app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(appWidgetId,
                    provider.getProfile(), provider.provider, setOptions);

            // Make sure we get the options used when binding.
            foundOptions = getAppWidgetManager().getAppWidgetOptions(appWidgetId);
            assertTrue(equalOptions(setOptions, foundOptions));
        } finally {
            // Clean up.
            host.deleteAppWidgetId(appWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testDeleteHost() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0);
        host.deleteHost();
        host.startListening();

        int appWidgetId = 0;

        try {
            // Allocate an widget id to bind.
            appWidgetId = host.allocateAppWidgetId();

            // Grab the provider we defined to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Bind the app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(appWidgetId,
                    provider.getProfile(), provider.provider, null);

            // The widget should be there.
            int[] widgetIds = getAppWidgetManager().getAppWidgetIds(provider.provider);
            assertTrue(Arrays.equals(widgetIds, new int[]{appWidgetId}));

            // Delete the host.
            host.deleteHost();

            // The host is gone and with it the widgets.
            widgetIds = getAppWidgetManager().getAppWidgetIds(provider.provider);
            assertTrue(widgetIds.length == 0);
        } finally {
            // Clean up.
            host.deleteAppWidgetId(appWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testDeleteHosts() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        // Create the first host and start listening.
        AppWidgetHost firstHost = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0);
        firstHost.deleteHost();
        firstHost.startListening();

        // Create the second host and start listening.
        AppWidgetHost secondHost = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 1);
        secondHost.deleteHost();
        secondHost.startListening();

        int firstAppWidgetId = 0;
        int secondAppWidgetId = 0;

        try {
            // Grab the provider we defined to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Allocate the first widget id to bind.
            firstAppWidgetId = firstHost.allocateAppWidgetId();

            // Bind the first app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Allocate the second widget id to bind.
            secondAppWidgetId = secondHost.allocateAppWidgetId();

            // Bind the second app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(secondAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // The widgets should be there.
            int[] widgetIds = getAppWidgetManager().getAppWidgetIds(provider.provider);
            assertTrue(Arrays.equals(widgetIds, new int[]{firstAppWidgetId, secondAppWidgetId}));

            // Delete all hosts.
            AppWidgetHost.deleteAllHosts();

            // The hosts are gone and with it the widgets.
            widgetIds = getAppWidgetManager().getAppWidgetIds(provider.provider);
            assertTrue(widgetIds.length == 0);
        } finally {
            // Clean up.
            firstHost.deleteAppWidgetId(firstAppWidgetId);
            secondHost.deleteAppWidgetId(secondAppWidgetId);
            AppWidgetHost.deleteAllHosts();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testOnProvidersChanged() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        final AtomicInteger onProvidersChangedCallCounter = new AtomicInteger();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0) {
            @Override
            public void onProvidersChanged() {
                synchronized (mLock) {
                    onProvidersChangedCallCounter.incrementAndGet();
                    mLock.notifyAll();
                }
            }
        };
        host.deleteHost();
        host.startListening();

        int appWidgetId = 0;

        try {
            // Grab the provider we defined to be bound.
            AppWidgetProviderInfo firstLookupProvider = getFirstAppWidgetProviderInfo();

            // Allocate a widget id to bind.
            appWidgetId = host.allocateAppWidgetId();

            // Bind the first app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(appWidgetId,
                    firstLookupProvider.getProfile(), firstLookupProvider.provider, null);

            // Disable the provider we just bound to.
            PackageManager packageManager = getInstrumentation().getTargetContext()
                    .getApplicationContext().getPackageManager();
            packageManager.setComponentEnabledSetting(firstLookupProvider.provider,
                    PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
                    PackageManager.DONT_KILL_APP);

            // Wait for the package change to propagate.
            waitForCallCount(onProvidersChangedCallCounter, 1);

            // The provider should not be present anymore.
            AppWidgetProviderInfo secondLookupProvider = getFirstAppWidgetProviderInfo();
            assertNull(secondLookupProvider);

            // Enable the provider we disabled.
            packageManager.setComponentEnabledSetting(firstLookupProvider.provider,
                    PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
                    PackageManager.DONT_KILL_APP);

            // Wait for the package change to propagate.
            waitForCallCount(onProvidersChangedCallCounter, 2);
        } finally {
            // Clean up.
            host.deleteAppWidgetId(appWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testAppWidgetRemoved() throws Exception {

        // We want to bind widgets.
        grantBindAppWidgetPermission();

        final AtomicInteger onAppWidgetRemovedCounter = new AtomicInteger();
        IntConsumer callback = mock(IntConsumer.class);

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
            getInstrumentation().getTargetContext(), 0) {
            @Override
            public void onAppWidgetRemoved(int widgetId) {
                synchronized (mLock) {
                    onAppWidgetRemovedCounter.incrementAndGet();
                    mLock.notifyAll();
                    callback.accept(widgetId);
                }
            }
        };
        host.deleteHost();
        host.startListening();

        int firstAppWidgetId = 0;
        int secondAppWidgetId = 0;

        try {
            // Grab the provider we defined to be bound.
            AppWidgetProviderInfo firstProviderInfo = getFirstAppWidgetProviderInfo();
            AppWidgetProviderInfo secondProviderInfo = getSecondAppWidgetProviderInfo();

            // Allocate widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();
            secondAppWidgetId = host.allocateAppWidgetId();

            //create listeners
            MyAppWidgetHostView.OnUpdateAppWidgetListener secondAppHostViewListener =
                mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);

            // Bind the first app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                firstProviderInfo.getProfile(), firstProviderInfo.provider, null);
            getAppWidgetManager().bindAppWidgetIdIfAllowed(secondAppWidgetId,
                secondProviderInfo.getProfile(), secondProviderInfo.provider, null);

            // Disable the first widget while host is listening
            PackageManager packageManager = getInstrumentation().getTargetContext()
                .getApplicationContext().getPackageManager();
            packageManager.setComponentEnabledSetting(firstProviderInfo.provider,
                PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
                PackageManager.DONT_KILL_APP);

            waitForCallCount(onAppWidgetRemovedCounter, 1);

            // Disable the second widget while host is paused
            host.stopListening();
            packageManager.setComponentEnabledSetting(secondProviderInfo.provider,
                PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
                PackageManager.DONT_KILL_APP);


            assertEquals(onAppWidgetRemovedCounter.get(),1);
            verify(callback).accept(eq(firstAppWidgetId));

            // resume listening
            host.startListening();

            // Wait for the package change to propagate.
            waitForCallCount(onAppWidgetRemovedCounter, 2);
            verify(callback).accept(eq(secondAppWidgetId));

            // Reenable disabled items
            packageManager.setComponentEnabledSetting(secondProviderInfo.provider,
                    PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
                    PackageManager.DONT_KILL_APP);
            packageManager.setComponentEnabledSetting(firstProviderInfo.provider,
                    PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
                    PackageManager.DONT_KILL_APP);

        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteAppWidgetId(secondAppWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testUpdateAppWidgetViaComponentName() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        final AtomicInteger updateAppWidgetCallCount = new AtomicInteger();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0) {
            @Override
            protected AppWidgetHostView onCreateView(Context context, int appWidgetId,
                    AppWidgetProviderInfo appWidget) {
                return new MyAppWidgetHostView(context);
            }
        };
        host.deleteHost();
        host.startListening();

        int firstAppWidgetId = 0;
        int secondAppWidgetId = 0;

        try {
            // Grab the provider to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Allocate the first widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();

            // Bind the first app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Create the first host view.
            MyAppWidgetHostView firstHostView = (MyAppWidgetHostView) host.createView(
                    getInstrumentation().getContext(), firstAppWidgetId, provider);
            MyAppWidgetHostView.OnUpdateAppWidgetListener firstAppHostViewListener =
                    mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);
            firstHostView.setOnUpdateAppWidgetListener(firstAppHostViewListener);

            // Allocate the second widget id to bind.
            secondAppWidgetId = host.allocateAppWidgetId();

            // Bind the second app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(secondAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Create the second host view.
            MyAppWidgetHostView secondHostView = (MyAppWidgetHostView) host.createView(
                    getInstrumentation().getContext(), secondAppWidgetId, provider);
            MyAppWidgetHostView.OnUpdateAppWidgetListener secondAppHostViewListener =
                    mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);
            doAnswer(new Answer<Void>() {
                @Override
                public Void answer(InvocationOnMock invocation) throws Throwable {
                    synchronized (mLock) {
                        updateAppWidgetCallCount.incrementAndGet();
                        mLock.notifyAll();
                    }
                    return null;
                }
            }).when(secondAppHostViewListener).onUpdateAppWidget(any(RemoteViews.class));
            secondHostView.setOnUpdateAppWidgetListener(secondAppHostViewListener);

            // Update all app widgets.
            final RemoteViews content = new RemoteViews(
                    getInstrumentation().getContext().getPackageName(),
                    R.layout.second_initial_layout);
            getAppWidgetManager().updateAppWidget(provider.provider, content);

            waitForCallCount(updateAppWidgetCallCount, 1);

            // Verify the expected callbacks.
            InOrder firstInOrder = inOrder(firstAppHostViewListener);
            firstInOrder.verify(firstAppHostViewListener).onUpdateAppWidget(argThat(
                    new RemoteViewsMatcher(content.getLayoutId(),
                            provider.provider.getPackageName())));

            InOrder secondInOrder = inOrder(secondAppHostViewListener);
            secondInOrder.verify(secondAppHostViewListener).onUpdateAppWidget(argThat(
                    new RemoteViewsMatcher(content.getLayoutId(),
                            provider.provider.getPackageName())));
        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteAppWidgetId(secondAppWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testUpdateAppWidgetViaWidgetId() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        final AtomicInteger updateAppWidgetCallCount = new AtomicInteger();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0) {
            @Override
            protected AppWidgetHostView onCreateView(Context context, int appWidgetId,
                    AppWidgetProviderInfo appWidget) {
                return new MyAppWidgetHostView(context);
            }
        };
        host.deleteHost();
        host.startListening();

        int firstAppWidgetId = 0;

        try {
            // Grab the provider to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Allocate the first widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();

            // Bind the first app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Create the first host view.
            MyAppWidgetHostView hostView = (MyAppWidgetHostView) host.createView(
                    getInstrumentation().getContext(), firstAppWidgetId, provider);
            MyAppWidgetHostView.OnUpdateAppWidgetListener appHostViewListener =
                    mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);
            doAnswer(new Answer<Void>() {
                @Override
                public Void answer(InvocationOnMock invocation) throws Throwable {
                    synchronized (mLock) {
                        updateAppWidgetCallCount.incrementAndGet();
                        mLock.notifyAll();
                    }
                    return null;
                }
            }).when(appHostViewListener).onUpdateAppWidget(any(RemoteViews.class));
            hostView.setOnUpdateAppWidgetListener(appHostViewListener);

            // Update all app widgets.
            RemoteViews content = new RemoteViews(
                    getInstrumentation().getContext().getPackageName(),
                    R.layout.second_initial_layout);
            getAppWidgetManager().updateAppWidget(firstAppWidgetId, content);

            waitForCallCount(updateAppWidgetCallCount, 1);

            // Verify the expected callbacks.
            InOrder inOrder = inOrder(appHostViewListener);
            inOrder.verify(appHostViewListener).onUpdateAppWidget(argThat(
                    new RemoteViewsMatcher(content.getLayoutId(),
                            provider.provider.getPackageName())
            ));
        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testUpdateAppWidgetViaWidgetIds() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        final AtomicInteger onUpdateAppWidgetCallCount = new AtomicInteger();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0) {
            @Override
            protected AppWidgetHostView onCreateView(Context context, int appWidgetId,
                    AppWidgetProviderInfo appWidget) {
                return new MyAppWidgetHostView(context);
            }
        };
        host.deleteHost();
        host.startListening();

        int firstAppWidgetId = 0;
        int secondAppWidgetId = 0;

        try {
            // Grab the provider to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Allocate the first widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();

            // Bind the first app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Create the first host view.
            MyAppWidgetHostView firstHostView = (MyAppWidgetHostView) host.createView(
                    getInstrumentation().getContext(), firstAppWidgetId, provider);
            MyAppWidgetHostView.OnUpdateAppWidgetListener firstAppHostViewListener =
                    mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);
            firstHostView.setOnUpdateAppWidgetListener(firstAppHostViewListener);

            // Allocate the second widget id to bind.
            secondAppWidgetId = host.allocateAppWidgetId();

            // Bind the second app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(secondAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Create the second host view.
            MyAppWidgetHostView secondHostView = (MyAppWidgetHostView) host.createView(
                    getInstrumentation().getContext(), secondAppWidgetId, provider);
            MyAppWidgetHostView.OnUpdateAppWidgetListener secondAppHostViewListener =
                    mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);
            doAnswer(new Answer<Void>() {
                @Override
                public Void answer(InvocationOnMock invocation) throws Throwable {
                    synchronized (mLock) {
                        onUpdateAppWidgetCallCount.incrementAndGet();
                        mLock.notifyAll();
                    }
                    return null;
                }
            }).when(secondAppHostViewListener).onUpdateAppWidget(any(RemoteViews.class));
            secondHostView.setOnUpdateAppWidgetListener(secondAppHostViewListener);

            // Update all app widgets.
            RemoteViews content = new RemoteViews(
                    getInstrumentation().getContext().getPackageName(),
                    R.layout.second_initial_layout);
            getAppWidgetManager().updateAppWidget(new int[] {firstAppWidgetId,
                    secondAppWidgetId}, content);

            waitForCallCount(onUpdateAppWidgetCallCount, 1);

            // Verify the expected callbacks.
            InOrder firstInOrder = inOrder(firstAppHostViewListener);
            firstInOrder.verify(firstAppHostViewListener).onUpdateAppWidget(
                    argThat(new RemoteViewsMatcher(content.getLayoutId(),
                            provider.provider.getPackageName())));

            InOrder secondInOrder = inOrder(secondAppHostViewListener);
            secondInOrder.verify(secondAppHostViewListener).onUpdateAppWidget(
                    argThat(new RemoteViewsMatcher(content.getLayoutId(),
                            provider.provider.getPackageName()))
            );
        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteAppWidgetId(secondAppWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testPartiallyUpdateAppWidgetViaWidgetId() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        final AtomicInteger updateAppWidgetCallCount = new AtomicInteger();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0) {
            @Override
            protected AppWidgetHostView onCreateView(Context context, int appWidgetId,
                    AppWidgetProviderInfo appWidget) {
                return new MyAppWidgetHostView(context);
            }
        };
        host.deleteHost();
        host.startListening();

        int firstAppWidgetId = 0;

        try {
            // Grab the provider to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Allocate the first widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();

            // Bind the first app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Create the first host view.
            MyAppWidgetHostView hostView = (MyAppWidgetHostView) host.createView(
                    getInstrumentation().getContext(), firstAppWidgetId, provider);
            MyAppWidgetHostView.OnUpdateAppWidgetListener appHostViewListener =
                    mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);
            doAnswer(new Answer<Void>() {
                @Override
                public Void answer(InvocationOnMock invocation) throws Throwable {
                    synchronized (mLock) {
                        updateAppWidgetCallCount.incrementAndGet();
                        mLock.notifyAll();
                    }
                    return null;
                }
            }).when(appHostViewListener).onUpdateAppWidget(any(RemoteViews.class));
            hostView.setOnUpdateAppWidgetListener(appHostViewListener);

            // Set the content for all app widgets.
            RemoteViews content = new RemoteViews(
                    getInstrumentation().getContext().getPackageName(),
                    R.layout.first_initial_layout);
            getAppWidgetManager().updateAppWidget(firstAppWidgetId, content);

            waitForCallCount(updateAppWidgetCallCount, 1);

            // Partially update the content for all app widgets (pretend we changed something).
            getAppWidgetManager().partiallyUpdateAppWidget(firstAppWidgetId, content);

            waitForCallCount(updateAppWidgetCallCount, 2);

            // Verify the expected callbacks.
            InOrder inOrder = inOrder(appHostViewListener);
            inOrder.verify(appHostViewListener, times(2)).onUpdateAppWidget(
                    argThat(new RemoteViewsMatcher(content.getLayoutId(),
                            provider.provider.getPackageName())));
        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testPartiallyUpdateAppWidgetViaWidgetIds() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        final AtomicInteger firstAppWidgetCallCounter = new AtomicInteger();
        final AtomicInteger secondAppWidgetCallCounter = new AtomicInteger();

        // Create a host and start listening.
        AppWidgetHost host = new AppWidgetHost(
                getInstrumentation().getTargetContext(), 0) {
            @Override
            protected AppWidgetHostView onCreateView(Context context, int appWidgetId,
                    AppWidgetProviderInfo appWidget) {
                return new MyAppWidgetHostView(context);
            }
        };
        host.deleteHost();
        host.startListening();

        int firstAppWidgetId = 0;
        int secondAppWidgetId = 0;

        try {
            // Grab the provider to be bound.
            AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Allocate the first widget id to bind.
            firstAppWidgetId = host.allocateAppWidgetId();

            // Bind the first app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(firstAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Create the first host view.
            MyAppWidgetHostView firstHostView = (MyAppWidgetHostView) host.createView(
                    getInstrumentation().getContext(), firstAppWidgetId, provider);
            MyAppWidgetHostView.OnUpdateAppWidgetListener firstAppHostViewListener =
                    mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);
            doAnswer(new Answer<Void>() {
                @Override
                public Void answer(InvocationOnMock invocation) throws Throwable {
                    synchronized (mLock) {
                        firstAppWidgetCallCounter.incrementAndGet();
                        mLock.notifyAll();
                    }
                    return null;
                }
            }).when(firstAppHostViewListener).onUpdateAppWidget(any(RemoteViews.class));
            firstHostView.setOnUpdateAppWidgetListener(firstAppHostViewListener);

            // Allocate the second widget id to bind.
            secondAppWidgetId = host.allocateAppWidgetId();

            // Bind the second app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(secondAppWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Create the second host view.
            MyAppWidgetHostView secondHostView = (MyAppWidgetHostView) host.createView(
                    getInstrumentation().getContext(), secondAppWidgetId, provider);
            MyAppWidgetHostView.OnUpdateAppWidgetListener secondAppHostViewListener =
                    mock(MyAppWidgetHostView.OnUpdateAppWidgetListener.class);
            doAnswer(new Answer<Void>() {
                @Override
                public Void answer(InvocationOnMock invocation) throws Throwable {
                    synchronized (mLock) {
                        secondAppWidgetCallCounter.incrementAndGet();
                        mLock.notifyAll();
                    }
                    return null;
                }
            }).when(secondAppHostViewListener).onUpdateAppWidget(any(RemoteViews.class));
            secondHostView.setOnUpdateAppWidgetListener(secondAppHostViewListener);

            // Set the content for all app widgets.
            RemoteViews content = new RemoteViews(
                    getInstrumentation().getContext().getPackageName(),
                    R.layout.first_initial_layout);
            getAppWidgetManager().updateAppWidget(new int[]{firstAppWidgetId,
                    secondAppWidgetId}, content);

            waitForCallCount(firstAppWidgetCallCounter, 1);
            waitForCallCount(secondAppWidgetCallCounter, 1);

            // Partially update the content for all app widgets (pretend we changed something).
            getAppWidgetManager().partiallyUpdateAppWidget(new int[] {firstAppWidgetId,
                    secondAppWidgetId}, content);

            waitForCallCount(firstAppWidgetCallCounter, 2);
            waitForCallCount(secondAppWidgetCallCounter, 2);

            // Verify the expected callbacks.
            InOrder firstInOrder = inOrder(firstAppHostViewListener);
            firstInOrder.verify(firstAppHostViewListener, times(2)).onUpdateAppWidget(
                    argThat(new RemoteViewsMatcher(content.getLayoutId(),
                            provider.provider.getPackageName())));

            InOrder secondInOrder = inOrder(secondAppHostViewListener);
            secondInOrder.verify(secondAppHostViewListener, times(2)).onUpdateAppWidget(
                    argThat(new RemoteViewsMatcher(content.getLayoutId(),
                            provider.provider.getPackageName())));
        } finally {
            // Clean up.
            host.deleteAppWidgetId(firstAppWidgetId);
            host.deleteAppWidgetId(secondAppWidgetId);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @Ignore("b/355285596")
    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testCollectionWidgets() throws Exception {
        // We want to bind widgets.
        grantBindAppWidgetPermission();

        final AtomicInteger invocationCounter = new AtomicInteger();
        final Context context = getInstrumentation().getTargetContext();

        // Create a host and start listening.
        final AppWidgetHost host = new AppWidgetHost(context, 0);
        host.deleteHost();
        host.startListening();

        final int appWidgetId;

        try {
            // Configure the provider behavior.
            AppWidgetProviderCallbacks callbacks = createAppWidgetProviderCallbacks(
                    invocationCounter);
            doAnswer(new Answer<Void>() {
                @Override
                public Void answer(InvocationOnMock invocation) throws Throwable {
                    final int appWidgetId = ((int[]) invocation.getArguments()[2])[0];

                    Intent intent = new Intent(context, MyAppWidgetService.class);
                    intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
                    intent.setData(Uri.parse(intent.toUri(Intent.URI_INTENT_SCHEME)));

                    RemoteViews removeViews = new RemoteViews(context.getPackageName(),
                            R.layout.collection_widget_layout);
                    removeViews.setRemoteAdapter(R.id.stack_view, intent);

                    getAppWidgetManager().updateAppWidget(appWidgetId, removeViews);

                    synchronized (mLock) {
                        invocationCounter.incrementAndGet();
                        mLock.notifyAll();
                    }

                    return null;
                }
            }).when(callbacks).onUpdate(any(Context.class), any(AppWidgetManager.class),
                    any(int[].class));
            FirstAppWidgetProvider.setCallbacks(callbacks);

            // Grab the provider to be bound.
            final AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();

            // Allocate a widget id to bind.
            appWidgetId = host.allocateAppWidgetId();

            // Bind the app widget.
            getAppWidgetManager().bindAppWidgetIdIfAllowed(appWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Wait for onEnabled and onUpdate
            waitForCallCount(invocationCounter, 2);

            // Configure the app widget service behavior.
            RemoteViewsFactory factory = mock(RemoteViewsFactory.class);
            doAnswer(new Answer<Integer>() {
                @Override
                public Integer answer(InvocationOnMock invocation) throws Throwable {
                    return 1;
                }
            }).when(factory).getCount();
            doAnswer(new Answer<RemoteViews>() {
                @Override
                public RemoteViews answer(InvocationOnMock invocation) throws Throwable {
                    RemoteViews remoteViews = new RemoteViews(context.getPackageName(),
                            R.layout.collection_widget_item_layout);
                    remoteViews.setTextViewText(R.id.text_view, context.getText(R.string.foo));
                    synchronized (mLock) {
                        invocationCounter.incrementAndGet();
                    }
                    return remoteViews;
                }
            }).when(factory).getViewAt(any(int.class));
            doAnswer(new Answer<Integer>() {
                @Override
                public Integer answer(InvocationOnMock invocation) throws Throwable {
                    return 1;
                }
            }).when(factory).getViewTypeCount();
            MyAppWidgetService.setFactory(factory);

            getInstrumentation().runOnMainSync(new Runnable() {
                @Override
                public void run() {
                    host.createView(context, appWidgetId, provider);
                }
            });

            // Wait for the interactions to occur.
            waitForCallCount(invocationCounter, 3);

            // Verify the interactions.
            verify(factory, atLeastOnce()).hasStableIds();
            verify(factory, atLeastOnce()).getViewTypeCount();
            verify(factory, atLeastOnce()).getCount();
            verify(factory, atLeastOnce()).getLoadingView();
            verify(factory, atLeastOnce()).getViewAt(same(0));
        } finally {
            // Clean up.
            FirstAppWidgetProvider.setCallbacks(null);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testWidgetFeaturesParsed() throws Exception {
        assertEquals(0, getFirstAppWidgetProviderInfo().widgetFeatures);
        String packageName = getInstrumentation().getTargetContext().getPackageName();

        assertEquals(AppWidgetProviderInfo.WIDGET_FEATURE_RECONFIGURABLE,
                getProviderInfo(new ComponentName(packageName,
                AppWidgetProviderWithFeatures.Provider1.class.getName())).widgetFeatures);
        assertEquals(AppWidgetProviderInfo.WIDGET_FEATURE_HIDE_FROM_PICKER,
                getProviderInfo(new ComponentName(packageName,
                        AppWidgetProviderWithFeatures.Provider2.class.getName())).widgetFeatures);
        assertEquals(AppWidgetProviderInfo.WIDGET_FEATURE_RECONFIGURABLE
                | AppWidgetProviderInfo.WIDGET_FEATURE_HIDE_FROM_PICKER,
                getProviderInfo(new ComponentName(packageName,
                        AppWidgetProviderWithFeatures.Provider3.class.getName())).widgetFeatures);
    }


    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @Test
    public void testAppWidgetGetActivityInfo() {
        AppWidgetProviderInfo info = getFirstAppWidgetProviderInfo();
        assertNotNull(info.getActivityInfo());
        assertEquals(info.provider.getClassName(), info.getActivityInfo().name);
        assertEquals(info.provider.getPackageName(), info.getActivityInfo().packageName);
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @RequiresFlagsEnabled(Flags.FLAG_GENERATED_PREVIEWS)
    @ApiTest(apis = {
            "android.appwidget.AppWidgetManager#setWidgetPreview",
            "android.appwidget.AppWidgetManager#getWidgetPreview",
            "android.appwidget.AppWidgetManager#removeWidgetPreview",
            "android.appwidget.AppWidgetProviderInfo#generatedPreviewCategories",
    })
    @Test
    public void testSetGeneratedPreview() {
        // AppWidgetHost is used to wait until provider change notification is sent.
        final Context context = getInstrumentation().getTargetContext();
        final AppWidgetHostWithLatch host = new AppWidgetHostWithLatch(context, 0);
        host.deleteHost();
        host.startListening();

        try {
            // Disable setWidgetPreview rate limit for tests
            setGeneratedPreviewRateLimit(/* resetIntervalMs= */ 0,
                    /* maxCallsPerInterval */ Integer.MAX_VALUE);

            final ComponentName provider = getFirstWidgetComponent();
            final AppWidgetProviderInfo initialInfo = getFirstAppWidgetProviderInfo();

            // Clear providers and verify initial state
            if (initialInfo.generatedPreviewCategories != 0) {
                host.latch = new CountDownLatch(1);
                getAppWidgetManager().removeWidgetPreview(provider,
                        initialInfo.generatedPreviewCategories);
                host.latch.await();

                final AppWidgetProviderInfo info = getFirstAppWidgetProviderInfo();
                assertThat(info.generatedPreviewCategories).isEqualTo(0);
                assertThat(getAppWidgetManager().getWidgetPreview(info.provider,
                        info.getProfile(), WIDGET_CATEGORY_HOME_SCREEN)).isNull();
                assertThat(getAppWidgetManager().getWidgetPreview(info.provider,
                        info.getProfile(), WIDGET_CATEGORY_KEYGUARD)).isNull();
            }

            final RemoteViews whiteLayout = new RemoteViews(context.getPackageName(),
                    R.layout.simple_white_layout);
            final RemoteViews blackLayout = new RemoteViews(context.getPackageName(),
                    R.layout.simple_black_layout);

            host.latch = new CountDownLatch(2);
            assertThat(getAppWidgetManager().setWidgetPreview(provider, WIDGET_CATEGORY_HOME_SCREEN,
                    whiteLayout)).isTrue();
            assertThat(getAppWidgetManager().setWidgetPreview(provider, WIDGET_CATEGORY_KEYGUARD,
                    blackLayout)).isTrue();
            host.latch.await();

            final AppWidgetProviderInfo info = getFirstAppWidgetProviderInfo();
            assertThat(info.generatedPreviewCategories).isEqualTo(
                    WIDGET_CATEGORY_HOME_SCREEN | WIDGET_CATEGORY_KEYGUARD);
            final RemoteViews homePreview = getAppWidgetManager().getWidgetPreview(info.provider,
                    info.getProfile(), WIDGET_CATEGORY_HOME_SCREEN);
            assertThat(homePreview).isNotNull();
            final RemoteViews keyguardPreview = getAppWidgetManager().getWidgetPreview(
                    info.provider, info.getProfile(), WIDGET_CATEGORY_KEYGUARD);
            assertThat(keyguardPreview).isNotNull();

            assertThat(homePreview.getLayoutId()).isEqualTo(whiteLayout.getLayoutId());
            assertThat(keyguardPreview.getLayoutId()).isEqualTo(blackLayout.getLayoutId());

            // Update previews for homescreen
            host.latch = new CountDownLatch(1);
            assertThat(getAppWidgetManager().setWidgetPreview(provider, WIDGET_CATEGORY_HOME_SCREEN,
                    blackLayout)).isTrue();
            host.latch.await();

            final RemoteViews updatedPreview = getAppWidgetManager().getWidgetPreview(info.provider,
                    info.getProfile(), WIDGET_CATEGORY_HOME_SCREEN);
            assertThat(updatedPreview).isNotNull();
            assertThat(updatedPreview.getLayoutId()).isEqualTo(blackLayout.getLayoutId());

            // remove previews
            host.latch = new CountDownLatch(1);
            getAppWidgetManager().removeWidgetPreview(provider,
                    WIDGET_CATEGORY_HOME_SCREEN | WIDGET_CATEGORY_KEYGUARD);
            host.latch.await();

            final AppWidgetProviderInfo newInfo = getFirstAppWidgetProviderInfo();
            assertThat(newInfo.generatedPreviewCategories).isEqualTo(0);
            assertThat(
                    getAppWidgetManager().getWidgetPreview(newInfo.provider, newInfo.getProfile(),
                            WIDGET_CATEGORY_HOME_SCREEN)).isNull();
            assertThat(
                    getAppWidgetManager().getWidgetPreview(newInfo.provider, newInfo.getProfile(),
                            WIDGET_CATEGORY_KEYGUARD)).isNull();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            host.deleteHost();
        }
    }

    @AppModeFull(reason = "Instant apps cannot provide or host app widgets")
    @RequiresFlagsEnabled(Flags.FLAG_GENERATED_PREVIEWS)
    @ApiTest(apis = {
            "android.appwidget.AppWidgetManager#setWidgetPreview",
            "android.appwidget.AppWidgetManager#removeWidgetPreview",
    })
    @Test
    public void testGeneratedPreviewRateLimiting() {
        // Set rate limit to 1 per 5 seconds.
        final long resetIntervalMs = Duration.ofSeconds(5).toMillis();
        setGeneratedPreviewRateLimit(resetIntervalMs, /* maxCallsPerInterval= */ 1);

        // Disable and reenable provider to ensure provider's API call count is reset.
        final Context context = getInstrumentation().getTargetContext();
        final ComponentName provider = getFirstWidgetComponent();
        context.getPackageManager().setComponentEnabledSetting(provider,
                PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
                /* flags= */ PackageManager.SYNCHRONOUS | PackageManager.DONT_KILL_APP);
        context.getPackageManager().setComponentEnabledSetting(provider,
                PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
                /* flags= */ PackageManager.SYNCHRONOUS | PackageManager.DONT_KILL_APP);

        final RemoteViews whiteLayout = new RemoteViews(context.getPackageName(),
                R.layout.simple_white_layout);
        assertThat(getAppWidgetManager().setWidgetPreview(provider, WIDGET_CATEGORY_HOME_SCREEN,
                whiteLayout)).isTrue();
        assertThat(getAppWidgetManager().setWidgetPreview(provider, WIDGET_CATEGORY_HOME_SCREEN,
                whiteLayout)).isFalse();
        try {
            Thread.sleep(resetIntervalMs);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        assertThat(getAppWidgetManager().setWidgetPreview(provider, WIDGET_CATEGORY_HOME_SCREEN,
                whiteLayout)).isTrue();
        getAppWidgetManager().removeWidgetPreview(provider, WIDGET_CATEGORY_HOME_SCREEN);
    }

    @RequiresFlagsEnabled({Flags.FLAG_CHECK_REMOTE_VIEWS_URI_PERMISSION})
    @Test
    public void testCheckRemoteViewsUri() throws Exception {
        final Context context = getInstrumentation().getTargetContext();

        final AppWidgetHost host = new AppWidgetHost(context, 0);
        // Delete host to clear up any old ones.
        host.deleteHost();
        host.startListening();

        final int myUser = UserHandle.myUserId();
        int targetUser;
        if (UserManager.isHeadlessSystemUserMode()) {
            if (myUser == 10) {
                targetUser = 11;
            } else {
                targetUser = 10;
            }
        } else {
            if (myUser == 0) {
                targetUser = 10;
            } else {
                targetUser = 0;
            }
        }
        final Uri invalidContentUri = Uri.parse(
                "content://" + targetUser + "@android.appwidget.cts/foobar.png");
        final Uri validUri = Uri.parse(
                "content://" + myUser + "@android.appwidget.cts/foobar.png");
        final Uri resourceUri = Uri.parse("android.resource://android/drawable/foobar");
        final Uri fileUri = Uri.parse("file:///data/media");

        final int appWidgetId;
        try {
            // Configure the provider behavior.
            final AtomicInteger invocationCounter = new AtomicInteger();
            AppWidgetProviderCallbacks callbacks = createAppWidgetProviderCallbacks(
                    invocationCounter);
            doAnswer(new Answer<Void>() {
                @Override
                public Void answer(InvocationOnMock invocation) throws Throwable {
                    final int appWidgetId = ((int[]) invocation.getArguments()[2])[0];

                    // Provider should not be able to use content URI for package in another user.
                    RemoteViews invalidRemoteViews = new RemoteViews(context.getPackageName(),
                            R.layout.image_view);
                    invalidRemoteViews.setImageViewUri(R.id.hello, invalidContentUri);
                    assertThrows(SecurityException.class, () -> {
                        getAppWidgetManager().updateAppWidget(appWidgetId, invalidRemoteViews);
                    });

                    // Content URI for own package should not throw.
                    RemoteViews contentUriViews = new RemoteViews(context.getPackageName(),
                            R.layout.image_view);
                    contentUriViews.setImageViewUri(R.id.hello, validUri);
                    getAppWidgetManager().updateAppWidget(appWidgetId, contentUriViews);

                    // Resource URI should not throw.
                    RemoteViews resourceUriViews = new RemoteViews(context.getPackageName(),
                            R.layout.image_view);
                    resourceUriViews.setImageViewUri(R.id.hello, resourceUri);
                    getAppWidgetManager().updateAppWidget(appWidgetId, resourceUriViews);

                    // File URI should throw.
                    RemoteViews fileUriViews = new RemoteViews(context.getPackageName(),
                            R.layout.image_view);
                    // Disable StrictMode temporarily so setImageViewUri will not throw with file
                    // URI.
                    final StrictMode.VmPolicy oldPolicy = StrictMode.getVmPolicy();
                    StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().build());
                    try {
                        fileUriViews.setImageViewUri(R.id.hello, fileUri);
                    } finally {
                        StrictMode.setVmPolicy(oldPolicy);
                    }
                    assertThrows(SecurityException.class, () -> {
                        getAppWidgetManager().updateAppWidget(appWidgetId, fileUriViews);
                    });

                    synchronized (mLock) {
                        invocationCounter.incrementAndGet();
                        mLock.notifyAll();
                    }
                    return null;
                }
            }).when(callbacks).onUpdate(any(Context.class), any(AppWidgetManager.class),
                    any(int[].class));
            FirstAppWidgetProvider.setCallbacks(callbacks);

            // Bind an instance of the widget
            grantBindAppWidgetPermission();
            final AppWidgetProviderInfo provider = getFirstAppWidgetProviderInfo();
            appWidgetId = host.allocateAppWidgetId();
            getAppWidgetManager().bindAppWidgetIdIfAllowed(appWidgetId,
                    provider.getProfile(), provider.provider, null);

            // Wait for onEnabled and onUpdate
            waitForCallCount(invocationCounter, 2);

        } finally {
            FirstAppWidgetProvider.setCallbacks(null);
            host.deleteHost();
            revokeBindAppWidgetPermission();
        }
    }

    private void setGeneratedPreviewRateLimit(long resetIntervalMs, int maxCallsPerInterval) {
        final DeviceConfig.Properties props = new DeviceConfig.Properties.Builder(
                DeviceConfig.NAMESPACE_SYSTEMUI)
                .setLong("generated_preview_api_reset_interval_ms", resetIntervalMs)
                .setInt("generated_preview_api_max_calls_per_interval", maxCallsPerInterval)
                .build();
        mDeviceConfigStateHelper.set(props);
    }

    private void waitForCallCount(AtomicInteger counter, int expectedCount) {
        synchronized (mLock) {
            final long startTimeMillis = SystemClock.uptimeMillis();
            while (counter.get() < expectedCount) {
                final long elapsedTimeMillis = SystemClock.uptimeMillis() - startTimeMillis;
                final long remainingTimeMillis = OPERATION_TIMEOUT - elapsedTimeMillis;
                if (remainingTimeMillis <= 0) {
                    fail("Did not get expected call");
                }
                try {
                    mLock.wait(remainingTimeMillis);
                } catch (InterruptedException ie) {
                        /* ignore */
                }
            }
        }
    }

    @SuppressWarnings("deprecation")
    private void assertExpectedInstalledProviders(List<AppWidgetProviderInfo> providers) {
        boolean[] verifiedWidgets = verifyInstalledProviders(providers);
        assertTrue(verifiedWidgets[0]);
        assertTrue(verifiedWidgets[1]);
    }

    private AppWidgetProviderInfo getFirstAppWidgetProviderInfo() {
        return getProviderInfo(getFirstWidgetComponent());
    }

    private AppWidgetProviderInfo getSecondAppWidgetProviderInfo() {
        return getProviderInfo(getSecondWidgetComponent());
    }

    private AppWidgetProviderCallbacks createAppWidgetProviderCallbacks(
            final AtomicInteger callCounter) {
        // Set a mock to intercept provider callbacks.
        AppWidgetProviderCallbacks callbacks = mock(AppWidgetProviderCallbacks.class);

        // onEnabled
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                synchronized (mLock) {
                    callCounter.incrementAndGet();
                    mLock.notifyAll();
                }
                return null;
            }
        }).when(callbacks).onEnabled(any(Context.class));

        // onUpdate
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                synchronized (mLock) {
                    callCounter.incrementAndGet();
                    mLock.notifyAll();
                }
                return null;
            }
        }).when(callbacks).onUpdate(any(Context.class), any(AppWidgetManager.class),
                any(int[].class));

        // onAppWidgetOptionsChanged
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                synchronized (mLock) {
                    callCounter.incrementAndGet();
                    mLock.notifyAll();
                }
                return null;
            }
        }).when(callbacks).onAppWidgetOptionsChanged(any(Context.class),
                any(AppWidgetManager.class), any(int.class), any(Bundle.class));

        // onDeleted
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                synchronized (mLock) {
                    callCounter.incrementAndGet();
                    mLock.notifyAll();
                }
                return null;
            }
        }).when(callbacks).onDeleted(any(Context.class), any(int[].class));

        // onDisabled
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                synchronized (mLock) {
                    callCounter.incrementAndGet();
                    mLock.notifyAll();
                }
                return null;
            }
        }).when(callbacks).onDisabled(any(Context.class));

        // onRestored
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                synchronized (mLock) {
                    callCounter.incrementAndGet();
                    mLock.notifyAll();
                }
                return null;
            }
        }).when(callbacks).onRestored(any(Context.class), any(int[].class),
                any(int[].class));

        return callbacks;
    }

    private static boolean equalOptions(Bundle first, Bundle second) {
        return first.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH)
                       == second.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH)
                && first.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT)
                       == second.getInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT)
                && first.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH)
                       == second.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH)
                && first.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT)
                       == second.getInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT);
    }

    private static final class OptionsMatcher extends BaseMatcher<Bundle> {
        private Bundle mOptions;

        public OptionsMatcher(Bundle options) {
            mOptions = options;
        }

        @Override
        public boolean matches(Object item) {
            Bundle options = (Bundle) item;
            return equalOptions(mOptions, options);
        }

        @Override
        public void describeTo(Description description) {
            /* do nothing */
        }
    }

    private static final class WidgetIdsMatcher extends BaseMatcher<int[]> {
        private final int[] mWidgetIds;

        public WidgetIdsMatcher(int[] widgetIds) {
            mWidgetIds = widgetIds;
        }

        @Override
        public boolean matches(Object item) {
            final int[] widgetIds = (int[]) item;
            return Arrays.equals(widgetIds, mWidgetIds);
        }

        @Override
        public void describeTo(Description description) {
            /* do nothing */
        }
    }

    private static final class RemoteViewsMatcher extends BaseMatcher<RemoteViews> {
        private final int mLayoutId;
        private final String mPackageName;

        public RemoteViewsMatcher(int layoutId, String packageName) {
            mLayoutId = layoutId;
            mPackageName = packageName;
        }

        @Override
        public boolean matches(Object item) {
            final RemoteViews remoteViews = (RemoteViews) item;
            return remoteViews != null && remoteViews.getLayoutId() == mLayoutId
                    && remoteViews.getPackage().equals(mPackageName);
        }

        @Override
        public void describeTo(Description description) {
            /* do nothing */
        }
    }

    private static class MyAppWidgetHostView extends AppWidgetHostView {
        private OnUpdateAppWidgetListener mOnUpdateAppWidgetListener;

        public interface OnUpdateAppWidgetListener {
            public void onUpdateAppWidget(RemoteViews remoteViews);
        }

        private MyAppWidgetHostView(Context context) {
            super(context);
        }

        public void setOnUpdateAppWidgetListener(OnUpdateAppWidgetListener listener) {
            mOnUpdateAppWidgetListener = listener;
        }

        @Override
        public void updateAppWidget(RemoteViews remoteViews) {
            super.updateAppWidget(remoteViews);
            if (mOnUpdateAppWidgetListener != null) {
                mOnUpdateAppWidgetListener.onUpdateAppWidget(remoteViews);
            }
        }
    }

    private static class AppWidgetHostWithLatch extends AppWidgetHost {
        CountDownLatch latch = null;

        AppWidgetHostWithLatch(Context context, int hostId) {
            super(context, hostId);
        }

        @Override
        protected void onProvidersChanged() {
            super.onProvidersChanged();
            if (latch != null) {
                latch.countDown();
            }
        }
    }
}