Merge branch 'executors' into vk.thread_detector

Author: vkryachko

firebase-common/src/main/java/com/google/firebase/concurrent/CustomThreadFactory.java

@@ -14,26 +14,38 @@
 
 package com.google.firebase.concurrent;
 
+import android.os.Process;
+import android.os.StrictMode;
 import java.util.Locale;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
 
 class CustomThreadFactory implements ThreadFactory {
   private static final ThreadFactory DEFAULT = Executors.defaultThreadFactory();
   private final AtomicLong threadCount = new AtomicLong();
   private final String namePrefix;
   private final int priority;
+  private final StrictMode.ThreadPolicy policy;
 
-  CustomThreadFactory(String namePrefix, int priority) {
+  CustomThreadFactory(String namePrefix, int priority, @Nullable StrictMode.ThreadPolicy policy) {
     this.namePrefix = namePrefix;
     this.priority = priority;
+    this.policy = policy;
   }
 
   @Override
   public Thread newThread(Runnable r) {
-    Thread thread = DEFAULT.newThread(r);
-    thread.setPriority(priority);
+    Thread thread =
+        DEFAULT.newThread(
+            () -> {
+              Process.setThreadPriority(priority);
+              if (policy != null) {
+                StrictMode.setThreadPolicy(policy);
+              }
+              r.run();
+            });
     thread.setName(
         String.format(Locale.ROOT, "%s Thread #%d", namePrefix, threadCount.getAndIncrement()));
     return thread;

firebase-common/src/main/java/com/google/firebase/concurrent/ExecutorsRegistrar.java

@@ -15,7 +15,10 @@
 package com.google.firebase.concurrent;
 
 import android.annotation.SuppressLint;
+import android.os.Build;
 import android.os.Process;
+import android.os.StrictMode;
+import com.google.firebase.BuildConfig;
 import com.google.firebase.annotations.concurrent.Background;
 import com.google.firebase.annotations.concurrent.Blocking;
 import com.google.firebase.annotations.concurrent.Lightweight;
@@ -32,23 +35,24 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadFactory;
 
-/** @hide */
 @SuppressLint("ThreadPoolCreation")
 public class ExecutorsRegistrar implements ComponentRegistrar {
   private static final Lazy<ScheduledExecutorService> BG_EXECUTOR =
       new Lazy<>(
           () ->
               scheduled(
                   Executors.newFixedThreadPool(
-                      4, factory("Firebase Background", Process.THREAD_PRIORITY_BACKGROUND))));
+                      4,
+                      factory(
+                          "Firebase Background", Process.THREAD_PRIORITY_BACKGROUND, bgPolicy()))));
 
   private static final Lazy<ScheduledExecutorService> LITE_EXECUTOR =
       new Lazy<>(
           () ->
               scheduled(
                   Executors.newFixedThreadPool(
                       Math.max(2, Runtime.getRuntime().availableProcessors()),
-                      factory("Firebase Lite", Process.THREAD_PRIORITY_DEFAULT))));
+                      factory("Firebase Lite", Process.THREAD_PRIORITY_DEFAULT, litePolicy()))));
 
   private static final Lazy<ScheduledExecutorService> BLOCKING_EXECUTOR =
       new Lazy<>(
@@ -97,6 +101,33 @@ private static ScheduledExecutorService scheduled(ExecutorService delegate) {
   }
 
   private static ThreadFactory factory(String threadPrefix, int priority) {
-    return new CustomThreadFactory(threadPrefix, priority);
+    return new CustomThreadFactory(threadPrefix, priority, null);
+  }
+
+  private static ThreadFactory factory(
+      String threadPrefix, int priority, StrictMode.ThreadPolicy policy) {
+    return new CustomThreadFactory(threadPrefix, priority, policy);
+  }
+
+  private static StrictMode.ThreadPolicy bgPolicy() {
+    StrictMode.ThreadPolicy.Builder builder = new StrictMode.ThreadPolicy.Builder().detectNetwork();
+    if (Build.VERSION.SDK_INT >= 23) {
+      builder.detectResourceMismatches();
+      if (Build.VERSION.SDK_INT >= 26) {
+        builder.detectUnbufferedIo();
+      }
+    }
+    if (BuildConfig.DEBUG) {
+      builder.penaltyDeath();
+    }
+    return builder.penaltyLog().build();
+  }
+
+  private static StrictMode.ThreadPolicy litePolicy() {
+    StrictMode.ThreadPolicy.Builder builder = new StrictMode.ThreadPolicy.Builder().detectAll();
+    if (BuildConfig.DEBUG) {
+      builder.penaltyDeath();
+    }
+    return builder.penaltyLog().build();
   }
 }

firebase-common/src/main/java/com/google/firebase/concurrent/FirebaseExecutors.java

@@ -0,0 +1,49 @@
+// Copyright 2022 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.concurrent;
+
+import java.util.concurrent.Executor;
+
+/** Provides commonly useful executors. */
+public class FirebaseExecutors {
+  private FirebaseExecutors() {}
+
+  /**
+   * Creates a sequential executor.
+   *
+   * <p>Executes tasks sequentially and provides memory synchronization guarantees for any mutations
+   * of shared state.
+   *
+   * <p>For details see:
+   * https://guava.dev/releases/31.1-jre/api/docs/com/google/common/util/concurrent/MoreExecutors.html#newSequentialExecutor(java.util.concurrent.Executor)
+   */
+  public static Executor newSequentialExecutor(Executor delegate) {
+    return new SequentialExecutor(delegate);
+  }
+
+  /** Returns a direct executor. */
+  public static Executor directExecutor() {
+    return DirectExecutor.INSTANCE;
+  }
+
+  private enum DirectExecutor implements Executor {
+    INSTANCE;
+
+    @Override
+    public void execute(Runnable command) {
+      command.run();
+    }
+  }
+}