path: root/tests/src/com/android/providers/contacts/ContactDirectoryManagerTest.java

/*
 * Copyright (C) 2010 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 com.android.providers.contacts;

import static android.content.pm.Flags.FLAG_STAY_STOPPED;

import android.accounts.Account;
import android.content.ContentValues;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.ProviderInfo;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.net.Uri;
import android.os.Bundle;
import android.platform.test.annotations.RequiresFlagsEnabled;
import android.platform.test.flag.junit.CheckFlagsRule;
import android.platform.test.flag.junit.DeviceFlagsValueProvider;
import android.provider.ContactsContract;
import android.provider.ContactsContract.AggregationExceptions;
import android.provider.ContactsContract.Contacts;
import android.provider.ContactsContract.Directory;
import android.provider.ContactsContract.RawContacts;
import android.test.mock.MockContentProvider;
import android.util.Log;

import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;

import com.android.providers.contacts.ContactsDatabaseHelper.AggregationExceptionColumns;

import com.google.android.collect.Lists;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.Arrays;
import java.util.Set;

/**
 * Unit tests for {@link ContactDirectoryManager}. Run the test like this:
 *
    adb shell am instrument -e class com.android.providers.contacts.ContactDirectoryManagerTest \
        -w com.android.providers.contacts.tests/android.test.InstrumentationTestRunner
 *
 */
@RunWith(AndroidJUnit4.class)
public class ContactDirectoryManagerTest extends BaseContactsProvider2Test {

    @Rule
    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
    private static final String TAG = "ContactDirectoryManagerTest";

    private ContactsMockPackageManager mPackageManager;

    private ContactsProvider2 mProvider;

    private ContactDirectoryManager mDirectoryManager;

    public static class MockContactDirectoryProvider extends MockContentProvider {

        private String mAuthority;

        private MatrixCursor mResponse;

        @Override
        public void attachInfoForTesting(Context context, ProviderInfo info) {
            mAuthority = info.authority;
        }

        public MatrixCursor createResponseCursor() {
            mResponse = new MatrixCursor(
                    new String[] { Directory.ACCOUNT_NAME, Directory.ACCOUNT_TYPE,
                            Directory.DISPLAY_NAME, Directory.TYPE_RESOURCE_ID,
                            Directory.EXPORT_SUPPORT, Directory.SHORTCUT_SUPPORT,
                            Directory.PHOTO_SUPPORT });

            return mResponse;
        }

        @Override
        public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
                String sortOrder) {

            if (uri.toString().equals("content://" + mAuthority + "/directories")) {
                // Should tolerate multiple queries.
                mResponse.moveToPosition(-1);
                return mResponse;
            } else if (uri.toString().startsWith("content://" + mAuthority + "/contacts")) {
                MatrixCursor cursor = new MatrixCursor(
                        new String[] { "projection", "selection", "selectionArgs", "sortOrder",
                                "accountName", "accountType"});
                cursor.addRow(new Object[] {
                    Lists.newArrayList(projection).toString(),
                    selection,
                    Lists.newArrayList(selectionArgs).toString(),
                    sortOrder,
                    uri.getQueryParameter(RawContacts.ACCOUNT_NAME),
                    uri.getQueryParameter(RawContacts.ACCOUNT_TYPE),
                });
                return cursor;
            } else if (uri.toString().startsWith(
                    "content://" + mAuthority + "/aggregation_exceptions")) {
                return new MatrixCursor(projection);
            }

            fail("Unexpected uri: " + uri);
            return null;
        }
    }

    @Before
    @Override
    public void setUp() throws Exception {

        super.setUp();

        mProvider = (ContactsProvider2) getProvider();
        mDirectoryManager = mProvider.getContactDirectoryManagerForTest();

        mPackageManager = (ContactsMockPackageManager) getProvider()
                .getContext().getPackageManager();
    }

    @Override
    protected String getContextPackageName() {
        // In this test, we need to use the real package name, because that'll be recorded in the
        // directory table, and if it's wrong, the tests would get confused.
        return mContext.getPackageName();
    }

    @Test
    public void testIsDirectoryProvider() {
        ProviderInfo provider = new ProviderInfo();

        // Null -- just return false.
        assertFalse(ContactDirectoryManager.isDirectoryProvider(null));

        // No metadata
        assertFalse(ContactDirectoryManager.isDirectoryProvider(provider));

        // No CONTACT_DIRECTORY_META_DATA
        provider.metaData = new Bundle();
        assertFalse(ContactDirectoryManager.isDirectoryProvider(provider));

        // CONTACT_DIRECTORY_META_DATA is a string
        provider.metaData.putString("android.content.ContactDirectory", "");
        assertFalse(ContactDirectoryManager.isDirectoryProvider(provider));

        // CONTACT_DIRECTORY_META_DATA is false
        provider.metaData.putBoolean("android.content.ContactDirectory", false);
        assertFalse(ContactDirectoryManager.isDirectoryProvider(provider));

        // CONTACT_DIRECTORY_META_DATA is true
        provider.metaData.putBoolean("android.content.ContactDirectory", true);
        assertTrue(ContactDirectoryManager.isDirectoryProvider(provider));
    }

    @Test
    public void testScanAllProviders() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(
                        createProviderPackage("test.package1", "authority1"),
                        createProviderPackage("test.package2", "authority2"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_FULL_SIZE_ONLY);
        addDirectoryRow(response1, "account-name2", "account-type2", "display-name2", 2,
                Directory.EXPORT_SUPPORT_ANY_ACCOUNT, Directory.SHORTCUT_SUPPORT_DATA_ITEMS_ONLY,
                Directory.PHOTO_SUPPORT_THUMBNAIL_ONLY);

        MockContactDirectoryProvider provider2 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority2");

        MatrixCursor response2 = provider2.createResponseCursor();
        addDirectoryRow(response2, "account-name3", "account-type3", "display-name3", 3,
                Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY, Directory.SHORTCUT_SUPPORT_FULL,
                Directory.PHOTO_SUPPORT_FULL);

        assertEquals(3, mDirectoryManager.scanAllPackages(/* rescan=*/ false));

        Cursor cursor = mResolver.query(Directory.CONTENT_URI, null, null, null,
                /* order by=*/ Directory.DIRECTORY_AUTHORITY + "," + Directory.ACCOUNT_NAME +
                "," + Directory._ID );

        TestUtils.dumpCursor(cursor);
        assertEquals(5, cursor.getCount());

        assertTrue(cursor.moveToPosition(0));
        assertDirectoryRow(cursor, "test.package1", "authority1", "account-name1", "account-type1",
                "display-name1", 1, Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_FULL_SIZE_ONLY);

        assertTrue(cursor.moveToPosition(1));
        assertDirectoryRow(cursor, "test.package1", "authority1", "account-name2", "account-type2",
                "display-name2", 2, Directory.EXPORT_SUPPORT_ANY_ACCOUNT,
                Directory.SHORTCUT_SUPPORT_DATA_ITEMS_ONLY, Directory.PHOTO_SUPPORT_THUMBNAIL_ONLY);

        assertTrue(cursor.moveToPosition(2));
        assertDirectoryRow(cursor, "test.package2", "authority2", "account-name3", "account-type3",
                "display-name3", 3, Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY,
                Directory.SHORTCUT_SUPPORT_FULL, Directory.PHOTO_SUPPORT_FULL);

        assertTrue(cursor.moveToPosition(3));
        assertDirectoryRow(cursor, mContext.getPackageName(),
                "com.android.contacts", null, null,
                null, -1 /* =any */, Directory.EXPORT_SUPPORT_NONE,
                Directory.SHORTCUT_SUPPORT_FULL, Directory.PHOTO_SUPPORT_FULL);

        assertTrue(cursor.moveToPosition(4));
        assertDirectoryRow(cursor, mContext.getPackageName(),
                "com.android.contacts", null, null,
                null, -1 /* =any */, Directory.EXPORT_SUPPORT_NONE,
                Directory.SHORTCUT_SUPPORT_FULL, Directory.PHOTO_SUPPORT_FULL);

        cursor.close();
    }

    @Test
    public void testScanAllProviders_scanCondition() throws Exception {
        testScanAllProviders();

        // Nothing has changed, so no scanning.
        assertEquals(0, mDirectoryManager.scanAllPackages(/* rescan=*/ false));

        // rescan = true, so a full-scan should happen.
        assertEquals(3, mDirectoryManager.scanAllPackages(/* rescan=*/ true));

        // Change GAL packages, a scan should happen.
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(
                        createProviderPackage("test.package2", "authority2"),
                        createPackage("test.packageX", "authorityX", false)));
        assertEquals(1, mDirectoryManager.scanAllPackages(/* rescan=*/ false));

        // Remove the non-GAL package, no scan should happen.
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(
                        createProviderPackage("test.package2", "authority2")));
        assertEquals(0, mDirectoryManager.scanAllPackages(/* rescan=*/ false));

        // Remove GAL package 2 and add 1, a scan should happen.
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(
                        createProviderPackage("test.package1", "authority1"),
                        createPackage("test.packageX", "authorityX", false)));
        assertEquals(2, mDirectoryManager.scanAllPackages(/* rescan=*/ false));

    }

    @Test
    public void testPackageInstalled() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(createProviderPackage("test.package1", "authority1"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_FULL);

        mDirectoryManager.scanAllPackages(/* rescan=*/ false);

        // At this point the manager has discovered a single directory (plus two
        // standard ones).
        Cursor cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(3, cursor.getCount());
        cursor.close();

        // Pretend to install another package
        MockContactDirectoryProvider provider2 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority2");

        MatrixCursor response2 = provider2.createResponseCursor();
        addDirectoryRow(response2, "account-name3", "account-type3", "display-name3", 3,
                Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY, Directory.SHORTCUT_SUPPORT_FULL,
                Directory.PHOTO_SUPPORT_FULL);

        mPackageManager.getInstalledPackages(0).add(
                createProviderPackage("test.package2", "authority2"));

        mProvider.onPackageChanged("test.package2");

        cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(4, cursor.getCount());

        cursor.moveToPosition(2);
        assertDirectoryRow(cursor, "test.package1", "authority1", "account-name1", "account-type1",
                "display-name1", 1, Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_FULL);

        cursor.moveToNext();
        assertDirectoryRow(cursor, "test.package2", "authority2", "account-name3", "account-type3",
                "display-name3", 3, Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY,
                Directory.SHORTCUT_SUPPORT_FULL, Directory.PHOTO_SUPPORT_FULL);

        cursor.close();
    }

    @Test
    public void testPackageUninstalled() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(
                        createProviderPackage("test.package1", "authority1"),
                        createProviderPackage("test.package2", "authority2"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        MockContactDirectoryProvider provider2 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority2");

        MatrixCursor response2 = provider2.createResponseCursor();
        addDirectoryRow(response2, "account-name3", "account-type3", "display-name3", 3,
                Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY, Directory.SHORTCUT_SUPPORT_FULL,
                Directory.PHOTO_SUPPORT_FULL);

        mDirectoryManager.scanAllPackages(/* rescan=*/ false);

        // At this point the manager has discovered two custom directories.
        Cursor cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(4, cursor.getCount());
        cursor.close();

        // Pretend to uninstall one of the packages
        mPackageManager.getInstalledPackages(0).remove(1);

        mProvider.onPackageChanged("test.package2");

        cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(3, cursor.getCount());

        cursor.moveToPosition(2);
        assertDirectoryRow(cursor, "test.package1", "authority1", "account-name1", "account-type1",
                "display-name1", 1, Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        cursor.close();
    }

    @Test
    public void testPackageReplaced() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(
                        createProviderPackage("test.package1", "authority1"),
                        createProviderPackage("test.package2", "authority2"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        MockContactDirectoryProvider provider2 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority2");

        MatrixCursor response2 = provider2.createResponseCursor();
        addDirectoryRow(response2, "account-name3", "account-type3", "display-name3", 3,
                Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY, Directory.SHORTCUT_SUPPORT_FULL,
                Directory.PHOTO_SUPPORT_FULL);

        mDirectoryManager.scanAllPackages(/* rescan=*/ false);

        // At this point the manager has discovered two custom directories.
        Cursor cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(4, cursor.getCount());
        cursor.close();

        // Pretend to replace the package with a different provider inside
        MatrixCursor response3 = provider2.createResponseCursor();
        addDirectoryRow(response3, "account-name4", "account-type4", "display-name4", 4,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        mProvider.onPackageChanged("test.package2");

        cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(4, cursor.getCount());

        cursor.moveToPosition(2);
        assertDirectoryRow(cursor, "test.package1", "authority1", "account-name1", "account-type1",
                "display-name1", 1, Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        cursor.moveToNext();
        assertDirectoryRow(cursor, "test.package2", "authority2", "account-name4", "account-type4",
                "display-name4", 4, Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        cursor.close();
    }

    /**
     * Tests if the manager works correctly when the package name for a directory is changed
     * (on system update).
     */
    @Test
    public void testPackageRenamed() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(
                        createProviderPackage("test.package1", "authority1"),
                        createProviderPackage("test.package2", "authority2"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        MockContactDirectoryProvider provider2 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority2");

        MatrixCursor response2 = provider2.createResponseCursor();
        addDirectoryRow(response2, "account-name2", "account-type2", "display-name2", 2,
                Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY, Directory.SHORTCUT_SUPPORT_FULL,
                Directory.PHOTO_SUPPORT_FULL);

        mDirectoryManager.scanAllPackages(/* rescan=*/ false);

        // At this point the manager has discovered two custom directories.
        Cursor cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(4, cursor.getCount());
        cursor.close();

        // Pretend to rename the package name of a package on system update.
        PackageInfo info = mPackageManager.getInstalledPackages(0).get(1);
        info.packageName              = "test.package3";
        info.providers[0].packageName = "test.package3";
        MatrixCursor response3 = provider2.createResponseCursor();
        // Change resource id.
        addDirectoryRow(response3, "account-name2", "account-type2", "display-name2", 3,
                Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY, Directory.SHORTCUT_SUPPORT_FULL,
                Directory.PHOTO_SUPPORT_FULL);

        // When this happens on reboot, scanAllPackages() is called instead of onPackageChanged()
        // (as part of ContactsProvider2 initialization).
        // Accounts won't be affected so false should be passed here.
        mDirectoryManager.scanAllPackages(false);

        cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        // We should have columns for default, local_invisible, test.package1, and test.package3.
        // The row for test.package2 should not remain.
        assertEquals(4, cursor.getCount());

        cursor.moveToPosition(2);
        assertDirectoryRow(cursor, "test.package1", "authority1", "account-name1", "account-type1",
                "display-name1", 1, Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        cursor.moveToNext();
        assertDirectoryRow(cursor, "test.package3", "authority2", "account-name2", "account-type2",
                "display-name2", 3, Directory.EXPORT_SUPPORT_SAME_ACCOUNT_ONLY,
                Directory.SHORTCUT_SUPPORT_FULL, Directory.PHOTO_SUPPORT_FULL);

        cursor.close();
    }

    @Test
    public void testAccountRemoval() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(
                        createProviderPackage("test.package1", "authority1"),
                        createProviderPackage("test.package2", "authority2"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        Account[] accounts = new Account[]{
                new Account("account-name1", "account-type1"),
                new Account("account-name2", "account-type2")};
        mActor.setAccounts(accounts);
        ((ContactsProvider2)getProvider()).onAccountsUpdated(accounts);

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);
        addDirectoryRow(response1, "account-name2", "account-type2", "display-name2", 2,
                Directory.EXPORT_SUPPORT_ANY_ACCOUNT, Directory.SHORTCUT_SUPPORT_DATA_ITEMS_ONLY,
                Directory.PHOTO_SUPPORT_FULL_SIZE_ONLY);

        mDirectoryManager.scanAllPackages(/* rescan=*/ false);

        accounts = new Account[]{new Account("account-name1", "account-type1")};
        mActor.setAccounts(accounts);
        ((ContactsProvider2)getProvider()).onAccountsUpdated(accounts);

        Cursor cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(3, cursor.getCount());

        cursor.moveToPosition(2);
        assertDirectoryRow(cursor, "test.package1", "authority1", "account-name1", "account-type1",
                "display-name1", 1, Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        cursor.close();
    }

    @Test
    public void testNotifyDirectoryChange() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(createProviderPackage("test.package1", "authority1"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        mDirectoryManager.scanAllPackages(/* rescan=*/ false);

        // Pretend to replace the package with a different provider inside
        MatrixCursor response2 = provider1.createResponseCursor();
        addDirectoryRow(response2, "account-name2", "account-type2", "display-name2", 2,
                Directory.EXPORT_SUPPORT_ANY_ACCOUNT, Directory.SHORTCUT_SUPPORT_FULL,
                Directory.PHOTO_SUPPORT_FULL);

        ContactsContract.Directory.notifyDirectoryChange(mResolver);

        Cursor cursor = mResolver.query(Directory.CONTENT_URI, null, null, null, null);
        assertEquals(3, cursor.getCount());

        cursor.moveToPosition(2);
        assertDirectoryRow(cursor, "test.package1", "authority1", "account-name2", "account-type2",
                "display-name2", 2, Directory.EXPORT_SUPPORT_ANY_ACCOUNT,
                Directory.SHORTCUT_SUPPORT_FULL, Directory.PHOTO_SUPPORT_FULL);

        cursor.close();
    }

    @Test
    public void testForwardingToDirectoryProvider() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(createProviderPackage("test.package1", "authority1"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        mDirectoryManager.scanAllPackages(/* rescan=*/ false);

        Cursor cursor = mResolver.query(
                Directory.CONTENT_URI, new String[] { Directory._ID }, null, null, null);
        cursor.moveToPosition(2);
        long directoryId = cursor.getLong(0);
        cursor.close();

        Uri contentUri = Contacts.CONTENT_URI.buildUpon().appendQueryParameter(
                ContactsContract.DIRECTORY_PARAM_KEY, String.valueOf(directoryId)).build();

        // The request should be forwarded to TestProvider, which will simply
        // package arguments and return them to us for verification
        cursor = mResolver.query(contentUri,
                new String[]{"f1", "f2"}, "query", new String[]{"s1", "s2"}, "so");
        assertNotNull(cursor);
        assertEquals(1, cursor.getCount());
        cursor.moveToFirst();
        assertEquals("[f1, f2]", cursor.getString(cursor.getColumnIndex("projection")));
        assertEquals("query", cursor.getString(cursor.getColumnIndex("selection")));
        assertEquals("[s1, s2]", cursor.getString(cursor.getColumnIndex("selectionArgs")));
        assertEquals("so", cursor.getString(cursor.getColumnIndex("sortOrder")));
        assertEquals("account-name1", cursor.getString(cursor.getColumnIndex("accountName")));
        assertEquals("account-type1", cursor.getString(cursor.getColumnIndex("accountType")));
        cursor.close();
    }

    @Test
    public void testProjectionPopulated() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(createProviderPackage("test.package1", "authority1"),
                        createPackage("test.packageX", "authorityX", false)));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");

        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        mDirectoryManager.scanAllPackages(/* rescan=*/ false);

        Cursor cursor = mResolver.query(
                Directory.CONTENT_URI, new String[] { Directory._ID }, null, null, null);
        cursor.moveToPosition(2);
        long directoryId = cursor.getLong(0);
        cursor.close();

        Uri contentUri = AggregationExceptions.CONTENT_URI.buildUpon().appendQueryParameter(
                ContactsContract.DIRECTORY_PARAM_KEY, String.valueOf(directoryId)).build();

        // The request should be forwarded to TestProvider, which will return an empty cursor
        // but the projection should be correctly populated by ContactProvider
        assertProjection(contentUri, new String[]{
                AggregationExceptionColumns._ID,
                AggregationExceptions.TYPE,
                AggregationExceptions.RAW_CONTACT_ID1,
                AggregationExceptions.RAW_CONTACT_ID2,
        });
    }

    /**
     * Test {@link ContactDirectoryManager#getDirectoryProviderPackages} with the actual
     * package manager, and see if it returns the google sync package.
     */
    @Test
    public void testGetDirectoryProviderPackages() {
        final PackageManager pm = mContext.getPackageManager();
        final String googleSync = "com.google.android.gms";

        // Skip if the package is not installed.
        try {
            pm.getPackageInfo(googleSync, 0);
        } catch (NameNotFoundException e) {
            Log.w(TAG, googleSync + " not installed.  Skipping...");
            return;
        }

        try {
            InstrumentationRegistry.getInstrumentation().getUiAutomation()
                    .executeShellCommand("am wait-for-broadcast-idle");
            Thread.sleep(1000); // wait for the system
        } catch (Exception ignored) { }

        // If installed, getDirectoryProviderPackages() should return it.
        Set<String> dirProviderPackages = ContactDirectoryManager.getDirectoryProviderPackages(pm);
        assertTrue(googleSync + " package not found in the list of directory provider packages: "
                        + Arrays.toString(dirProviderPackages.toArray()),
                        dirProviderPackages.contains(googleSync));
    }

    @Test
    public void testUpdateDirectoriesForUnstoppedPackage() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(createProviderPackage("test.package1", "authority1")));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");
        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        PackageInfo packageInfo = mPackageManager.getPackageInfo("test.package1",
                PackageManager.GET_PROVIDERS | PackageManager.GET_META_DATA);

        ApplicationInfo applicationInfo = new ApplicationInfo();
        applicationInfo.packageName = packageInfo.packageName;
        packageInfo.applicationInfo = applicationInfo;
        // Package is not in stopped state
        packageInfo.applicationInfo.flags = 0;

        assertEquals(mDirectoryManager.updateDirectoriesForPackage(packageInfo, true).size(), 1);
    }

    @Test
    @RequiresFlagsEnabled(FLAG_STAY_STOPPED)
    public void testUpdateDirectoriesForStoppedPackage() throws Exception {
        mPackageManager.setInstalledPackages(
                Lists.newArrayList(createProviderPackage("test.package1", "authority1")));

        MockContactDirectoryProvider provider1 = (MockContactDirectoryProvider) addProvider(
                MockContactDirectoryProvider.class, "authority1");
        MatrixCursor response1 = provider1.createResponseCursor();
        addDirectoryRow(response1, "account-name1", "account-type1", "display-name1", 1,
                Directory.EXPORT_SUPPORT_NONE, Directory.SHORTCUT_SUPPORT_NONE,
                Directory.PHOTO_SUPPORT_NONE);

        PackageInfo packageInfo = mPackageManager.getPackageInfo("test.package1",
                PackageManager.GET_PROVIDERS | PackageManager.GET_META_DATA);

        ApplicationInfo applicationInfo = new ApplicationInfo();
        applicationInfo.packageName = packageInfo.packageName;
        packageInfo.applicationInfo = applicationInfo;
        // Put the package in stopped state: set associated app flags to true
        packageInfo.applicationInfo.flags |= ApplicationInfo.FLAG_STOPPED;

        assertNull(mDirectoryManager.updateDirectoriesForPackage(packageInfo, true));
    }

    protected PackageInfo createProviderPackage(String packageName, String authority) {
        return createPackage(packageName, authority, true);
    }

    protected PackageInfo createPackage(String packageName, String authority,
            boolean isDirectoryProvider) {
        PackageInfo providerPackage = new PackageInfo();
        providerPackage.packageName = packageName;
        ProviderInfo providerInfo = new ProviderInfo();
        providerInfo.packageName = providerPackage.packageName;
        providerInfo.authority = authority;
        if (isDirectoryProvider) {
            providerInfo.metaData = new Bundle();
            providerInfo.metaData.putBoolean("android.content.ContactDirectory", true);
        }
        providerPackage.providers = new ProviderInfo[] { providerInfo };
        return providerPackage;
    }

    protected void addDirectoryRow(MatrixCursor cursor, String accountName, String accountType,
            String displayName, int typeResourceId, int exportSupport, int shortcutSupport,
            int photoSupport) {
        Object[] row = new Object[cursor.getColumnCount()];
        row[cursor.getColumnIndex(Directory.ACCOUNT_NAME)] = accountName;
        row[cursor.getColumnIndex(Directory.ACCOUNT_TYPE)] = accountType;
        row[cursor.getColumnIndex(Directory.DISPLAY_NAME)] = displayName;
        row[cursor.getColumnIndex(Directory.TYPE_RESOURCE_ID)] = typeResourceId;
        row[cursor.getColumnIndex(Directory.EXPORT_SUPPORT)] = exportSupport;
        row[cursor.getColumnIndex(Directory.SHORTCUT_SUPPORT)] = shortcutSupport;
        row[cursor.getColumnIndex(Directory.PHOTO_SUPPORT)] = photoSupport;
        cursor.addRow(row);
    }

    protected void assertDirectoryRow(Cursor cursor, String packageName, String authority,
            String accountName, String accountType, String displayName, int typeResourceId,
            int exportSupport, int shortcutSupport, int photoSupport) {
        ContentValues values = new ContentValues();
        values.put(Directory.PACKAGE_NAME, packageName);
        values.put(Directory.DIRECTORY_AUTHORITY, authority);
        values.put(Directory.ACCOUNT_NAME, accountName);
        values.put(Directory.ACCOUNT_TYPE, accountType);
        values.put(Directory.DISPLAY_NAME, displayName);
        if (typeResourceId >= 0) {
            values.put(Directory.TYPE_RESOURCE_ID, typeResourceId);
        }
        values.put(Directory.EXPORT_SUPPORT, exportSupport);
        values.put(Directory.SHORTCUT_SUPPORT, shortcutSupport);
        values.put(Directory.PHOTO_SUPPORT, photoSupport);

        assertCursorValues(cursor, values);
    }
}