Fix fcm dependency

firebase-common/src/main/java/com/google/firebase/FirebaseApp.java

@@ -27,6 +27,7 @@
 import android.os.Looper;
 import android.text.TextUtils;
 import android.util.Log;
+import androidx.annotation.GuardedBy;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.RestrictTo;
@@ -59,7 +60,6 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * The entry point of Firebase SDKs. It holds common configuration and state for Firebase APIs. Most

firebase-messaging/firebase-messaging.gradle

@@ -100,7 +100,8 @@ dependencies {
  implementation 'com.google.firebase:firebase-measurement-connector:19.0.0'
  implementation "com.google.firebase:firebase-iid-interop:17.1.0"
  implementation 'com.google.android.gms:play-services-cloud-messaging:17.0.1'
- implementation ("com.google.api-client:google-api-client:1.30.9") {
+ implementation "com.google.errorprone:error_prone_annotations:2.9.0"
+ testImplementation ("com.google.api-client:google-api-client:1.30.9") {
  exclude group: "org.apache.httpcomponents", module: "httpclient"
  }
  testCompileOnly 'com.google.auto.value:auto-value-annotations:1.6.3'

firebase-messaging/src/main/java/com/google/firebase/messaging/ByteStreams.java

@@ -0,0 +1,201 @@
+// Copyright 2020 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.messaging;
+
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+
+/** @hide */
+final class ByteStreams {
+
+ private static final int BUFFER_SIZE = 8192;
+
+ /** Creates a new byte array for buffering reads or writes. */
+ static byte[] createBuffer() {
+ return new byte[BUFFER_SIZE];
+ }
+
+ private static int saturatedCast(long value) {
+ if (value > Integer.MAX_VALUE) {
+ return Integer.MAX_VALUE;
+ }
+ if (value < Integer.MIN_VALUE) {
+ return Integer.MIN_VALUE;
+ }
+ return (int) value;
+ }
+
+ private ByteStreams() {}
+
+ /** Max array length on JVM. */
+ private static final int MAX_ARRAY_LEN = Integer.MAX_VALUE - 8;
+
+ /** Large enough to never need to expand, given the geometric progression of buffer sizes. */
+ private static final int TO_BYTE_ARRAY_DEQUE_SIZE = 20;
+
+ /**
+ * Returns a byte array containing the bytes from the buffers already in {@code bufs} (which have
+ * a total combined length of {@code totalLen} bytes) followed by all bytes remaining in the given
+ * input stream.
+ */
+ private static byte[] toByteArrayInternal(InputStream in, Queue<byte[]> bufs, int totalLen)
+ throws IOException {
+ // Roughly size to match what has been read already. Some file systems, such as procfs, return 0
+ // as their length. These files are very small, so it's wasteful to allocate an 8KB buffer.
+ int initialBufferSize = min(BUFFER_SIZE, max(128, Integer.highestOneBit(totalLen) * 2));
+ // Starting with an 8k buffer, double the size of each successive buffer. Smaller buffers
+ // quadruple in size until they reach 8k, to minimize the number of small reads for longer
+ // streams. Buffers are retained in a deque so that there's no copying between buffers while
+ // reading and so all of the bytes in each new allocated buffer are available for reading from
+ // the stream.
+ for (int bufSize = initialBufferSize;
+ totalLen < MAX_ARRAY_LEN;
+ bufSize = saturatedCast((long) bufSize * (bufSize < 4096 ? 4 : 2))) {
+ byte[] buf = new byte[min(bufSize, MAX_ARRAY_LEN - totalLen)];
+ bufs.add(buf);
+ int off = 0;
+ while (off < buf.length) {
+ // always OK to fill buf; its size plus the rest of bufs is never more than MAX_ARRAY_LEN
+ int r = in.read(buf, off, buf.length - off);
+ if (r == -1) {
+ return combineBuffers(bufs, totalLen);
+ }
+ off += r;
+ totalLen += r;
+ }
+ }
+
+ // read MAX_ARRAY_LEN bytes without seeing end of stream
+ if (in.read() == -1) {
+ // oh, there's the end of the stream
+ return combineBuffers(bufs, MAX_ARRAY_LEN);
+ } else {
+ throw new OutOfMemoryError("input is too large to fit in a byte array");
+ }
+ }
+
+ private static byte[] combineBuffers(Queue<byte[]> bufs, int totalLen) {
+ if (bufs.isEmpty()) {
+ return new byte[0];
+ }
+ byte[] result = bufs.remove();
+ if (result.length == totalLen) {
+ return result;
+ }
+ int remaining = totalLen - result.length;
+ result = Arrays.copyOf(result, totalLen);
+ while (remaining > 0) {
+ byte[] buf = bufs.remove();
+ int bytesToCopy = min(remaining, buf.length);
+ int resultOffset = totalLen - remaining;
+ System.arraycopy(buf, 0, result, resultOffset, bytesToCopy);
+ remaining -= bytesToCopy;
+ }
+ return result;
+ }
+
+ /**
+ * Reads all bytes from an input stream into a byte array. Does not close the stream.
+ *
+ * @param in the input stream to read from
+ * @return a byte array containing all the bytes from the stream
+ * @throws IOException if an I/O error occurs
+ */
+ public static byte[] toByteArray(InputStream in) throws IOException {
+ return toByteArrayInternal(in, new ArrayDeque<byte[]>(TO_BYTE_ARRAY_DEQUE_SIZE), 0);
+ }
+
+ public static InputStream limit(InputStream in, long limit) {
+ return new LimitedInputStream(in, limit);
+ }
+
+ private static final class LimitedInputStream extends FilterInputStream {
+
+ private long left;
+ private long mark = -1;
+
+ LimitedInputStream(InputStream in, long limit) {
+ super(in);
+ left = limit;
+ }
+
+ @Override
+ public int available() throws IOException {
+ return (int) Math.min(in.available(), left);
+ }
+
+ // it's okay to mark even if mark isn't supported, as reset won't work
+ @Override
+ public synchronized void mark(int readLimit) {
+ in.mark(readLimit);
+ mark = left;
+ }
+
+ @Override
+ public int read() throws IOException {
+ if (left == 0) {
+ return -1;
+ }
+
+ int result = in.read();
+ if (result != -1) {
+ --left;
+ }
+ return result;
+ }
+
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ if (left == 0) {
+ return -1;
+ }
+
+ len = (int) Math.min(len, left);
+ int result = in.read(b, off, len);
+ if (result != -1) {
+ left -= result;
+ }
+ return result;
+ }
+
+ @Override
+ public synchronized void reset() throws IOException {
+ if (!in.markSupported()) {
+ throw new IOException("Mark not supported");
+ }
+ if (mark == -1) {
+ throw new IOException("Mark not set");
+ }
+
+ in.reset();
+ left = mark;
+ }
+
+ @Override
+ public long skip(long n) throws IOException {
+ n = Math.min(n, left);
+ long skipped = in.skip(n);
+ left -= skipped;
+ return skipped;
+ }
+ }
+}

firebase-messaging/src/main/java/com/google/firebase/messaging/FcmBroadcastProcessor.java

@@ -21,14 +21,14 @@
 import android.os.Build;
 import android.util.Base64;
 import android.util.Log;
+import androidx.annotation.GuardedBy;
 import com.google.android.gms.common.annotation.KeepForSdk;
 import com.google.android.gms.common.util.PlatformVersion;
 import com.google.android.gms.common.util.VisibleForTesting;
 import com.google.android.gms.tasks.Task;
 import com.google.android.gms.tasks.Tasks;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Processes incoming FCM broadcasts.

firebase-messaging/src/main/java/com/google/firebase/messaging/FirebaseMessaging.java

@@ -28,6 +28,7 @@
 import android.os.Build;
 import android.text.TextUtils;
 import android.util.Log;
+import androidx.annotation.GuardedBy;
 import androidx.annotation.Keep;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -54,7 +55,6 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Top level <a href="https://firebase.google.com/docs/cloud-messaging/">Firebase Cloud

firebase-messaging/src/main/java/com/google/firebase/messaging/ImageDownload.java

@@ -23,7 +23,6 @@
 import androidx.annotation.Nullable;
 import com.google.android.gms.tasks.Task;
 import com.google.android.gms.tasks.TaskCompletionSource;
-import com.google.common.io.ByteStreams;
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;

firebase-messaging/src/main/java/com/google/firebase/messaging/Metadata.java

@@ -21,13 +21,13 @@
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.util.Log;
+import androidx.annotation.GuardedBy;
 import androidx.annotation.IntDef;
 import com.google.android.gms.common.util.PlatformVersion;
 import com.google.firebase.FirebaseApp;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.List;
-import javax.annotation.concurrent.GuardedBy;
 
 /** Helper to query app's metadata. */
 class Metadata {

firebase-messaging/src/main/java/com/google/firebase/messaging/RequestDeduplicator.java

@@ -16,11 +16,11 @@
 import static com.google.firebase.messaging.FirebaseMessaging.TAG;
 
 import android.util.Log;
+import androidx.annotation.GuardedBy;
 import androidx.collection.ArrayMap;
 import com.google.android.gms.tasks.Task;
 import java.util.Map;
 import java.util.concurrent.Executor;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Deduplicates concurrent requests for FCM tokens into the same request to GmsCore/FCM backend.

firebase-messaging/src/main/java/com/google/firebase/messaging/ServiceStarter.java

@@ -25,14 +25,14 @@
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
 import android.util.Log;
+import androidx.annotation.GuardedBy;
 import androidx.annotation.MainThread;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import com.google.android.gms.common.annotation.KeepForSdk;
 import com.google.firebase.iid.FirebaseInstanceIdReceiver;
 import java.util.ArrayDeque;
 import java.util.Queue;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Manages securely starting the app's FirebaseMessagingService implementation even though they are

firebase-messaging/src/main/java/com/google/firebase/messaging/SyncTask.java

@@ -26,14 +26,14 @@
 import android.os.PowerManager;
 import android.os.PowerManager.WakeLock;
 import android.util.Log;
+import androidx.annotation.Nullable;
 import com.google.android.gms.common.util.VisibleForTesting;
 import com.google.android.gms.common.util.concurrent.NamedThreadFactory;
 import java.io.IOException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.Nullable;
 
 /** Background task to perform sync operations with the Firebase backend using a bg thread */
 class SyncTask implements Runnable {

firebase-messaging/src/main/java/com/google/firebase/messaging/WakeLockHolder.java

@@ -17,12 +17,12 @@
 import android.content.Context;
 import android.content.Intent;
 import android.os.PowerManager;
+import androidx.annotation.GuardedBy;
 import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
 import com.google.android.gms.stats.WakeLock;
 import com.google.errorprone.annotations.RestrictedApi;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Helper class to manage wake locks in FCM.