Merge branch 'master' of github.com:firebase/firebase-android-sdk into floc-master

Author: diwu-arete

firebase-common/src/main/AndroidManifest.xml

@@ -1,11 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest
     xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     package="com.google.firebase">
   <!--Although the *SdkVersion is captured in gradle build files, this is required for non gradle builds-->
   <!--<uses-sdk android:minSdkVersion="14"/>-->
   <application>
 
+    <service android:name="com.google.firebase.components.ComponentDiscoveryService"
+        android:directBootAware="true" android:exported="false"
+        tools:targetApi="n" />
+
     <provider
         android:name="com.google.firebase.provider.FirebaseInitProvider"
         android:authorities="${applicationId}.firebaseinitprovider"

firebase-config/src/main/java/com/google/firebase/remoteconfig/RemoteConfigComponent.java

@@ -60,7 +60,7 @@ public class RemoteConfigComponent {
   /** Name of the file where defaults configs are stored. */
   public static final String DEFAULTS_FILE_NAME = "defaults";
   /** Timeout for the call to the Firebase Remote Config servers in second. */
-  public static final long NETWORK_CONNECTION_TIMEOUT_IN_SECONDS = 5;
+  public static final long NETWORK_CONNECTION_TIMEOUT_IN_SECONDS = 60;
 
   private static final String FIREBASE_REMOTE_CONFIG_FILE_NAME_PREFIX = "frc";
   private static final String PREFERENCES_FILE_NAME = "settings";

firebase-database/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 19.1.0
+- [feature] Added support for the Firebase Database Emulator. To connect to
+  the emulator, specify "http://<emulatorHost>/?ns=<projectId>" as your
+  Database URL (via `FirebaseDatabase.getInstance(String)`).
+  Note that if you are running the Database Emulator on "localhost" and
+  connecting from an app that is running inside an Android Emulator, the
+  emulator host will be "10.0.2.2" followed by its port.
+
 # 18.0.1
 - [changed] The SDK now reports the correct version number (via
   `FirebaseDatabase.getSdkVersion()`).

firebase-database/src/androidTest/java/com/google/firebase/database/DataTest.java

@@ -1081,9 +1081,9 @@ public void urlEncodingAndDecodingWorks()
         new DatabaseReference(
             IntegrationTestValues.getNamespace() + "/a%b&c@d/space: /non-ascii:ø", ctx);
     String result = ref.toString();
-    String expected =
+    String encoded =
         IntegrationTestValues.getNamespace() + "/a%25b%26c%40d/space%3A%20/non-ascii%3A%C3%B8";
-    assertEquals(expected, result);
+    assertEquals(encoded, result);
 
     String child = "" + new Random().nextInt(100000000);
     new WriteFuture(ref.child(child), "testdata").timedGet();

firebase-database/src/androidTest/java/com/google/firebase/database/FirebaseDatabaseTest.java

@@ -170,7 +170,7 @@ public void persistenceSettings() {
     config.setPersistenceCacheSizeBytes(1 * 1024 * 1024);
 
     try {
-      FirebaseDatabase db = new DatabaseReference("", config).getDatabase();
+      FirebaseDatabase db = new DatabaseReference("http://localhost", config).getDatabase();
       db.setPersistenceCacheSizeBytes(1 * 1024 * 1024);
       fail("should throw - can't modify after init");
     } catch (DatabaseException e) {

firebase-database/src/androidTest/java/com/google/firebase/database/RealtimeTest.java

@@ -23,8 +23,6 @@
 import androidx.test.runner.AndroidJUnit4;
 import com.google.firebase.database.core.DatabaseConfig;
 import com.google.firebase.database.core.RepoManager;
-import com.google.firebase.database.core.utilities.ParsedUrl;
-import com.google.firebase.database.core.utilities.Utilities;
 import com.google.firebase.database.future.ReadFuture;
 import com.google.firebase.database.future.WriteFuture;
 import java.util.List;
@@ -48,21 +46,6 @@ public void tearDown() {
     IntegrationTestHelpers.failOnFirstUncaughtException();
   }
 
-  @Test
-  public void testUrlParsing() throws DatabaseException {
-    ParsedUrl parsed = Utilities.parseUrl("http://gsoltis.fblocal.com:9000");
-    assertEquals(parsed.path.toString(), "/");
-    assertEquals(parsed.repoInfo.host, "gsoltis.fblocal.com:9000");
-    assertEquals(parsed.repoInfo.internalHost, "gsoltis.fblocal.com:9000");
-    assertEquals(parsed.repoInfo.secure, false);
-
-    parsed = Utilities.parseUrl("http://gsoltis.firebaseio.com/foo/bar");
-    assertEquals(parsed.path.toString(), "/foo/bar");
-    assertEquals(parsed.repoInfo.host, "gsoltis.firebaseio.com");
-    assertEquals(parsed.repoInfo.internalHost, "gsoltis.firebaseio.com");
-    assertEquals(parsed.repoInfo.secure, true);
-  }
-
   @Test
   public void testOnDisconnectSetWorks()
       throws DatabaseException, TestFailure, TimeoutException, InterruptedException {

firebase-database/src/main/java/com/google/firebase/database/core/utilities/DefaultRunLoop.java

@@ -128,13 +128,20 @@ public static String messageForException(Throwable t) {
           + "https://firebase.google.com/docs/database/ios/structure-data#best_practices_for_data_structure"
           + " and "
           + "https://firebase.google.com/docs/database/android/retrieve-data#filtering_data";
+    } else if (t instanceof NoClassDefFoundError) {
+      return "A symbol that the Firebase Database SDK depends on failed to load. This usually "
+          + "indicates that your project includes an incompatible version of another Firebase "
+          + "dependency. If updating your dependencies to the latest version does not resolve "
+          + "this issue, please file a report at https://github.com/firebase/firebase-android-sdk";
     } else if (t instanceof DatabaseException) {
       // Exception should be self-explanatory and they shouldn't contact support.
       return "";
     } else {
       return "Uncaught exception in Firebase Database runloop ("
           + FirebaseDatabase.getSdkVersion()
-          + "). Please report to [email protected]";
+          + "). If you are not already on the latest version of the Firebase SDKs, try updating "
+          + "your dependencies. Should this problem persist, please file a report at "
+          + "https://github.com/firebase/firebase-android-sdk";
     }
   }
 }

firebase-database/src/main/java/com/google/firebase/database/core/utilities/ParsedUrl.java

@@ -21,4 +21,15 @@ public class ParsedUrl {
 
   public RepoInfo repoInfo;
   public Path path;
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    ParsedUrl parsedUrl = (ParsedUrl) o;
+
+    if (!repoInfo.equals(parsedUrl.repoInfo)) return false;
+    return path.equals(parsedUrl.path);
+  }
 }

firebase-database/src/main/java/com/google/firebase/database/core/utilities/Utilities.java

@@ -14,6 +14,7 @@
 
 package com.google.firebase.database.core.utilities;
 
+import android.net.Uri;
 import android.util.Base64;
 import com.google.android.gms.tasks.Task;
 import com.google.android.gms.tasks.TaskCompletionSource;
@@ -23,83 +24,85 @@
 import com.google.firebase.database.core.Path;
 import com.google.firebase.database.core.RepoInfo;
 import java.io.UnsupportedEncodingException;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.net.URLEncoder;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
-import java.util.ArrayList;
 import java.util.Map;
 
 public class Utilities {
   private static final char[] HEX_CHARACTERS = "0123456789abcdef".toCharArray();
 
   public static ParsedUrl parseUrl(String url) throws DatabaseException {
-    String original = url;
     try {
-      int schemeOffset = original.indexOf("//");
-      if (schemeOffset == -1) {
-        throw new URISyntaxException(original, "Invalid scheme specified");
-      }
-      int pathOffset = original.substring(schemeOffset + 2).indexOf("/");
-      if (pathOffset != -1) {
-        pathOffset += schemeOffset + 2;
-        String[] pathSegments = original.substring(pathOffset).split("/", -1);
-        StringBuilder builder = new StringBuilder();
-        for (int i = 0; i < pathSegments.length; ++i) {
-          if (!pathSegments[i].equals("")) {
-            builder.append("/");
-            builder.append(URLEncoder.encode(pathSegments[i], "UTF-8"));
-          }
-        }
-        original = original.substring(0, pathOffset) + builder.toString();
-      }
+      Uri uri = Uri.parse(url);
 
-      URI uri = new URI(original);
-      // URLEncoding a space turns it into a '+', which is different
-      // from our expected behavior. Do a manual replace to fix it.
-      String pathString = uri.getPath().replace("+", " ");
-      Validation.validateRootPathString(pathString);
-      Path path = new Path(pathString);
       String scheme = uri.getScheme();
+      if (scheme == null) {
+        throw new IllegalArgumentException("Database URL does not specify a URL scheme");
+      }
+
+      String host = uri.getHost();
+      if (host == null) {
+        throw new IllegalArgumentException("Database URL does not specify a valid host");
+      }
 
       RepoInfo repoInfo = new RepoInfo();
-      repoInfo.host = uri.getHost().toLowerCase();
+      repoInfo.host = host.toLowerCase();
 
       int port = uri.getPort();
       if (port != -1) {
-        repoInfo.secure = scheme.equals("https");
+        repoInfo.secure = scheme.equals("https") || scheme.equals("wss");
         repoInfo.host += ":" + port;
       } else {
         repoInfo.secure = true;
       }
-      String[] parts = repoInfo.host.split("\\.", -1);
 
-      repoInfo.namespace = parts[0].toLowerCase();
+      String namespaceParam = uri.getQueryParameter("ns");
+      if (namespaceParam != null) {
+        repoInfo.namespace = namespaceParam;
+      } else {
+        String[] parts = host.split("\\.", -1);
+        repoInfo.namespace = parts[0].toLowerCase();
+      }
+
       repoInfo.internalHost = repoInfo.host;
+
+      String originalPathString = extractPathString(url);
+      // URLEncoding a space turns it into a '+', which is different
+      // from our expected behavior. Do a manual replace to fix it.
+      originalPathString = originalPathString.replace("+", " ");
+      Validation.validateRootPathString(originalPathString);
+
       ParsedUrl parsedUrl = new ParsedUrl();
-      parsedUrl.path = path;
+      parsedUrl.path = new Path(originalPathString);
       parsedUrl.repoInfo = repoInfo;
-      return parsedUrl;
 
-    } catch (URISyntaxException e) {
-      throw new DatabaseException("Invalid Firebase Database url specified", e);
-    } catch (UnsupportedEncodingException e) {
-      throw new DatabaseException("Failed to URLEncode the path", e);
+      return parsedUrl;
+    } catch (Exception e) {
+      throw new DatabaseException("Invalid Firebase Database url specified: " + url, e);
     }
   }
 
-  public static String[] splitIntoFrames(String src, int maxFrameSize) {
-    if (src.length() <= maxFrameSize) {
-      return new String[] {src};
-    } else {
-      ArrayList<String> segs = new ArrayList<String>();
-      for (int i = 0; i < src.length(); i += maxFrameSize) {
-        int end = Math.min(i + maxFrameSize, src.length());
-        String seg = src.substring(i, end);
-        segs.add(seg);
+  /**
+   * Extracts the path string from the original URL without changing the encoding (unlike
+   * Uri.getPath()).
+   */
+  private static String extractPathString(String originalUrl) {
+    int schemeOffset = originalUrl.indexOf("//");
+    if (schemeOffset == -1) {
+      throw new DatabaseException("Firebase Database URL is missing URL scheme");
+    }
+
+    String urlWithoutScheme = originalUrl.substring(schemeOffset + 2);
+    int pathOffset = urlWithoutScheme.indexOf("/");
+    if (pathOffset != -1) {
+      int queryOffset = urlWithoutScheme.indexOf("?");
+      if (queryOffset != -1) {
+        return urlWithoutScheme.substring(pathOffset + 1, queryOffset);
+      } else {
+        return urlWithoutScheme.substring(pathOffset + 1);
       }
-      return segs.toArray(new String[segs.size()]);
+    } else {
+      return "";
     }
   }
 

firebase-database/src/test/java/com/google/firebase/database/core/utilities/ParseUrlTest.java

@@ -0,0 +1,93 @@
+// 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.database.core.utilities;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.firebase.database.DatabaseException;
+import org.junit.Test;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@org.junit.runner.RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class ParseUrlTest {
+
+  @Test
+  public void testUrlParsing() throws DatabaseException {
+    ParsedUrl parsed = Utilities.parseUrl("http://gsoltis.fblocal.com:9000");
+    assertEquals("/", parsed.path.toString());
+    assertEquals("gsoltis.fblocal.com:9000", parsed.repoInfo.host);
+    assertEquals("gsoltis.fblocal.com:9000", parsed.repoInfo.internalHost);
+
+    parsed = Utilities.parseUrl("http://gsoltis.firebaseio.com/foo/bar");
+    assertEquals("/foo/bar", parsed.path.toString());
+    assertEquals("gsoltis.firebaseio.com", parsed.repoInfo.host);
+    assertEquals("gsoltis.firebaseio.com", parsed.repoInfo.internalHost);
+
+    parsed = Utilities.parseUrl("http://gsoltis.firebaseio.com/foo/empty space");
+    assertEquals("/foo/empty space", parsed.path.toString());
+    assertEquals("gsoltis.firebaseio.com", parsed.repoInfo.host);
+    assertEquals("gsoltis.firebaseio.com", parsed.repoInfo.internalHost);
+
+    parsed = Utilities.parseUrl("http://gsoltis.firebaseio.com/foo/\\;:@\uD83D\uDE00");
+    assertEquals("/foo/\\;:@\uD83D\uDE00", parsed.path.toString());
+    assertEquals("gsoltis.firebaseio.com", parsed.repoInfo.host);
+    assertEquals("gsoltis.firebaseio.com", parsed.repoInfo.internalHost);
+  }
+
+  @Test
+  public void testUrlParsingTurnsPlusIntoSpace() throws DatabaseException {
+    ParsedUrl parsed = Utilities.parseUrl("http://gsoltis.firebaseio.com/+");
+    assertEquals("/ ", parsed.path.toString());
+  }
+
+  @Test
+  public void testUrlParsingSpecialCharacters() throws DatabaseException {
+    ParsedUrl parsed =
+        Utilities.parseUrl("http://gsoltis.firebaseio.com/a%b&c@d/+space: /non-ascii:ø");
+    assertEquals("/a%b&c@d/ space: /non-ascii:ø", parsed.path.toString());
+  }
+
+  @Test
+  public void testUrlParsingIgnoresTrailingSlash() throws DatabaseException {
+    ParsedUrl parsed1 = Utilities.parseUrl("http://gsoltis.firebaseio.com/");
+    ParsedUrl parsed2 = Utilities.parseUrl("http://gsoltis.firebaseio.com");
+    assertEquals(parsed1, parsed2);
+  }
+
+  @Test
+  public void testUrlParsingWithNamespace() throws DatabaseException {
+    ParsedUrl parsed = Utilities.parseUrl("http://localhost/foo/bar?ns=mrschmidt");
+    assertEquals("mrschmidt", parsed.repoInfo.namespace);
+
+    parsed = Utilities.parseUrl("http://10.0.2.2:9000/foo/bar?ns=mrschmidt");
+    assertEquals(parsed.path.toString(), "/foo/bar");
+    assertEquals("mrschmidt", parsed.repoInfo.namespace);
+  }
+
+  @Test
+  public void testUrlParsingSslDetection() throws DatabaseException {
+    // Hosts with custom ports are considered non-secure
+    ParsedUrl parsed = Utilities.parseUrl("http://gsoltis.fblocal.com:9000");
+    assertFalse(parsed.repoInfo.secure);
+
+    // Hosts with the default ports are considered secure
+    parsed = Utilities.parseUrl("http://gsoltis.firebaseio.com");
+    assertTrue(parsed.repoInfo.secure);
+  }
+}

firebase-firestore/CHANGELOG.md

@@ -1,4 +1,6 @@
 # Unreleased
+
+# 21.0.0
 - [changed] Transactions are now more flexible. Some sequences of operations
   that were previously incorrectly disallowed are now allowed. For example,
   after reading a document that doesn't exist, you can now set it multiple