E2-2014 Moved SQLite writes to background thread (#372)

* E2-2014 Moved SQLite writes to background thread

* Fixing failing tests

* Fixing failing test

* Fixing failing tests

* Fixing failing tests

* Fixing failing tests

Author: milos1290

AndroidSDKCore/src/main/java/com/leanplum/internal/Operation.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2019, Leanplum, Inc. All rights reserved.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.leanplum.internal;
+
+import android.os.Handler;
+import android.os.Looper;
+
+
+public class Operation extends Thread {
+
+    private static final Handler handler = new Handler(Looper.getMainLooper());
+
+    private Runnable runnable;
+
+    protected Operation(Runnable runnable) {
+        this.runnable = runnable;
+    }
+
+    /**
+     * Helper methods to execute runnable on main thread
+     *
+     * @param runnable to executes
+     */
+    public static void runOnUiThread(Runnable runnable) {
+        handler.post(runnable);
+    }
+
+    /**
+     * Helper methods to execute runnable on main thread after delay
+     *
+     * @param runnable to executes
+     */
+    public static void runOnUiThreadAfterDelay(Runnable runnable, long delayTimeMillis) {
+        handler.postDelayed(runnable, delayTimeMillis);
+    }
+
+    /**
+     * Helper methods to remove runnable from main thread
+     *
+     * @param runnable to remove
+     */
+    public static void removeOperationOnUiThread(Runnable runnable) {
+        handler.removeCallbacks(runnable);
+    }
+
+    @Override
+    public void run() {
+        if (runnable != null) {
+            runnable.run();
+        }
+    }
+}

AndroidSDKCore/src/main/java/com/leanplum/internal/OperationQueue.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2019, Leanplum, Inc. All rights reserved.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.leanplum.internal;
+
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Process;
+
+public class OperationQueue {
+
+    private static OperationQueue instance;
+
+    private static final String OPERATION_QUEUE_NAME = "com.leanplum.operation_queue";
+    private static final int OPERATION_QUEUE_PRIORITY = Process.THREAD_PRIORITY_DEFAULT;
+
+    private HandlerThread handlerThread;
+    private Handler handler;
+
+    public static OperationQueue sharedInstance() {
+        if (instance == null) {
+            instance = new OperationQueue();
+        }
+        return instance;
+    }
+
+    OperationQueue() {
+        start();
+    }
+
+    /**
+     * Start the underlying thread, call to this method is optional.
+     */
+    void start() {
+        if (handlerThread == null) {
+            handlerThread = new HandlerThread(OPERATION_QUEUE_NAME, OPERATION_QUEUE_PRIORITY);
+            handlerThread.start();
+        }
+
+        handler = new Handler(handlerThread.getLooper());
+    }
+
+    /**
+     * Stop OperationQueue and remove all operations
+     */
+    void stop() {
+        removeAllOperations();
+
+        handlerThread.quit();
+        handlerThread = null;
+    }
+
+    /**
+     * Add operation to OperationQueue at the end
+     * @param operation The operation that will be executed.
+     * @return return true if the operation was successfully placed in to the operation queue. Returns false on failure.
+     */
+    boolean addOperation(Runnable operation) {
+        if (operation != null && handler != null) {
+            return handler.post(new Operation(operation));
+        }
+        return false;
+    }
+
+    /**
+     * Add operation to OperationQueue at the front
+     * @param operation The operation that will be executed.
+     * @return return true if the operation was successfully placed in to the operation queue. Returns false on failure.
+     */
+    boolean addOperationAtFront(Runnable operation) {
+        if (operation != null && handler != null) {
+            return handler.postAtFrontOfQueue(new Operation(operation));
+        }
+        return false;
+    }
+
+    /**
+     * Add operation to OperationQueue, to be run at a specific time given by millis.
+     * @param operation operation The operation that will be executed.
+     * @return return true if the operation was successfully placed in to the operation queue. Returns false on failure.
+     */
+    boolean addOperationAtTime(Runnable operation, long millis) {
+        if (operation != null && handler != null) {
+            return handler.postAtTime(new Operation(operation), millis);
+        }
+        return false;
+    }
+
+    /**
+     * Add operation to OperationQueue, to be run after the specific time given by delayMillis.
+     * @param operation operation operation The operation that will be executed.
+     * @param delayMillis
+     * @return return true if the operation was successfully placed in to the operation queue. Returns false on failure.
+     */
+    boolean addOperationAfterDelay(Runnable operation, long delayMillis) {
+        if (operation != null && handler != null) {
+            return handler.postDelayed(new Operation(operation), delayMillis);
+        }
+        return false;
+    }
+
+    /**
+     * Remove all pending Operations that are in OperationQueue
+     */
+    void removeAllOperations() {
+        if (handler != null) {
+            handler.removeCallbacksAndMessages(null);
+        }
+    }
+}

AndroidSDKCore/src/main/java/com/leanplum/internal/RequestOld.java

@@ -25,12 +25,6 @@
 import android.content.SharedPreferences;
 import android.os.AsyncTask;
 import android.os.Build;
-
-import androidx.annotation.MainThread;
-import androidx.annotation.NonNull;
-import androidx.annotation.VisibleForTesting;
-
-import android.os.Looper;
 import android.text.TextUtils;
 
 import com.leanplum.Leanplum;
@@ -66,7 +60,7 @@ public class RequestOld implements Requesting {
   private static final long DEVELOPMENT_MIN_DELAY_MS = 100;
   private static final long DEVELOPMENT_MAX_DELAY_MS = 5000;
   private static final long PRODUCTION_DELAY = 60000;
-  private RequestSequenceRecorder requestSequenceRecorder;
+
   static final int MAX_EVENTS_PER_API_CALL;
   static final String LEANPLUM = "__leanplum__";
   static final String UUID_KEY = "uuid";
@@ -176,28 +170,6 @@ public static void saveToken() {
     SharedPreferencesUtil.commitChanges(editor);
   }
 
-  private static class NoRequestSequenceRecorder implements RequestSequenceRecorder {
-    @Override
-    public void beforeRead() {
-      // No op.
-    }
-
-    @Override
-    public void afterRead() {
-      // No op.
-    }
-
-    @Override
-    public void beforeWrite() {
-      // No op.
-    }
-
-    @Override
-    public void afterWrite() {
-      // No op.
-    }
-  }
-
   public static String appId() {
     return appId;
   }
@@ -211,10 +183,6 @@ public static String userId() {
   }
 
   public RequestOld(String httpMethod, String apiMethod, Map<String, Object> params) {
-    this(httpMethod, apiMethod, params, new NoRequestSequenceRecorder());
-  }
-
-  RequestOld(String httpMethod, String apiMethod, Map<String, Object> params, RequestSequenceRecorder requestSequenceRecorder) {
     this.httpMethod = httpMethod;
     this.apiMethod = apiMethod;
     this.params = params != null ? params : new HashMap<String, Object>();
@@ -225,7 +193,7 @@ public RequestOld(String httpMethod, String apiMethod, Map<String, Object> param
     // Make sure the Handler is initialized on the main thread.
     OsHandler.getInstance();
     dataBaseIndex = -1;
-    this.requestSequenceRecorder = requestSequenceRecorder;
+
     this.requestId = UUID.randomUUID().toString();
   }
 
@@ -259,7 +227,6 @@ public void onApiResponse(ApiResponseCallback apiResponse) {
     RequestOld.apiResponse = apiResponse;
   }
 
-  @VisibleForTesting
   public Map<String, Object> createArgsDictionary() {
     Map<String, Object> args = new HashMap<>();
     args.put(Constants.Params.DEVICE_ID, deviceId);
@@ -276,43 +243,47 @@ public Map<String, Object> createArgsDictionary() {
     return args;
   }
 
-  private void saveRequestForLater(Map<String, Object> args) {
-    try {
+  /**
+   * Saves requests into database.
+   * Saving will be executed on background thread serially.
+   * @param args json to save.
+   */
+  private void saveRequestForLater(final Map<String, Object> args) {
+    OperationQueue.sharedInstance().addOperation(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          Context context = Leanplum.getContext();
+          if (context == null) {
+            return;
+          }
 
-      Context context = Leanplum.getContext();
-      if (context == null) {
-        return;
-      }
+          SharedPreferences preferences = context.getSharedPreferences(LEANPLUM,
+                  Context.MODE_PRIVATE);
+          SharedPreferences.Editor editor = preferences.edit();
+          long count = LeanplumEventDataManager.sharedInstance().getEventsCount();
+          String uuid = preferences.getString(Constants.Defaults.UUID_KEY, null);
+          if (uuid == null || count % MAX_EVENTS_PER_API_CALL == 0) {
+            uuid = UUID.randomUUID().toString();
+            editor.putString(Constants.Defaults.UUID_KEY, uuid);
+            SharedPreferencesUtil.commitChanges(editor);
+          }
+          args.put(UUID_KEY, uuid);
+          LeanplumEventDataManager.sharedInstance().insertEvent(JsonConverter.toJson(args));
+
+          dataBaseIndex = count;
+          // Checks if here response and/or error callback for this request. We need to add callbacks to
+          // eventCallbackManager only if here was internet connection, otherwise triggerErrorCallback
+          // will handle error callback for this event.
+          if (response != null || error != null && !Util.isConnected()) {
+            eventCallbackManager.addCallbacks(RequestOld.this, response, error);
+          }
 
-      requestSequenceRecorder.beforeWrite();
-
-      synchronized (RequestOld.class) {
-        SharedPreferences preferences = context.getSharedPreferences(
-            LEANPLUM, Context.MODE_PRIVATE);
-        SharedPreferences.Editor editor = preferences.edit();
-        long count = LeanplumEventDataManager.sharedInstance().getEventsCount();
-        String uuid = preferences.getString(Constants.Defaults.UUID_KEY, null);
-        if (uuid == null || count % MAX_EVENTS_PER_API_CALL == 0) {
-          uuid = UUID.randomUUID().toString();
-          editor.putString(Constants.Defaults.UUID_KEY, uuid);
-          SharedPreferencesUtil.commitChanges(editor);
-        }
-        args.put(UUID_KEY, uuid);
-        LeanplumEventDataManager.sharedInstance().insertEvent(JsonConverter.toJson(args));
-
-        dataBaseIndex = count;
-        // Checks if here response and/or error callback for this request. We need to add callbacks to
-        // eventCallbackManager only if here was internet connection, otherwise triggerErrorCallback
-        // will handle error callback for this event.
-        if (response != null || error != null && !Util.isConnected()) {
-          eventCallbackManager.addCallbacks(this, response, error);
+        } catch (Throwable t) {
+          Util.handleException(t);
         }
       }
-
-      requestSequenceRecorder.afterWrite();
-    } catch (Throwable t) {
-      Util.handleException(t);
-    }
+    });
   }
 
   public void send() {
@@ -483,7 +454,6 @@ private void parseResponseBody(JSONObject responseBody, List<Map<String, Object>
    * @param errorMessage String of error from server response.
    * @return String of readable error message.
    */
-  @NonNull
   private String getReadableErrorMessage(String errorMessage) {
     if (errorMessage == null || errorMessage.length() == 0) {
       errorMessage = "API error";
@@ -609,12 +579,9 @@ private RequestsWithEncoding getRequestsWithEncodedString() {
 
   private void sendRequests() {
     Leanplum.countAggregator().sendAllCounts();
-    requestSequenceRecorder.beforeRead();
 
     RequestsWithEncoding requestsWithEncoding = getRequestsWithEncodedString();
 
-    requestSequenceRecorder.afterRead();
-
     List<Map<String, Object>> unsentRequests = requestsWithEncoding.unsentRequests;
     List<Map<String, Object>> requestsToSend = requestsWithEncoding.requestsToSend;
     String jsonEncodedString = requestsWithEncoding.jsonEncodedString;