make ServiceProvider's serviceMap thread safe

Add synchronized around all access to ServiceProvider's serviceMap.
This ensures nothing can modify this map, resulting in multiple
instance of a class being return unexpectedly.

Another critical path is the call to resolve(this), where this logic
could also take enough time that could case threading issues that is
now wrapped in this new lock.

This most likely will fix the real world problem we have been seeing
where IApplicationService.appContext is null unexpectedly. One
discovered path is ReceiveReceiptWorker is created from the Android OS
on a background thread and it calls getService() without first calling
OneSignal.initWithContext, resulting in a race condition where
two instance of IApplicationService can be created.
ReceiveReceiptWorker probably should call OneSignal.initWithContext
first, but changing this is out of scope for this commit.

Author: jkasten2

OneSignalSDK/onesignal/core/src/main/java/com/onesignal/common/services/ServiceProvider.kt

@@ -9,6 +9,7 @@ class ServiceProvider(
     registrations: List<ServiceRegistration<*>>,
 ) : IServiceProvider {
     private var serviceMap: Map<Class<*>, List<ServiceRegistration<*>>>
+    private val serviceMapLock = Any()
 
     init {
         val serviceMap = mutableMapOf<Class<*>, MutableList<ServiceRegistration<*>>>()
@@ -44,23 +45,27 @@ class ServiceProvider(
     }
 
     override fun <T> hasService(c: Class<T>): Boolean {
-        return serviceMap.containsKey(c)
+        synchronized(serviceMapLock) {
+            return serviceMap.containsKey(c)
+        }
     }
 
     override fun <T> getAllServices(c: Class<T>): List<T> {
-        val listOfServices: MutableList<T> = mutableListOf()
+        synchronized(serviceMapLock) {
+            val listOfServices: MutableList<T> = mutableListOf()
 
-        if (serviceMap.containsKey(c)) {
-            for (serviceReg in serviceMap!![c]!!) {
-                val service =
-                    serviceReg.resolve(this) as T?
-                        ?: throw Exception("Could not instantiate service: $serviceReg")
+            if (serviceMap.containsKey(c)) {
+                for (serviceReg in serviceMap!![c]!!) {
+                    val service =
+                        serviceReg.resolve(this) as T?
+                            ?: throw Exception("Could not instantiate service: $serviceReg")
 
-                listOfServices.add(service)
+                    listOfServices.add(service)
+                }
             }
-        }
 
-        return listOfServices
+            return listOfServices
+        }
     }
 
     override fun <T> getService(c: Class<T>): T {
@@ -74,11 +79,10 @@ class ServiceProvider(
     }
 
     override fun <T> getServiceOrNull(c: Class<T>): T? {
-        Logging.debug("${indent}Retrieving service $c")
-//        indent += "  "
-        val service = serviceMap[c]?.last()?.resolve(this) as T?
-//        indent = indent.substring(0, indent.length-2)
-        return service
+        synchronized(serviceMapLock) {
+            Logging.debug("${indent}Retrieving service $c")
+            return serviceMap[c]?.last()?.resolve(this) as T?
+        }
     }
 
     companion object {