[Firebase Segmentation] Add custom installation id cache layer and tests for it.

firebase-segmentation/firebase-segmentation.gradle

@@ -91,12 +91,17 @@ dependencies {
     implementation 'androidx.multidex:multidex:2.0.0'
     implementation 'com.google.android.gms:play-services-tasks:16.0.1'
 
+    compileOnly "com.google.auto.value:auto-value-annotations:1.6.5"
+    annotationProcessor "com.google.auto.value:auto-value:1.6.2"
+
     testImplementation 'androidx.test:core:1.2.0'
     testImplementation 'junit:junit:4.12'
     testImplementation "org.robolectric:robolectric:$robolectricVersion"
 
-    androidTestImplementation 'androidx.annotation:annotation:1.1.0'
-    androidTestImplementation 'androidx.test:runner:1.2.0'
-    androidTestImplementation 'androidx.test:rules:1.2.0'
+    androidTestImplementation "androidx.annotation:annotation:1.1.0"
     androidTestImplementation 'androidx.test.ext:junit:1.1.1'
+    androidTestImplementation 'androidx.test:rules:1.2.0'
+    androidTestImplementation 'androidx.test:runner:1.2.0'
+    androidTestImplementation "com.google.truth:truth:$googleTruthVersion"
+    androidTestImplementation 'junit:junit:4.12'
 }

firebase-segmentation/src/androidTest/java/com/google/firebase/segmentation/CustomInstallationIdCacheTest.java

@@ -0,0 +1,91 @@
+// Copyright 2019 Google LLC
+//
+// 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.google.firebase.segmentation;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import androidx.test.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.FirebaseOptions;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/** Instrumented tests for {@link CustomInstallationIdCache} */
+@RunWith(AndroidJUnit4.class)
+public class CustomInstallationIdCacheTest {
+
+  private FirebaseApp firebaseApp0;
+  private FirebaseApp firebaseApp1;
+  private CustomInstallationIdCache cache;
+
+  @Before
+  public void setUp() {
+    FirebaseApp.clearInstancesForTest();
+    firebaseApp0 =
+        FirebaseApp.initializeApp(
+            InstrumentationRegistry.getContext(),
+            new FirebaseOptions.Builder().setApplicationId("1:123456789:android:abcdef").build());
+    firebaseApp1 =
+        FirebaseApp.initializeApp(
+            InstrumentationRegistry.getContext(),
+            new FirebaseOptions.Builder().setApplicationId("1:987654321:android:abcdef").build(),
+            "firebase_app_1");
+    cache = CustomInstallationIdCache.getInstance();
+  }
+
+  @After
+  public void cleanUp() throws Exception {
+    Tasks.await(cache.clearAll());
+  }
+
+  @Test
+  public void testReadCacheEntry_Null() {
+    assertNull(cache.readCacheEntryValue(firebaseApp0));
+    assertNull(cache.readCacheEntryValue(firebaseApp1));
+  }
+
+  @Test
+  public void testUpdateAndReadCacheEntry() throws Exception {
+    assertTrue(
+        Tasks.await(
+            cache.insertOrUpdateCacheEntry(
+                firebaseApp0,
+                CustomInstallationIdCacheEntryValue.create(
+                    "123456", "cAAAAAAAAAA", CustomInstallationIdCache.CacheStatus.PENDING))));
+    CustomInstallationIdCacheEntryValue entryValue = cache.readCacheEntryValue(firebaseApp0);
+    assertThat(entryValue.getCustomInstallationId()).isEqualTo("123456");
+    assertThat(entryValue.getFirebaseInstanceId()).isEqualTo("cAAAAAAAAAA");
+    assertThat(entryValue.getCacheStatus())
+        .isEqualTo(CustomInstallationIdCache.CacheStatus.PENDING);
+    assertNull(cache.readCacheEntryValue(firebaseApp1));
+
+    assertTrue(
+        Tasks.await(
+            cache.insertOrUpdateCacheEntry(
+                firebaseApp0,
+                CustomInstallationIdCacheEntryValue.create(
+                    "123456", "cAAAAAAAAAA", CustomInstallationIdCache.CacheStatus.SYNCED))));
+    entryValue = cache.readCacheEntryValue(firebaseApp0);
+    assertThat(entryValue.getCustomInstallationId()).isEqualTo("123456");
+    assertThat(entryValue.getFirebaseInstanceId()).isEqualTo("cAAAAAAAAAA");
+    assertThat(entryValue.getCacheStatus()).isEqualTo(CustomInstallationIdCache.CacheStatus.SYNCED);
+  }
+}

firebase-segmentation/src/main/java/com/google/firebase/segmentation/CustomInstallationIdCache.java

@@ -0,0 +1,130 @@
+// Copyright 2019 Google LLC
+//
+// 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.google.firebase.segmentation;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.gms.common.util.Strings;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.firebase.FirebaseApp;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+class CustomInstallationIdCache {
+
+  // Status of each cache entry
+  // NOTE: never change the ordinal of the enum values because the enum values are stored in cache
+  // as their ordinal numbers.
+  enum CacheStatus {
+    // Cache entry is synced to Firebase backend
+    SYNCED,
+    // Cache entry is waiting for Firebase backend response or pending internal retry for retryable
+    // errors.
+    PENDING,
+    // Cache entry is not accepted by Firebase backend.
+    ERROR,
+  }
+
+  private static final String SHARED_PREFS_NAME = "CustomInstallationIdCache";
+
+  private static final String CUSTOM_INSTALLATION_ID_KEY = "Cid";
+  private static final String INSTANCE_ID_KEY = "Iid";
+  private static final String CACHE_STATUS_KEY = "Status";
+
+  private static CustomInstallationIdCache singleton = null;
+  private final Executor ioExecuter;
+  private final SharedPreferences prefs;
+
+  static CustomInstallationIdCache getInstance() {
+    if (singleton == null) {
+      singleton = new CustomInstallationIdCache();
+    }
+    return singleton;
+  }
+
+  private CustomInstallationIdCache() {
+    // Since different FirebaseApp in the same Android application should have the same application
+    // context and same dir path, so that use the context of the default FirebaseApp to create the
+    // shared preferences.
+    prefs =
+        FirebaseApp.getInstance()
+            .getApplicationContext()
+            .getSharedPreferences(SHARED_PREFS_NAME, Context.MODE_PRIVATE);
+
+    ioExecuter = Executors.newFixedThreadPool(2);
+  }
+
+  @Nullable
+  synchronized CustomInstallationIdCacheEntryValue readCacheEntryValue(FirebaseApp firebaseApp) {
+    String cid =
+        prefs.getString(getSharedPreferencesKey(firebaseApp, CUSTOM_INSTALLATION_ID_KEY), null);
+    String iid = prefs.getString(getSharedPreferencesKey(firebaseApp, INSTANCE_ID_KEY), null);
+    int status = prefs.getInt(getSharedPreferencesKey(firebaseApp, CACHE_STATUS_KEY), -1);
+
+    if (Strings.isEmptyOrWhitespace(cid) || Strings.isEmptyOrWhitespace(iid) || status == -1) {
+      return null;
+    }
+
+    return CustomInstallationIdCacheEntryValue.create(cid, iid, CacheStatus.values()[status]);
+  }
+
+  synchronized Task<Boolean> insertOrUpdateCacheEntry(
+      FirebaseApp firebaseApp, CustomInstallationIdCacheEntryValue entryValue) {
+    SharedPreferences.Editor editor = prefs.edit();
+    editor.putString(
+        getSharedPreferencesKey(firebaseApp, CUSTOM_INSTALLATION_ID_KEY),
+        entryValue.getCustomInstallationId());
+    editor.putString(
+        getSharedPreferencesKey(firebaseApp, INSTANCE_ID_KEY), entryValue.getFirebaseInstanceId());
+    editor.putInt(
+        getSharedPreferencesKey(firebaseApp, CACHE_STATUS_KEY),
+        entryValue.getCacheStatus().ordinal());
+    return commitSharedPreferencesEditAsync(editor);
+  }
+
+  synchronized Task<Boolean> clear(FirebaseApp firebaseApp) {
+    SharedPreferences.Editor editor = prefs.edit();
+    editor.remove(getSharedPreferencesKey(firebaseApp, CUSTOM_INSTALLATION_ID_KEY));
+    editor.remove(getSharedPreferencesKey(firebaseApp, INSTANCE_ID_KEY));
+    editor.remove(getSharedPreferencesKey(firebaseApp, CACHE_STATUS_KEY));
+    return commitSharedPreferencesEditAsync(editor);
+  }
+
+  @VisibleForTesting
+  synchronized Task<Boolean> clearAll() {
+    SharedPreferences.Editor editor = prefs.edit();
+    editor.clear();
+    return commitSharedPreferencesEditAsync(editor);
+  }
+
+  private static String getSharedPreferencesKey(FirebaseApp firebaseApp, String key) {
+    return String.format("%s|%s", firebaseApp.getPersistenceKey(), key);
+  }
+
+  private Task<Boolean> commitSharedPreferencesEditAsync(SharedPreferences.Editor editor) {
+    TaskCompletionSource<Boolean> result = new TaskCompletionSource<Boolean>();
+    ioExecuter.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            result.setResult(editor.commit());
+          }
+        });
+    return result.getTask();
+  }
+}

firebase-segmentation/src/main/java/com/google/firebase/segmentation/CustomInstallationIdCacheEntryValue.java

@@ -0,0 +1,37 @@
+// Copyright 2019 Google LLC
+//
+// 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.google.firebase.segmentation;
+
+import com.google.auto.value.AutoValue;
+import com.google.firebase.segmentation.CustomInstallationIdCache.CacheStatus;
+
+/**
+ * This class represents a cache entry value in {@link CustomInstallationIdCache}, which contains a
+ * Firebase instance id, a custom installation id and the cache status of this entry.
+ */
+@AutoValue
+abstract class CustomInstallationIdCacheEntryValue {
+  abstract String getCustomInstallationId();
+
+  abstract String getFirebaseInstanceId();
+
+  abstract CacheStatus getCacheStatus();
+
+  static CustomInstallationIdCacheEntryValue create(
+      String customInstallationId, String firebaseInstanceId, CacheStatus cacheStatus) {
+    return new AutoValue_CustomInstallationIdCacheEntryValue(
+        customInstallationId, firebaseInstanceId, cacheStatus);
+  }
+}