Added catch for Throwable to Thread.start

* Catching InternalError and OutOfMemoryError didn't cover all possible
first time calls to Thread.start based on the following reports
   - #917 (comment)
   -  #917 (comment)
* Added catching for Error, IllegalThreadStateException (should never fire on first start call but just in case), RuntimeException, and Throwable.
* These are new catches and re-throws with the same logic as PR #975

Author: jkasten2

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

@@ -167,11 +167,36 @@ private synchronized void startDelayedWrite() {
          * Future: We may want to use this strategy for all Thread.start calls.
          *         And limit thread usages, using mostly coroutines instead.
          */
-        private VirtualMachineError threadStartError;
+
+        private Error threadStartError;
+        private RuntimeException threadStartRuntimeException;
+        private Throwable threadStartThrowable;
+
         private void startThread() {
             if (threadStartError != null)
                 throw threadStartError;
 
+            if (threadStartRuntimeException != null)
+                throw threadStartRuntimeException;
+
+            // Ideally we would just throw threadStartThrowable here,
+            //   however we can't without adding throws to this method's signature.
+            // If this is done we would have to add throws all the way up the stack to
+            //   to public SDK methods which can't be done at this time nor would
+            //   "throws Throwable" be a good public signature.
+            if (threadStartThrowable != null) {
+                // The following lines turn a Throwable into a RuntimeException
+                //   to workaround the the throwable signature noted above.
+                RuntimeException exception = new RuntimeException(
+                        threadStartThrowable.getClass().getName() +
+                            ": " +
+                            threadStartThrowable.getMessage(),
+                        threadStartThrowable
+                );
+                exception.setStackTrace(threadStartThrowable.getStackTrace());
+                throw exception;
+            }
+
             try {
                 start();
             } catch (InternalError e) {
@@ -184,6 +209,27 @@ private void startThread() {
                 threadStartError = e;
                 throw e;
             }
+            catch (Error t) {
+                // Possibly some other error we didn't expect Thread.start() to throw
+                threadStartError = t;
+                throw t;
+            }
+            catch (IllegalThreadStateException e) {
+                // Adds the state of the thread to IllegalThreadStateException to provide more details
+                IllegalThreadStateException exception =
+                    new IllegalThreadStateException("Thread has state: " + this.getState());
+                exception.setStackTrace(e.getStackTrace());
+                threadStartRuntimeException = exception;
+                throw exception;
+            }
+            catch (RuntimeException e) {
+                threadStartRuntimeException = e;
+                throw e;
+            }
+            catch (Throwable t) {
+                threadStartThrowable = t;
+                throw t;
+            }
         }
 
         private Runnable getNewRunnable() {