Add dynamic launcher shortcuts.
Currently the shortcuts are created for the top 3 contacts returned from
Contacts.CONTENT_STREQUENT_URI
Test:
Added unit tests for DynamicShortcuts but currently suppressed because they
require AndroidJUnitRunner
Manual:
* Use N_MR1 device with recent dogfood Nexus launcher installed.
* launch app
* star some contacts if needed
* press home
* long press launcher icon
* verify that starred contacts show in list of shortcuts
* unstar some contacts
* verify that shortcuts change
* pin a shortcut
* remove contact for pinned shortcut
* verify that pinned shortcut is disabled
* pin a shortcut
* change name of contact for pinned shortcut
* verify that name on pinned shortcut changes
Also prevent disambiguation dialog for other home screen shortcuts
Bug 30189449
Bug 31628994
Change-Id: Iace4b1c88b51ba1f7973c6f4ef90002fb92d0784
diff --git a/tests/Android.mk b/tests/Android.mk
index 48a00f4..1176687 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -17,8 +17,9 @@
LOCAL_SDK_VERSION := current
LOCAL_MIN_SDK_VERSION := 21
-LOCAL_STATIC_JAVA_LIBRARIES := \
- mockito-target
+LOCAL_STATIC_JAVA_LIBRARIES += \
+ hamcrest-library \
+ mockito-target-minus-junit4
LOCAL_AAPT_FLAGS := \
--auto-add-overlay \
diff --git a/tests/src/com/android/contacts/DynamicShortcutsTests.java b/tests/src/com/android/contacts/DynamicShortcutsTests.java
new file mode 100644
index 0000000..168b646
--- /dev/null
+++ b/tests/src/com/android/contacts/DynamicShortcutsTests.java
@@ -0,0 +1,307 @@
+/*
+ * Copyright (C) 2016 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.contacts;
+
+import android.annotation.TargetApi;
+import android.app.job.JobScheduler;
+import android.content.ContentProvider;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.pm.ShortcutInfo;
+import android.content.pm.ShortcutManager;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Contacts;
+import android.support.test.filters.SdkSuppress;
+import android.test.AndroidTestCase;
+import android.test.mock.MockContentResolver;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.test.suitebuilder.annotation.Suppress;
+
+import com.android.contacts.common.test.mocks.MockContentProvider;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.Matchers;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@TargetApi(Build.VERSION_CODES.N_MR1)
+@SdkSuppress(minSdkVersion = Build.VERSION_CODES.N_MR1)
+// TODO: need to switch to android.support.test.runner.AndroidJUnitRunner for the @SdkSuppress
+// annotation to be respected. So for now we suppress this test to keep it from failing when run
+// by the build system.
+@Suppress
+@SmallTest
+public class DynamicShortcutsTests extends AndroidTestCase {
+
+
+ @Override
+ protected void tearDown() throws Exception {
+ super.tearDown();
+
+ // Clean up the job if it was scheduled by these tests.
+ final JobScheduler scheduler = (JobScheduler) getContext()
+ .getSystemService(Context.JOB_SCHEDULER_SERVICE);
+ scheduler.cancel(ContactsJobService.DYNAMIC_SHORTCUTS_JOB_ID);
+ }
+
+ // Basic smoke test to make sure the queries executed by DynamicShortcuts are valid as well
+ // as the integration with ShortcutManager. Note that this may change the state of the shortcuts
+ // on the device it is executed on.
+ public void test_refresh_doesntCrash() {
+ final DynamicShortcuts sut = new DynamicShortcuts(getContext());
+ sut.refresh();
+ // Pass because it didn't throw an exception.
+ }
+
+ public void test_createShortcutFromRow_hasCorrectResult() {
+ final DynamicShortcuts sut = createDynamicShortcuts();
+
+ final Cursor row = queryResult(
+ // ID, LOOKUP_KEY, DISPLAY_NAME_PRIMARY
+ 1l, "lookup_key", "John Smith"
+ );
+
+ row.moveToFirst();
+ final ShortcutInfo shortcut = sut.builderForContactShortcut(row).build();
+
+ assertEquals("lookup_key", shortcut.getId());
+ assertEquals(Contacts.getLookupUri(1, "lookup_key"), shortcut.getIntent().getData());
+ assertEquals(ContactsContract.QuickContact.ACTION_QUICK_CONTACT,
+ shortcut.getIntent().getAction());
+ assertEquals("John Smith", shortcut.getShortLabel());
+ assertEquals("John Smith", shortcut.getLongLabel());
+ assertEquals(1l, shortcut.getExtras().getLong(Contacts._ID));
+ }
+
+ public void test_builderForContactShortcut_ellipsizesLongNamesForLabels() {
+ final DynamicShortcuts sut = createDynamicShortcuts();
+ sut.setShortLabelMaxLength(5);
+ sut.setLongLabelMaxLength(10);
+
+ final ShortcutInfo shortcut = sut.builderForContactShortcut(1l, "lookup_key",
+ "123456789 1011").build();
+
+ assertEquals("1234…", shortcut.getShortLabel());
+ assertEquals("123456789…", shortcut.getLongLabel());
+ }
+
+ public void test_updatePinned_disablesShortcutsForRemovedContacts() {
+ final ShortcutManager mockShortcutManager = mock(ShortcutManager.class);
+ when(mockShortcutManager.getPinnedShortcuts()).thenReturn(
+ Collections.singletonList(shortcutFor(1l, "key1", "name1")));
+
+ final DynamicShortcuts sut = new DynamicShortcuts(getContext(), emptyResolver(),
+ mockShortcutManager);
+
+ sut.updatePinned();
+
+ verify(mockShortcutManager).disableShortcuts(
+ eq(Collections.singletonList("key1")), anyString());
+ }
+
+ public void test_updatePinned_updatesExistingShortcutsWithMatchingKeys() {
+ final ShortcutManager mockShortcutManager = mock(ShortcutManager.class);
+ when(mockShortcutManager.getPinnedShortcuts()).thenReturn(
+ Arrays.asList(
+ shortcutFor(1l, "key1", "name1"),
+ shortcutFor(2l, "key2", "name2"),
+ shortcutFor(3l, "key3", "name3")
+ ));
+
+ final DynamicShortcuts sut = createDynamicShortcuts(resolverWithExpectedQueries(
+ queryForSingleRow(Contacts.getLookupUri(1l, "key1"), 11l, "key1", "New Name1"),
+ queryForSingleRow(Contacts.getLookupUri(2l, "key2"), 2l, "key2", "name2"),
+ queryForSingleRow(Contacts.getLookupUri(3l, "key3"), 33l, "key3", "name3")
+ ), mockShortcutManager);
+
+ sut.updatePinned();
+
+ final ArgumentCaptor<List<ShortcutInfo>> updateArgs =
+ ArgumentCaptor.forClass((Class) List.class);
+
+ verify(mockShortcutManager).disableShortcuts(
+ eq(Collections.<String>emptyList()), anyString());
+ verify(mockShortcutManager).updateShortcuts(updateArgs.capture());
+
+ final List<ShortcutInfo> arg = updateArgs.getValue();
+ assertThat(arg.size(), equalTo(3));
+ assertThat(arg.get(0),
+ isShortcutForContact(11l, "key1", "New Name1"));
+ assertThat(arg.get(1),
+ isShortcutForContact(2l, "key2", "name2"));
+ assertThat(arg.get(2),
+ isShortcutForContact(33l, "key3", "name3"));
+ }
+
+ public void test_refresh_setsDynamicShortcutsToStrequentContacts() {
+ final ShortcutManager mockShortcutManager = mock(ShortcutManager.class);
+ when(mockShortcutManager.getPinnedShortcuts()).thenReturn(
+ Collections.<ShortcutInfo>emptyList());
+ final DynamicShortcuts sut = createDynamicShortcuts(resolverWithExpectedQueries(
+ queryFor(Contacts.CONTENT_STREQUENT_URI,
+ 1l, "starred_key", "starred name",
+ 2l, "freq_key", "freq name",
+ 3l, "starred_2", "Starred Two")), mockShortcutManager);
+
+ sut.refresh();
+
+ final ArgumentCaptor<List<ShortcutInfo>> updateArgs =
+ ArgumentCaptor.forClass((Class) List.class);
+
+ verify(mockShortcutManager).setDynamicShortcuts(updateArgs.capture());
+
+ final List<ShortcutInfo> arg = updateArgs.getValue();
+ assertThat(arg.size(), equalTo(3));
+ assertThat(arg.get(0), isShortcutForContact(1l, "starred_key", "starred name"));
+ assertThat(arg.get(1), isShortcutForContact(2l, "freq_key", "freq name"));
+ assertThat(arg.get(2), isShortcutForContact(3l, "starred_2", "Starred Two"));
+ }
+
+ public void test_scheduleUpdateJob_schedulesJob() {
+ final DynamicShortcuts sut = createDynamicShortcuts();
+ sut.scheduleUpdateJob();
+ assertThat(DynamicShortcuts.isJobScheduled(getContext()), Matchers.is(true));
+ }
+
+ private Matcher<ShortcutInfo> isShortcutForContact(final long id,
+ final String lookupKey, final String name) {
+ return new BaseMatcher<ShortcutInfo>() {
+ @Override
+ public boolean matches(Object o) {
+ if (!(o instanceof ShortcutInfo)) return false;
+ final ShortcutInfo other = (ShortcutInfo)o;
+ return id == other.getExtras().getLong(Contacts._ID)
+ && lookupKey.equals(other.getId())
+ && name.equals(other.getLongLabel())
+ && name.equals(other.getShortLabel());
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("Should be a shortcut for contact with _ID=" + id +
+ " lookup=" + lookupKey + " and display_name=" + name);
+ }
+ };
+ }
+
+ private ShortcutInfo shortcutFor(long contactId, String lookupKey, String name) {
+ return new DynamicShortcuts(getContext())
+ .builderForContactShortcut(contactId, lookupKey, name).build();
+ }
+
+ private ContentResolver emptyResolver() {
+ final MockContentProvider provider = new MockContentProvider();
+ provider.expect(MockContentProvider.Query.forAnyUri())
+ .withAnyProjection()
+ .withAnySelection()
+ .withAnySortOrder()
+ .returnEmptyCursor();
+ return resolverWithContactsProvider(provider);
+ }
+
+ private MockContentProvider.Query queryFor(Uri uri, Object... rows) {
+ final MockContentProvider.Query query = MockContentProvider.Query
+ .forUrisMatching(uri.getAuthority(), uri.getPath())
+ .withProjection(DynamicShortcuts.PROJECTION)
+ .withAnySelection()
+ .withAnySortOrder();
+
+ populateQueryRows(query, DynamicShortcuts.PROJECTION.length, rows);
+ return query;
+ }
+
+ private MockContentProvider.Query queryForSingleRow(Uri uri, Object... row) {
+ return new MockContentProvider.Query(uri)
+ .withProjection(DynamicShortcuts.PROJECTION)
+ .withAnySelection()
+ .withAnySortOrder()
+ .returnRow(row);
+ }
+
+ private ContentResolver resolverWithExpectedQueries(MockContentProvider.Query... queries) {
+ final MockContentProvider provider = new MockContentProvider();
+ for (MockContentProvider.Query query : queries) {
+ provider.expect(query);
+ }
+ return resolverWithContactsProvider(provider);
+ }
+
+ private ContentResolver resolverWithContactsProvider(ContentProvider provider) {
+ final MockContentResolver resolver = new MockContentResolver();
+ resolver.addProvider(ContactsContract.AUTHORITY, provider);
+ return resolver;
+ }
+
+ private DynamicShortcuts createDynamicShortcuts() {
+ return createDynamicShortcuts(emptyResolver(), mock(ShortcutManager.class));
+ }
+
+ private DynamicShortcuts createDynamicShortcuts(ContentResolver resolver,
+ ShortcutManager shortcutManager) {
+ final DynamicShortcuts result = new DynamicShortcuts(getContext(), resolver,
+ shortcutManager);
+ // Use very long label limits to make checking shortcuts easier to understand
+ result.setShortLabelMaxLength(100);
+ result.setLongLabelMaxLength(100);
+ return result;
+ }
+
+ private void populateQueryRows(MockContentProvider.Query query, int numColumns,
+ Object... rows) {
+ for (int i = 0; i < rows.length; i += numColumns) {
+ Object[] row = new Object[numColumns];
+ for (int j = 0; j < numColumns; j++) {
+ row[j] = rows[i + j];
+ }
+ query.returnRow(row);
+ }
+ }
+
+ private Cursor queryResult(Object... values) {
+ return queryResult(DynamicShortcuts.PROJECTION, values);
+ }
+
+ private Cursor queryResult(String[] columns, Object... values) {
+ MatrixCursor result = new MatrixCursor(new String[] {
+ Contacts._ID, Contacts.LOOKUP_KEY,
+ Contacts.DISPLAY_NAME_PRIMARY
+ });
+ for (int i = 0; i < values.length; i += columns.length) {
+ MatrixCursor.RowBuilder builder = result.newRow();
+ for (int j = 0; j < columns.length; j++) {
+ builder.add(values[i + j]);
+ }
+ }
+ return result;
+ }
+}
diff --git a/tests/src/com/android/contacts/common/test/mocks/MockContentProvider.java b/tests/src/com/android/contacts/common/test/mocks/MockContentProvider.java
index 335e8d2..336467d 100644
--- a/tests/src/com/android/contacts/common/test/mocks/MockContentProvider.java
+++ b/tests/src/com/android/contacts/common/test/mocks/MockContentProvider.java
@@ -20,6 +20,7 @@
import com.google.common.collect.Maps;
import android.content.ContentValues;
+import android.content.UriMatcher;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.net.Uri;
@@ -43,6 +44,8 @@
public static class Query {
private final Uri mUri;
+ private UriMatcher mMatcher;
+
private String[] mProjection;
private String[] mDefaultProjection;
private String mSelection;
@@ -56,6 +59,15 @@
private boolean mExecuted;
+ private Query() {
+ mUri = null;
+ }
+
+ private Query(UriMatcher matcher) {
+ mUri = null;
+ mMatcher = matcher;
+ }
+
public Query(Uri uri) {
mUri = uri;
}
@@ -123,7 +135,11 @@
public boolean equals(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
- if (!uri.equals(mUri)) {
+ if (mUri == null) {
+ if (mMatcher != null && mMatcher.match(uri) == UriMatcher.NO_MATCH) {
+ return false;
+ }
+ } else if (!uri.equals(mUri)) {
return false;
}
@@ -169,6 +185,23 @@
}
return cursor;
}
+
+ public static Query forAnyUri() {
+ return new Query();
+ }
+
+ public static Query forUrisMatching(UriMatcher matcher) {
+ return new Query(matcher);
+ }
+
+ public static Query forUrisMatching(String authority, String... paths) {
+ final UriMatcher matcher = new UriMatcher(UriMatcher.NO_MATCH);
+ for (int i = 0; i < paths.length; i++) {
+ matcher.addURI(authority, paths[i], i);
+ }
+ return new Query(matcher);
+ }
+
}
public static class TypeQuery {
@@ -443,12 +476,15 @@
return true;
}
- public Query expectQuery(Uri contentUri) {
- Query query = new Query(contentUri);
+ public Query expect(Query query) {
mExpectedQueries.add(query);
return query;
}
+ public Query expectQuery(Uri contentUri) {
+ return expect(new Query(contentUri));
+ }
+
public void expectTypeQuery(Uri uri, String type) {
mExpectedTypeQueries.put(uri, type);
}
@@ -598,7 +634,7 @@
private static String queryToString(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
StringBuilder sb = new StringBuilder();
- sb.append(uri).append(" ");
+ sb.append(uri == null ? "<Any Uri>" : uri).append(" ");
if (projection != null) {
sb.append(Arrays.toString(projection));
} else {