refac: fire callbacks behind native ios ones inside of the main unity thread

Author: uerceg

Assets/Adjust/Scripts/AdjustiOS.cs

@@ -694,192 +694,306 @@ public static void TrackSubsessionEnd(string testingArgument = null)
 
         // MonoPInvokeCallback methods as method parameters
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateIsEnabledGetter))]
-        private static void IsEnabledGetterMonoPInvoke(bool isEnabled) {
-            if (appIsEnabledGetterCallbacks != null)
+        private static void IsEnabledGetterMonoPInvoke(bool isEnabled)
+        {
+            if (appIsEnabledGetterCallbacks == null)
+            {
+                return;
+            }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
             {
                 foreach (Action<bool> callback in appIsEnabledGetterCallbacks)
                 {
-                    callback(isEnabled);
+                    callback?.Invoke(isEnabled);
                 }
                 appIsEnabledGetterCallbacks.Clear();
-            }
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateAttributionGetter))]
-        private static void AttributionGetterMonoPInvoke(string attribution) {
-            if (appAttributionGetterCallbacks != null)
+        private static void AttributionGetterMonoPInvoke(string attribution)
+        {
+            if (appAttributionGetterCallbacks == null)
+            {
+                return;
+            }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
             {
                 foreach (Action<AdjustAttribution> callback in appAttributionGetterCallbacks)
                 {
-                    callback(new AdjustAttribution(attribution));    
+                    callback?.Invoke(new AdjustAttribution(attribution));
                 }
                 appAttributionGetterCallbacks.Clear();
-            }
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateAdidGetter))]
-        private static void AdidGetterMonoPInvoke(string adid) {
-            if (appAdidGetterCallbacks != null)
+        private static void AdidGetterMonoPInvoke(string adid)
+        {
+            if (appAdidGetterCallbacks == null)
+            {
+                return;
+            }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
             {
                 foreach (Action<string> callback in appAdidGetterCallbacks)
                 {
-                    callback(adid);
+                    callback?.Invoke(adid);
                 }
                 appAdidGetterCallbacks.Clear();
-            }
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateIdfaGetter))]
-        private static void IdfaGetterMonoPInvoke(string idfa) {
-            if (appIdfaGetterCallbacks != null)
+        private static void IdfaGetterMonoPInvoke(string idfa)
+        {
+            if (appIdfaGetterCallbacks == null)
+            {
+                return;
+            }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
             {
                 foreach (Action<string> callback in appIdfaGetterCallbacks)
                 {
-                    callback(idfa);
+                    callback?.Invoke(idfa);
                 }
                 appIdfaGetterCallbacks.Clear();
-            }
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateIdfvGetter))]
-        private static void IdfvGetterMonoPInvoke(string idfv) {
-            if (appIdfvGetterCallbacks != null)
+        private static void IdfvGetterMonoPInvoke(string idfv)
+        {
+            if (appIdfvGetterCallbacks == null)
             {
-                foreach (Action<string> callback in appIdfaGetterCallbacks)
+                return;
+            }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                foreach (Action<string> callback in appIdfvGetterCallbacks)
                 {
-                    callback(idfv);
+                    callback?.Invoke(idfv);
                 }
                 appIdfvGetterCallbacks.Clear();
-            }
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateLastDeeplinkGetter))]
-        private static void LastDeeplinkGetterMonoPInvoke(string lastDeeplink) {
-            if (appLastDeeplinkGetterCallbacks != null)
+        private static void LastDeeplinkGetterMonoPInvoke(string lastDeeplink)
+        {
+            if (appLastDeeplinkGetterCallbacks == null)
+            {
+                return;
+            }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
             {
                 foreach (Action<string> callback in appLastDeeplinkGetterCallbacks)
                 {
-                    callback(lastDeeplink);
+                    callback?.Invoke(lastDeeplink);
                 }
                 appLastDeeplinkGetterCallbacks.Clear();
-            }
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateSdkVersionGetter))]
-        private static void SdkVersionGetterMonoPInvoke(string sdkVersion) {
-            if (appSdkVersionGetterCallbacks != null)
+        private static void SdkVersionGetterMonoPInvoke(string sdkVersion)
+        {
+            if (appSdkVersionGetterCallbacks == null)
+            {
+                return;
+            }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
             {
                 foreach (Action<string> callback in appSdkVersionGetterCallbacks)
                 {
-                    callback(sdkPrefix + "@" + sdkVersion);
+                    callback?.Invoke(sdkPrefix + "@" + sdkVersion);
                 }
                 appSdkVersionGetterCallbacks.Clear();
-            }
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateAttCallback))]
-        private static void AttCallbackMonoPInvoke(int status) {
-            if (appAttCallbacks != null)
+        private static void AttCallbackMonoPInvoke(int status)
+        {
+            if (appAttCallbacks == null)
+            {
+                return;
+            }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
             {
                 foreach (Action<int> callback in appAttCallbacks)
                 {
-                    callback(status);
+                    callback?.Invoke(status);
                 }
                 appAttCallbacks.Clear();
-            }
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegatePurchaseVerificationCallback))]
-        private static void PurchaseVerificationCallbackMonoPInvoke(string verificationResult) {
-            if (appPurchaseVerificationCallback != null)
+        private static void PurchaseVerificationCallbackMonoPInvoke(string verificationResult)
+        {
+            if (appPurchaseVerificationCallback == null)
             {
-                appPurchaseVerificationCallback(new AdjustPurchaseVerificationResult(verificationResult));
-                appPurchaseVerificationCallback = null;
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appPurchaseVerificationCallback?.Invoke(new AdjustPurchaseVerificationResult(verificationResult));
+                appPurchaseVerificationCallback = null;
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateVerifyAndTrackCallback))]
-        private static void VerifyAndTrackCallbackMonoPInvoke(string verificationResult) {
-            if (appVerifyAndTrackCallback != null)
+        private static void VerifyAndTrackCallbackMonoPInvoke(string verificationResult)
+        {
+            if (appVerifyAndTrackCallback == null)
             {
-                appVerifyAndTrackCallback(new AdjustPurchaseVerificationResult(verificationResult));
-                appVerifyAndTrackCallback = null;
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appVerifyAndTrackCallback?.Invoke(new AdjustPurchaseVerificationResult(verificationResult));
+                appVerifyAndTrackCallback = null;
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateResolvedDeeplinkCallback))]
-        private static void ResolvedDeeplinkCallbackMonoPInvoke(string deeplink) {
-            if (appResolvedDeeplinkCallback != null)
+        private static void ResolvedDeeplinkCallbackMonoPInvoke(string deeplink)
+        {
+            if (appResolvedDeeplinkCallback == null)
             {
-                appResolvedDeeplinkCallback(deeplink);
-                appResolvedDeeplinkCallback = null;
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appResolvedDeeplinkCallback?.Invoke(deeplink);
+                appResolvedDeeplinkCallback = null;
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateSkanErrorCallback))]
-        private static void SkanErrorCallbackMonoPInvoke(string error) {
-            if (appSkanErrorCallback != null)
+        private static void SkanErrorCallbackMonoPInvoke(string error)
+        {
+            if (appSkanErrorCallback == null)
             {
-                appSkanErrorCallback(error);
-                appSkanErrorCallback = null;
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appSkanErrorCallback?.Invoke(error);
+                appSkanErrorCallback = null;
+            });
         }
 
         // MonoPInvokeCallback methods as subscriptions
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateAttributionCallback))]
-        private static void AttributionCallbackMonoPInvoke(string attribution) {
-            if (appAttributionCallback != null)
+        private static void AttributionCallbackMonoPInvoke(string attribution)
+        {
+            if (appAttributionCallback == null)
             {
-                appAttributionCallback(new AdjustAttribution(attribution));
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appAttributionCallback(new AdjustAttribution(attribution));
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateSessionSuccessCallback))]
-        private static void SessionSuccessCallbackMonoPInvoke(string sessionSuccess) {
-            if (appSessionSuccessCallback != null)
+        private static void SessionSuccessCallbackMonoPInvoke(string sessionSuccess)
+        {
+            if (appSessionSuccessCallback == null)
             {
-                appSessionSuccessCallback(new AdjustSessionSuccess(sessionSuccess));
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appSessionSuccessCallback(new AdjustSessionSuccess(sessionSuccess));
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateSessionFailureCallback))]
-        private static void SessionFailureCallbackMonoPInvoke(string sessionFailure) {
-            if (appSessionFailureCallback != null)
+        private static void SessionFailureCallbackMonoPInvoke(string sessionFailure)
+        {
+            if (appSessionFailureCallback == null)
             {
-                appSessionFailureCallback(new AdjustSessionFailure(sessionFailure));
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appSessionFailureCallback(new AdjustSessionFailure(sessionFailure));
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateEventSuccessCallback))]
-        private static void EventSuccessCallbackMonoPInvoke(string eventSuccess) {
-            if (appEventSuccessCallback != null)
+        private static void EventSuccessCallbackMonoPInvoke(string eventSuccess)
+        {
+            if (appEventSuccessCallback == null)
             {
-                appEventSuccessCallback(new AdjustEventSuccess(eventSuccess));
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appEventSuccessCallback(new AdjustEventSuccess(eventSuccess));
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateEventFailureCallback))]
-        private static void EventFailureCallbackMonoPInvoke(string eventFailure) {
-            if (appEventFailureCallback != null)
+        private static void EventFailureCallbackMonoPInvoke(string eventFailure)
+        {
+            if (appEventFailureCallback == null)
             {
-                appEventFailureCallback(new AdjustEventFailure(eventFailure));
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appEventFailureCallback(new AdjustEventFailure(eventFailure));
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateDeferredDeeplinkCallback))]
-        private static void DeferredDeeplinkCallbackMonoPInvoke(string deeplink) {
-            if (appDeferredDeeplinkCallback != null)
+        private static void DeferredDeeplinkCallbackMonoPInvoke(string deeplink)
+        {
+            if (appDeferredDeeplinkCallback == null)
             {
-                appDeferredDeeplinkCallback(deeplink);
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appDeferredDeeplinkCallback(deeplink);
+            });
         }
 
         [AOT.MonoPInvokeCallback(typeof(AdjustDelegateSkanUpdatedCallback))]
-        private static void SkanUpdatedCallbackMonoPInvoke(string skanData) {
-            if (appSkanUpdatedCallback != null)
+        private static void SkanUpdatedCallbackMonoPInvoke(string skanData)
+        {
+            if (appSkanUpdatedCallback == null)
             {
-                appSkanUpdatedCallback(AdjustUtils.GetSkanUpdateDataDictionary(skanData));
+                return;
             }
+
+            AdjustThreadDispatcher.RunOnMainThread(() =>
+            {
+                appSkanUpdatedCallback?.Invoke(AdjustUtils.GetSkanUpdateDataDictionary(skanData));
+            });
         }
     }
 #endif