Fixes rare IllegalThreadStateException start()

* The root issue is that `Thread.start()` could be called a 2nd time if
there was a problem getting a Handler after starting the thread.
Getting a Handler instance was used as the deturming factor if the
thread had started or not.
* When calling `Thread.start()` there is no guarantee that the thread
has started after finishing or that is may have alrady completed.
* To overcome the following 2 changes were made
  1. Override `HandlerThread`'s `onLooperPrepared`
     - Moving our `getLooper()` call here guarantees it will never be `null`
     - Then this means we can create a new `Handler` everytime successfully
  2. Added a boolean to make sure we only call `start()` once
     - `threadStartCalled` is set to `true` after `start()` is called.
     - This is needed as `onLooperPrepared` may not fire by the time some
       other part of the OneSignal SDK calls `scheduleFlushToDiskJob`
       again.

Author: jkasten2

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

@@ -132,23 +132,43 @@ public static class WritePrefHandlerThread extends HandlerThread {
             super(name);
         }
 
+        @Override
+        protected void onLooperPrepared() {
+            super.onLooperPrepared();
+
+            // Getting handler here as onLooperPrepared guarantees getLooper() will not return null
+            mHandler = new Handler(getLooper());
+            scheduleFlushToDiskJob();
+        }
+
         private synchronized void startDelayedWrite() {
             // A Context is required to write,
             //   if not available now later OneSignal.setContext will call this again.
             if (OneSignal.appContext == null)
                 return;
 
-            if (mHandler == null) {
-                startThread();
-                mHandler = new Handler(getLooper());
-            }
+            startThread();
+            scheduleFlushToDiskJob();
+        }
+
+        private synchronized void scheduleFlushToDiskJob() {
+            // Could be null if looper thread just started
+            if (mHandler == null)
+                return;
 
             mHandler.removeCallbacksAndMessages(null);
+
             if (lastSyncTime == 0)
                 lastSyncTime = System.currentTimeMillis();
-
             long delay = lastSyncTime - System.currentTimeMillis() + WRITE_CALL_DELAY_TO_BUFFER_MS;
-            mHandler.postDelayed(getNewRunnable(), delay);
+
+            Runnable runnable = new Runnable() {
+                @Override
+                public void run() {
+                    flushBufferToDisk();
+                }
+            };
+            mHandler.postDelayed(runnable, delay);
         }
 
         /**
@@ -172,7 +192,11 @@ private synchronized void startDelayedWrite() {
         private RuntimeException threadStartRuntimeException;
         private Throwable threadStartThrowable;
 
+        private boolean threadStartCalled;
         private void startThread() {
+            if (threadStartCalled)
+                return;
+
             if (threadStartError != null)
                 throw threadStartError;
 
@@ -199,6 +223,7 @@ private void startThread() {
 
             try {
                 start();
+                threadStartCalled = true;
             } catch (InternalError e) {
                 // Thread starting during runtime shutdown
                 threadStartError = e;
@@ -232,15 +257,6 @@ private void startThread() {
             }
         }
 
-        private Runnable getNewRunnable() {
-            return new Runnable() {
-                @Override
-                public void run() {
-                    flushBufferToDisk();
-                }
-            };
-        }
-
         private void flushBufferToDisk() {
             for (String pref : prefsToApply.keySet()) {
                 SharedPreferences prefsToWrite = getSharedPrefsByName(pref);