Replace FocusDelaySyncJobService by Worker (#1515)

* On focus delay service is replaced by a Worker
* JobService is not stopped by the system after completed

Author: Jeasmine

OneSignalSDK/onesignal/src/main/AndroidManifest.xml

@@ -90,19 +90,11 @@
             android:permission="android.permission.BIND_JOB_SERVICE"
             android:exported="false" />
 
-        <service
-          android:name="com.onesignal.FocusDelaySyncService"
-          android:stopWithTask="true"
-          android:exported="false"/>
-        <service
-          android:name="com.onesignal.FocusDelaySyncJobService"
-          android:permission="android.permission.BIND_JOB_SERVICE"
-          android:exported="false" />
-
         <service
           android:name="com.onesignal.SyncService"
           android:stopWithTask="true"
           android:exported="false" />
+
         <service
           android:name="com.onesignal.SyncJobService"
           android:permission="android.permission.BIND_JOB_SERVICE"

OneSignalSDK/onesignal/src/main/java/com/onesignal/ActivityLifecycleHandler.java

@@ -29,7 +29,6 @@
 
 import android.annotation.SuppressLint;
 import android.app.Activity;
-import android.content.Context;
 import android.content.pm.ActivityInfo;
 import android.content.res.Configuration;
 import android.os.Build;
@@ -56,17 +55,24 @@ void lostFocus() {
         }
     }
 
-    private static final Object SYNC_LOCK = new Object();
-    private static final String FOCUS_LOST_WORKER_TAG = "FOCUS_LOST_WORKER_TAG";
     private static final Map<String, ActivityAvailableListener> sActivityAvailableListeners = new ConcurrentHashMap<>();
     private static final Map<String, OSSystemConditionController.OSSystemConditionObserver> sSystemConditionObservers = new ConcurrentHashMap<>();
     private static final Map<String, KeyboardListener> sKeyboardListeners = new ConcurrentHashMap<>();
 
-    private static AppFocusRunnable appFocusRunnable;
+    private static final String FOCUS_LOST_WORKER_TAG = "FOCUS_LOST_WORKER_TAG";
+    // We want to perform a on_focus sync as soon as the session is done to report the time
+    private static final int SYNC_AFTER_BG_DELAY_MS = 2000;
+
+    private final OSFocusHandler focusHandler;
+
     @SuppressLint("StaticFieldLeak")
     private Activity curActivity = null;
     private boolean nextResumeIsFirstActivity = false;
 
+    public ActivityLifecycleHandler(OSFocusHandler focusHandler) {
+        this.focusHandler = focusHandler;
+    }
+
     void onConfigurationChanged(Configuration newConfig, Activity activity) {
         // If Activity contains the configChanges orientation flag, re-create the view this way
         if (curActivity != null && OSUtils.hasConfigChangeFlag(curActivity, ActivityInfo.CONFIG_ORIENTATION)) {
@@ -166,23 +172,23 @@ private void onOrientationChanged(Activity activity) {
 
     private void handleLostFocus() {
         OneSignal.onesignalLog(OneSignal.LOG_LEVEL.DEBUG, "ActivityLifecycleHandler Handling lost focus");
-        if (appFocusRunnable != null && appFocusRunnable.backgrounded && !appFocusRunnable.completed)
+        if (focusHandler == null || focusHandler.hasBackgrounded() && !focusHandler.hasCompleted())
             return;
 
         OneSignal.getFocusTimeController().appStopped();
-        OSFocusDelaySync.getInstance().scheduleSyncTask(OneSignal.appContext);
+        focusHandler.startOnLostFocusWorker(FOCUS_LOST_WORKER_TAG, SYNC_AFTER_BG_DELAY_MS, OneSignal.appContext);
     }
 
     private void handleFocus() {
-        OneSignal.onesignalLog(OneSignal.LOG_LEVEL.DEBUG, "ActivityLifecycleHandler handleFocus, with runnable: " + appFocusRunnable + " nextResumeIsFirstActivity: " + nextResumeIsFirstActivity);
-        if (hasBackgrounded() || nextResumeIsFirstActivity) {
+        OneSignal.onesignalLog(OneSignal.LOG_LEVEL.DEBUG, "ActivityLifecycleHandler handleFocus, nextResumeIsFirstActivity: " + nextResumeIsFirstActivity);
+        if (focusHandler.hasBackgrounded() || nextResumeIsFirstActivity) {
             OneSignal.onesignalLog(OneSignal.LOG_LEVEL.DEBUG, "ActivityLifecycleHandler reset background state, call app focus");
             nextResumeIsFirstActivity = false;
-            resetBackgroundState();
+            focusHandler.resetBackgroundState();
             OneSignal.onAppFocus();
         } else {
-            OneSignal.onesignalLog(OneSignal.LOG_LEVEL.DEBUG, "ActivityLifecycleHandler cancel background lost focus sync task");
-            OSFocusDelaySync.getInstance().cancelBackgroundSyncTask(OneSignal.appContext);
+            OneSignal.onesignalLog(OneSignal.LOG_LEVEL.DEBUG, "ActivityLifecycleHandler cancel background lost focus worker");
+            focusHandler.cancelOnLostFocusWorker(FOCUS_LOST_WORKER_TAG, OneSignal.appContext);
         }
     }
 
@@ -249,46 +255,6 @@ void setNextResumeIsFirstActivity(boolean nextResumeIsFirstActivity) {
         this.nextResumeIsFirstActivity = nextResumeIsFirstActivity;
     }
 
-    void resetBackgroundState() {
-        if (appFocusRunnable != null)
-            appFocusRunnable.backgrounded = false;
-    }
-
-    boolean hasBackgrounded() {
-        return appFocusRunnable != null && appFocusRunnable.backgrounded;
-    }
-
-    static void runLostFocusLogic(Context context) {
-        OneSignal.onesignalLog(OneSignal.LOG_LEVEL.DEBUG, "ActivityLifecycleHandler runLostFocusLogic");
-        ActivityLifecycleHandler activityLifecycleHandler = ActivityLifecycleListener.getActivityLifecycleHandler();
-        if (activityLifecycleHandler == null || activityLifecycleHandler.curActivity == null)
-            OneSignal.setInForeground(false);
-        appFocusRunnable = new AppFocusRunnable();
-        OSFocusDelaySync.getInstance().doBackgroundSync(
-                context,
-                appFocusRunnable
-        );
-    }
-
-    static class AppFocusRunnable implements Runnable {
-        private boolean backgrounded, completed;
-
-        public void run() {
-            OneSignal.onesignalLog(OneSignal.LOG_LEVEL.DEBUG, "ActivityLifecycleHandler running AppFocusRunnable");
-            backgrounded = true;
-            OneSignal.onAppLostFocus();
-            completed = true;
-        }
-
-        @Override
-        public String toString() {
-            return "AppFocusRunnable{" +
-                    "backgrounded=" + backgrounded +
-                    ", completed=" + completed +
-                    '}';
-        }
-    }
-
     static class KeyboardListener implements ViewTreeObserver.OnGlobalLayoutListener {
 
         private final OSSystemConditionController.OSSystemConditionObserver observer;

OneSignalSDK/onesignal/src/main/java/com/onesignal/ActivityLifecycleListener.java

@@ -53,7 +53,7 @@ static void registerActivityLifecycleCallbacks(@NonNull final Application applic
       }
 
       if (activityLifecycleHandler == null) {
-         activityLifecycleHandler = new ActivityLifecycleHandler();
+         activityLifecycleHandler = new ActivityLifecycleHandler(new OSFocusHandler());
       }
 
       // Configuration change listener setup

OneSignalSDK/onesignal/src/main/java/com/onesignal/FocusDelaySyncJobService.java

@@ -0,0 +1,95 @@
+/**
+ * Modified MIT License
+ * <p>
+ * Copyright 2022 OneSignal
+ * <p>
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * <p>
+ * 1. The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * <p>
+ * 2. All copies of substantial portions of the Software may only be used in connection
+ * with services provided by OneSignal.
+ * <p>
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.onesignal
+
+import android.content.Context
+import androidx.work.*
+import java.util.concurrent.TimeUnit
+
+class OSFocusHandler {
+
+    fun hasBackgrounded() = backgrounded
+
+    fun hasCompleted() = completed
+
+    fun resetBackgroundState() {
+        backgrounded = false
+    }
+
+    fun startOnLostFocusWorker(tag: String, delay: Long, context: Context)  {
+        val constraints = buildConstraints()
+        val workRequest = OneTimeWorkRequest.Builder(OnLostFocusWorker::class.java)
+            .setConstraints(constraints)
+            .setInitialDelay(delay, TimeUnit.MILLISECONDS)
+            .addTag(tag)
+            .build()
+        WorkManager.getInstance(context)
+            .enqueueUniqueWork(
+                tag,
+                ExistingWorkPolicy.KEEP,
+                workRequest
+            )
+    }
+
+    fun cancelOnLostFocusWorker(tag: String, context: Context) {
+        WorkManager.getInstance(context).cancelAllWorkByTag(tag)
+    }
+
+    private fun buildConstraints(): Constraints {
+        return Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+    }
+
+    class OnLostFocusWorker(context: Context, workerParams: WorkerParameters) :
+        Worker(context, workerParams) {
+        override fun doWork(): Result {
+            onLostFocusDoWork()
+            return Result.success()
+        }
+    }
+
+    companion object {
+        private var backgrounded = false
+        private var completed = false
+
+        fun onLostFocusDoWork() {
+            val activityLifecycleHandler = ActivityLifecycleListener.getActivityLifecycleHandler()
+            if (activityLifecycleHandler == null || activityLifecycleHandler.curActivity == null) {
+                OneSignal.setInForeground(false)
+            }
+            OneSignal.onesignalLog(
+                OneSignal.LOG_LEVEL.DEBUG,
+                "OSFocusHandler running onAppLostFocus"
+            )
+            backgrounded = true
+            OneSignal.onAppLostFocus()
+            completed = true
+        }
+    }
+}