Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/unity3d/services/ads/IUnityAds.java

@@ -0,0 +1,35 @@
+package com.unity3d.services.ads;
+
+import android.app.Activity;
+import android.content.Context;
+import androidx.annotation.Nullable;
+import com.unity3d.ads.IUnityAdsInitializationListener;
+import com.unity3d.ads.IUnityAdsLoadListener;
+import com.unity3d.ads.IUnityAdsShowListener;
+import com.unity3d.ads.IUnityAdsTokenListener;
+import com.unity3d.ads.UnityAdsLoadOptions;
+import com.unity3d.ads.UnityAdsShowOptions;
+
+/* loaded from: classes4.dex */
+public interface IUnityAds {
+    boolean getDebugMode();
+
+    @Nullable
+    String getToken();
+
+    void getToken(IUnityAdsTokenListener iUnityAdsTokenListener);
+
+    String getVersion();
+
+    void initialize(Context context, String str, boolean z, IUnityAdsInitializationListener iUnityAdsInitializationListener);
+
+    boolean isInitialized();
+
+    boolean isSupported();
+
+    void load(String str, UnityAdsLoadOptions unityAdsLoadOptions, IUnityAdsLoadListener iUnityAdsLoadListener);
+
+    void setDebugMode(boolean z);
+
+    void show(Activity activity, String str, UnityAdsShowOptions unityAdsShowOptions, IUnityAdsShowListener iUnityAdsShowListener);
+}

decompiled/sources/com/unity3d/services/ads/UnityAdsImplementation.java

@@ -0,0 +1,227 @@
+package com.unity3d.services.ads;
+
+import android.app.Activity;
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.unity3d.ads.IUnityAdsInitializationListener;
+import com.unity3d.ads.IUnityAdsLoadListener;
+import com.unity3d.ads.IUnityAdsShowListener;
+import com.unity3d.ads.IUnityAdsTokenListener;
+import com.unity3d.ads.UnityAds;
+import com.unity3d.ads.UnityAdsLoadOptions;
+import com.unity3d.ads.UnityAdsShowOptions;
+import com.unity3d.ads.core.configuration.AlternativeFlowReader;
+import com.unity3d.ads.core.data.model.Listeners;
+import com.unity3d.ads.core.data.model.LoadResult;
+import com.unity3d.services.UnityAdsSDK;
+import com.unity3d.services.UnityServices;
+import com.unity3d.services.ads.gmascar.managers.BiddingBaseManager;
+import com.unity3d.services.ads.gmascar.managers.BiddingManagerFactory;
+import com.unity3d.services.ads.operation.load.LoadModule;
+import com.unity3d.services.ads.operation.load.LoadOperationState;
+import com.unity3d.services.ads.operation.show.ShowModule;
+import com.unity3d.services.ads.operation.show.ShowOperationState;
+import com.unity3d.services.ads.token.AsyncTokenStorage;
+import com.unity3d.services.ads.token.TokenStorage;
+import com.unity3d.services.core.configuration.Configuration;
+import com.unity3d.services.core.configuration.ConfigurationReader;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.properties.ClientProperties;
+import com.unity3d.services.core.request.metrics.AdOperationMetric;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.webview.WebViewApp;
+import com.unity3d.services.core.webview.bridge.WebViewBridgeInvoker;
+
+/* loaded from: classes4.dex */
+public final class UnityAdsImplementation implements IUnityAds {
+    private static Configuration configuration;
+    private static IUnityAds instance;
+    private static WebViewBridgeInvoker webViewBridgeInvoker = new WebViewBridgeInvoker();
+
+    public static void setConfiguration(Configuration configuration2) {
+        configuration = configuration2;
+    }
+
+    public static IUnityAds getInstance() {
+        if (instance == null) {
+            instance = new UnityAdsImplementation();
+        }
+        return instance;
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public void initialize(Context context, String str, boolean z, IUnityAdsInitializationListener iUnityAdsInitializationListener) {
+        DeviceLog.entered();
+        UnityServices.initialize(context, str, z, iUnityAdsInitializationListener);
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public boolean isInitialized() {
+        return UnityServices.isInitialized();
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public boolean isSupported() {
+        return UnityServices.isSupported();
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public String getVersion() {
+        return UnityServices.getVersion();
+    }
+
+    public void show(Activity activity, String str) {
+        show(activity, str, new UnityAdsShowOptions(), null);
+    }
+
+    public void show(Activity activity, String str, IUnityAdsShowListener iUnityAdsShowListener) {
+        show(activity, str, new UnityAdsShowOptions(), iUnityAdsShowListener);
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public void show(@Nullable Activity activity, @Nullable String str, @Nullable UnityAdsShowOptions unityAdsShowOptions, @Nullable final IUnityAdsShowListener iUnityAdsShowListener) {
+        if (((AlternativeFlowReader) Utilities.getService(AlternativeFlowReader.class)).invoke()) {
+            UnityAdsSDK.INSTANCE.show(str, unityAdsShowOptions, new Listeners() { // from class: com.unity3d.services.ads.UnityAdsImplementation.1
+                @Override // com.unity3d.ads.core.data.model.Listeners
+                public void onLeftApplication(String str2) {
+                }
+
+                @Override // com.unity3d.ads.core.data.model.Listeners
+                public void onError(String str2, UnityAds.UnityAdsShowError unityAdsShowError, String str3) {
+                    IUnityAdsShowListener iUnityAdsShowListener2 = iUnityAdsShowListener;
+                    if (iUnityAdsShowListener2 != null) {
+                        iUnityAdsShowListener2.onUnityAdsShowFailure(str2, unityAdsShowError, str3);
+                    }
+                }
+
+                @Override // com.unity3d.ads.core.data.model.Listeners
+                public void onStart(String str2) {
+                    IUnityAdsShowListener iUnityAdsShowListener2 = iUnityAdsShowListener;
+                    if (iUnityAdsShowListener2 != null) {
+                        iUnityAdsShowListener2.onUnityAdsShowStart(str2);
+                    }
+                }
+
+                @Override // com.unity3d.ads.core.data.model.Listeners
+                public void onClick(String str2) {
+                    IUnityAdsShowListener iUnityAdsShowListener2 = iUnityAdsShowListener;
+                    if (iUnityAdsShowListener2 != null) {
+                        iUnityAdsShowListener2.onUnityAdsShowClick(str2);
+                    }
+                }
+
+                @Override // com.unity3d.ads.core.data.model.Listeners
+                public void onComplete(String str2, UnityAds.UnityAdsShowCompletionState unityAdsShowCompletionState) {
+                    IUnityAdsShowListener iUnityAdsShowListener2 = iUnityAdsShowListener;
+                    if (iUnityAdsShowListener2 != null) {
+                        iUnityAdsShowListener2.onUnityAdsShowComplete(str2, unityAdsShowCompletionState);
+                    }
+                }
+            });
+            return;
+        }
+        if (!isSupported()) {
+            handleShowError(iUnityAdsShowListener, str, UnityAds.UnityAdsShowError.NOT_INITIALIZED, "Unity Ads is not supported for this device");
+            return;
+        }
+        if (!isInitialized()) {
+            handleShowError(iUnityAdsShowListener, str, UnityAds.UnityAdsShowError.NOT_INITIALIZED, LoadResult.MSG_NOT_INITIALIZED);
+            return;
+        }
+        if (activity == null) {
+            handleShowError(iUnityAdsShowListener, str, UnityAds.UnityAdsShowError.INVALID_ARGUMENT, "Activity must not be null");
+            return;
+        }
+        if (str == null) {
+            handleShowError(iUnityAdsShowListener, "", UnityAds.UnityAdsShowError.INVALID_ARGUMENT, LoadResult.MSG_PLACEMENT_NULL);
+            return;
+        }
+        Configuration configuration2 = configuration;
+        if (configuration2 == null) {
+            configuration2 = new Configuration();
+        }
+        ClientProperties.setActivity(activity);
+        ShowModule.getInstance().executeAdOperation(WebViewApp.getCurrentApp(), new ShowOperationState(str, iUnityAdsShowListener, activity, unityAdsShowOptions, configuration2));
+    }
+
+    private void handleShowError(IUnityAdsShowListener iUnityAdsShowListener, String str, UnityAds.UnityAdsShowError unityAdsShowError, String str2) {
+        ((SDKMetricsSender) Utilities.getService(SDKMetricsSender.class)).sendMetricWithInitState(AdOperationMetric.newAdShowFailure(unityAdsShowError, (Long) 0L));
+        if (iUnityAdsShowListener == null) {
+            return;
+        }
+        iUnityAdsShowListener.onUnityAdsShowFailure(str, unityAdsShowError, str2);
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public void setDebugMode(boolean z) {
+        UnityServices.setDebugMode(z);
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public boolean getDebugMode() {
+        return UnityServices.getDebugMode();
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public void load(@Nullable String str, @NonNull UnityAdsLoadOptions unityAdsLoadOptions, @Nullable IUnityAdsLoadListener iUnityAdsLoadListener) {
+        if (((AlternativeFlowReader) Utilities.getService(AlternativeFlowReader.class)).invoke()) {
+            UnityAdsSDK.INSTANCE.load(str, unityAdsLoadOptions, iUnityAdsLoadListener, null);
+            return;
+        }
+        Configuration configuration2 = configuration;
+        if (configuration2 == null) {
+            configuration2 = new Configuration();
+        }
+        LoadModule.getInstance().executeAdOperation(webViewBridgeInvoker, new LoadOperationState(str, iUnityAdsLoadListener, unityAdsLoadOptions, configuration2));
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    @Nullable
+    public String getToken() {
+        if (((AlternativeFlowReader) Utilities.getService(AlternativeFlowReader.class)).invoke()) {
+            return UnityAdsSDK.INSTANCE.getToken();
+        }
+        String token = ((TokenStorage) Utilities.getService(TokenStorage.class)).getToken();
+        if (token == null || token.isEmpty()) {
+            return null;
+        }
+        Configuration configuration2 = configuration;
+        if (configuration2 == null) {
+            configuration2 = new ConfigurationReader().getCurrentConfiguration();
+        }
+        BiddingBaseManager createManager = BiddingManagerFactory.getInstance().createManager(null, configuration2.getExperiments());
+        createManager.start();
+        return createManager.getFormattedToken(token);
+    }
+
+    @Override // com.unity3d.services.ads.IUnityAds
+    public void getToken(@Nullable final IUnityAdsTokenListener iUnityAdsTokenListener) {
+        if (((AlternativeFlowReader) Utilities.getService(AlternativeFlowReader.class)).invoke()) {
+            UnityAdsSDK.INSTANCE.getToken(iUnityAdsTokenListener);
+            return;
+        }
+        if (iUnityAdsTokenListener == null) {
+            DeviceLog.info("Please provide non-null listener to UnityAds.GetToken method");
+            return;
+        }
+        if (ClientProperties.getApplicationContext() == null) {
+            Utilities.wrapCustomerListener(new Runnable() { // from class: com.unity3d.services.ads.UnityAdsImplementation$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    IUnityAdsTokenListener.this.onUnityAdsTokenReady(null);
+                }
+            });
+            return;
+        }
+        AsyncTokenStorage asyncTokenStorage = (AsyncTokenStorage) Utilities.getService(AsyncTokenStorage.class);
+        Configuration configuration2 = configuration;
+        if (configuration2 == null) {
+            configuration2 = new ConfigurationReader().getCurrentConfiguration();
+        }
+        BiddingBaseManager createManager = BiddingManagerFactory.getInstance().createManager(iUnityAdsTokenListener, configuration2.getExperiments());
+        createManager.start();
+        asyncTokenStorage.getToken(createManager);
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitActivity.java

@@ -0,0 +1,152 @@
+package com.unity3d.services.ads.adunit;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Bundle;
+import android.view.KeyEvent;
+import com.unity3d.services.core.webview.bridge.SharedInstances;
+import java.util.ArrayList;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class AdUnitActivity extends Activity implements IAdUnitActivity {
+    public static final String EXTRA_ACTIVITY_ID = "activityId";
+    public static final String EXTRA_DISPLAY_CUTOUT_MODE = "displayCutoutMode";
+    public static final String EXTRA_KEEP_SCREEN_ON = "keepScreenOn";
+    public static final String EXTRA_KEY_EVENT_LIST = "keyEvents";
+    public static final String EXTRA_ORIENTATION = "orientation";
+    public static final String EXTRA_SYSTEM_UI_VISIBILITY = "systemUiVisibility";
+    public static final String EXTRA_VIEWS = "views";
+    protected AdUnitActivityController _controller;
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public Activity getActivity() {
+        return this;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public Context getContext() {
+        return this;
+    }
+
+    public AdUnitActivityController createController() {
+        return new AdUnitActivityController(this, SharedInstances.INSTANCE.getWebViewEventSender(), new AdUnitViewHandlerFactory());
+    }
+
+    @Override // android.app.Activity
+    public void onCreate(Bundle bundle) {
+        super.onCreate(bundle);
+        AdUnitActivityController createController = createController();
+        this._controller = createController;
+        createController.onCreate(bundle);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public AdUnitRelativeLayout getLayout() {
+        return this._controller.getLayout();
+    }
+
+    @Override // android.app.Activity
+    public void onStart() {
+        super.onStart();
+        this._controller.onStart();
+    }
+
+    @Override // android.app.Activity
+    public void onStop() {
+        super.onStop();
+        this._controller.onStop();
+    }
+
+    @Override // android.app.Activity
+    public void onResume() {
+        super.onResume();
+        this._controller.onResume();
+    }
+
+    @Override // android.app.Activity
+    public void onPause() {
+        super.onPause();
+        this._controller.onPause();
+    }
+
+    @Override // android.app.Activity
+    public void onSaveInstanceState(Bundle bundle) {
+        super.onSaveInstanceState(bundle);
+        this._controller.onSaveInstanceState(bundle);
+    }
+
+    @Override // android.app.Activity
+    public void onDestroy() {
+        AdUnitActivityController adUnitActivityController = this._controller;
+        if (adUnitActivityController != null) {
+            adUnitActivityController.onDestroy();
+        }
+        super.onDestroy();
+    }
+
+    @Override // android.app.Activity, android.view.KeyEvent.Callback
+    public boolean onKeyDown(int i, KeyEvent keyEvent) {
+        return this._controller.onKeyDown(i, keyEvent);
+    }
+
+    @Override // android.app.Activity, android.view.Window.Callback
+    public void onWindowFocusChanged(boolean z) {
+        this._controller.onWindowFocusChanged(z);
+        super.onWindowFocusChanged(z);
+    }
+
+    @Override // android.app.Activity
+    public void onRequestPermissionsResult(int i, String[] strArr, int[] iArr) {
+        this._controller.onRequestPermissionsResult(i, strArr, iArr);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public void setViewFrame(String str, int i, int i2, int i3, int i4) {
+        this._controller.setViewFrame(str, i, i2, i3, i4);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public Map<String, Integer> getViewFrame(String str) {
+        return this._controller.getViewFrame(str);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public void setViews(String[] strArr) {
+        this._controller.setViews(strArr);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public String[] getViews() {
+        return this._controller.getViews();
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public void setOrientation(int i) {
+        this._controller.setOrientation(i);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public boolean setKeepScreenOn(boolean z) {
+        return this._controller.setKeepScreenOn(z);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public boolean setSystemUiVisibility(int i) {
+        return this._controller.setSystemUiVisibility(i);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public void setKeyEventList(ArrayList<Integer> arrayList) {
+        this._controller.setKeyEventList(arrayList);
+    }
+
+    public IAdUnitViewHandler getViewHandler(String str) {
+        return this._controller.getViewHandler(str);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitActivity
+    public void setLayoutInDisplayCutoutMode(int i) {
+        this._controller.setLayoutInDisplayCutoutMode(i);
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitActivityController.java

@@ -0,0 +1,446 @@
+package com.unity3d.services.ads.adunit;
+
+import android.graphics.drawable.ColorDrawable;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.WindowManager;
+import android.widget.FrameLayout;
+import android.widget.RelativeLayout;
+import androidx.core.view.ViewCompat;
+import com.unity3d.services.ads.api.AdUnit;
+import com.unity3d.services.core.api.Intent;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.misc.ViewUtilities;
+import com.unity3d.services.core.webview.WebViewApp;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import com.unity3d.services.core.webview.bridge.IEventSender;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import org.json.JSONArray;
+
+/* loaded from: classes4.dex */
+public class AdUnitActivityController {
+    private int _activityId;
+    private final IAdUnitActivity _adUnitActivity;
+    private final IAdUnitViewHandlerFactory _adUnitViewHandlerFactory;
+    private int _displayCutoutMode;
+    private final IEventSender _eventSender;
+    boolean _keepScreenOn;
+    private ArrayList<Integer> _keyEventList;
+    protected AdUnitRelativeLayout _layout;
+    private int _orientation = -1;
+    private int _systemUiVisibility;
+    private Map<String, IAdUnitViewHandler> _viewHandlers;
+    private String[] _views;
+
+    public AdUnitRelativeLayout getLayout() {
+        return this._layout;
+    }
+
+    public String[] getViews() {
+        return this._views;
+    }
+
+    public void setKeyEventList(ArrayList<Integer> arrayList) {
+        this._keyEventList = arrayList;
+    }
+
+    public AdUnitActivityController(IAdUnitActivity iAdUnitActivity, IEventSender iEventSender, IAdUnitViewHandlerFactory iAdUnitViewHandlerFactory) {
+        this._adUnitActivity = iAdUnitActivity;
+        this._eventSender = iEventSender;
+        this._adUnitViewHandlerFactory = iAdUnitViewHandlerFactory;
+    }
+
+    public void onCreate(Bundle bundle) {
+        AdUnitEvent adUnitEvent;
+        if (!this._eventSender.canSend()) {
+            DeviceLog.error("Unity Ads web app is null, closing Unity Ads activity from onCreate");
+            this._adUnitActivity.finish();
+            return;
+        }
+        AdUnit.setAdUnitActivity(this._adUnitActivity);
+        Intent.setActiveActivity(this._adUnitActivity.getActivity());
+        createLayout();
+        ViewUtilities.removeViewFromParent(this._layout);
+        IAdUnitActivity iAdUnitActivity = this._adUnitActivity;
+        AdUnitRelativeLayout adUnitRelativeLayout = this._layout;
+        iAdUnitActivity.addContentView(adUnitRelativeLayout, adUnitRelativeLayout.getLayoutParams());
+        if (bundle == null) {
+            this._views = this._adUnitActivity.getIntent().getStringArrayExtra(AdUnitActivity.EXTRA_VIEWS);
+            this._keyEventList = this._adUnitActivity.getIntent().getIntegerArrayListExtra(AdUnitActivity.EXTRA_KEY_EVENT_LIST);
+            if (this._adUnitActivity.getIntent().hasExtra("orientation")) {
+                this._orientation = this._adUnitActivity.getIntent().getIntExtra("orientation", -1);
+            }
+            if (this._adUnitActivity.getIntent().hasExtra(AdUnitActivity.EXTRA_SYSTEM_UI_VISIBILITY)) {
+                this._systemUiVisibility = this._adUnitActivity.getIntent().getIntExtra(AdUnitActivity.EXTRA_SYSTEM_UI_VISIBILITY, 0);
+            }
+            if (this._adUnitActivity.getIntent().hasExtra(AdUnitActivity.EXTRA_ACTIVITY_ID)) {
+                this._activityId = this._adUnitActivity.getIntent().getIntExtra(AdUnitActivity.EXTRA_ACTIVITY_ID, -1);
+            }
+            if (this._adUnitActivity.getIntent().hasExtra(AdUnitActivity.EXTRA_DISPLAY_CUTOUT_MODE)) {
+                this._displayCutoutMode = this._adUnitActivity.getIntent().getIntExtra(AdUnitActivity.EXTRA_DISPLAY_CUTOUT_MODE, 0);
+            }
+            adUnitEvent = AdUnitEvent.ON_CREATE;
+        } else {
+            this._views = bundle.getStringArray(AdUnitActivity.EXTRA_VIEWS);
+            this._orientation = bundle.getInt("orientation", -1);
+            this._systemUiVisibility = bundle.getInt(AdUnitActivity.EXTRA_SYSTEM_UI_VISIBILITY, 0);
+            this._keyEventList = bundle.getIntegerArrayList(AdUnitActivity.EXTRA_KEY_EVENT_LIST);
+            this._keepScreenOn = bundle.getBoolean(AdUnitActivity.EXTRA_KEEP_SCREEN_ON);
+            this._activityId = bundle.getInt(AdUnitActivity.EXTRA_ACTIVITY_ID, -1);
+            this._displayCutoutMode = bundle.getInt(AdUnitActivity.EXTRA_DISPLAY_CUTOUT_MODE, 0);
+            setKeepScreenOn(this._keepScreenOn);
+            adUnitEvent = AdUnitEvent.ON_RESTORE;
+        }
+        setOrientation(this._orientation);
+        setSystemUiVisibility(this._systemUiVisibility);
+        setLayoutInDisplayCutoutMode(this._displayCutoutMode);
+        String[] strArr = this._views;
+        if (strArr != null) {
+            for (String str : strArr) {
+                IAdUnitViewHandler viewHandler = getViewHandler(str);
+                if (viewHandler != null) {
+                    viewHandler.onCreate(this._adUnitActivity, bundle);
+                }
+            }
+        }
+        this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, adUnitEvent, Integer.valueOf(this._activityId));
+    }
+
+    public void onStart() {
+        if (!this._eventSender.canSend()) {
+            if (this._adUnitActivity.isFinishing()) {
+                return;
+            }
+            DeviceLog.error("Unity Ads web app is null, closing Unity Ads activity from onStart");
+            this._adUnitActivity.finish();
+            return;
+        }
+        Map<String, IAdUnitViewHandler> map = this._viewHandlers;
+        if (map != null) {
+            for (Map.Entry<String, IAdUnitViewHandler> entry : map.entrySet()) {
+                if (entry.getValue() != null) {
+                    entry.getValue().onStart(this._adUnitActivity);
+                }
+            }
+        }
+        this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, AdUnitEvent.ON_START, Integer.valueOf(this._activityId));
+    }
+
+    public void onStop() {
+        if (!this._eventSender.canSend()) {
+            if (this._adUnitActivity.isFinishing()) {
+                return;
+            }
+            DeviceLog.error("Unity Ads web app is null, closing Unity Ads activity from onStop");
+            this._adUnitActivity.finish();
+            return;
+        }
+        Map<String, IAdUnitViewHandler> map = this._viewHandlers;
+        if (map != null) {
+            for (Map.Entry<String, IAdUnitViewHandler> entry : map.entrySet()) {
+                if (entry.getValue() != null) {
+                    entry.getValue().onStop(this._adUnitActivity);
+                }
+            }
+        }
+        this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, AdUnitEvent.ON_STOP, Integer.valueOf(this._activityId));
+    }
+
+    public void onResume() {
+        if (!this._eventSender.canSend()) {
+            if (this._adUnitActivity.isFinishing()) {
+                return;
+            }
+            DeviceLog.error("Unity Ads web app is null, closing Unity Ads activity from onResume");
+            this._adUnitActivity.finish();
+            return;
+        }
+        setViews(this._views);
+        Map<String, IAdUnitViewHandler> map = this._viewHandlers;
+        if (map != null) {
+            for (Map.Entry<String, IAdUnitViewHandler> entry : map.entrySet()) {
+                if (entry.getValue() != null) {
+                    entry.getValue().onResume(this._adUnitActivity);
+                }
+            }
+        }
+        this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, AdUnitEvent.ON_RESUME, Integer.valueOf(this._activityId));
+    }
+
+    public void onPause() {
+        if (!this._eventSender.canSend()) {
+            if (this._adUnitActivity.isFinishing()) {
+                return;
+            }
+            DeviceLog.error("Unity Ads web app is null, closing Unity Ads activity from onPause");
+            this._adUnitActivity.finish();
+            return;
+        }
+        if (WebViewApp.getCurrentApp().getWebView() == null) {
+            DeviceLog.warning("Unity Ads web view is null, from onPause");
+        } else if (this._adUnitActivity.isFinishing()) {
+            ViewUtilities.removeViewFromParent(WebViewApp.getCurrentApp().getWebView());
+        }
+        Map<String, IAdUnitViewHandler> map = this._viewHandlers;
+        if (map != null) {
+            for (Map.Entry<String, IAdUnitViewHandler> entry : map.entrySet()) {
+                if (entry.getValue() != null) {
+                    entry.getValue().onPause(this._adUnitActivity);
+                }
+            }
+        }
+        this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, AdUnitEvent.ON_PAUSE, Boolean.valueOf(this._adUnitActivity.isFinishing()), Integer.valueOf(this._activityId));
+    }
+
+    public void onSaveInstanceState(Bundle bundle) {
+        bundle.putInt("orientation", this._orientation);
+        bundle.putInt(AdUnitActivity.EXTRA_SYSTEM_UI_VISIBILITY, this._systemUiVisibility);
+        bundle.putIntegerArrayList(AdUnitActivity.EXTRA_KEY_EVENT_LIST, this._keyEventList);
+        bundle.putBoolean(AdUnitActivity.EXTRA_KEEP_SCREEN_ON, this._keepScreenOn);
+        bundle.putStringArray(AdUnitActivity.EXTRA_VIEWS, this._views);
+        bundle.putInt(AdUnitActivity.EXTRA_ACTIVITY_ID, this._activityId);
+    }
+
+    public void onDestroy() {
+        if (!this._eventSender.canSend()) {
+            if (this._adUnitActivity.isFinishing()) {
+                return;
+            }
+            DeviceLog.error("Unity Ads web app is null, closing Unity Ads activity from onDestroy");
+            this._adUnitActivity.finish();
+            return;
+        }
+        this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, AdUnitEvent.ON_DESTROY, Boolean.valueOf(this._adUnitActivity.isFinishing()), Integer.valueOf(this._activityId));
+        Map<String, IAdUnitViewHandler> map = this._viewHandlers;
+        if (map != null) {
+            for (Map.Entry<String, IAdUnitViewHandler> entry : map.entrySet()) {
+                if (entry.getValue() != null) {
+                    entry.getValue().onDestroy(this._adUnitActivity);
+                }
+            }
+        }
+        if (AdUnit.getCurrentAdUnitActivityId() == this._activityId) {
+            AdUnit.setAdUnitActivity(null);
+        }
+        Intent.removeActiveActivity(this._adUnitActivity.getActivity());
+    }
+
+    public boolean onKeyDown(int i, KeyEvent keyEvent) {
+        ArrayList<Integer> arrayList = this._keyEventList;
+        if (arrayList == null || !arrayList.contains(Integer.valueOf(i))) {
+            return false;
+        }
+        this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, AdUnitEvent.KEY_DOWN, Integer.valueOf(i), Long.valueOf(keyEvent.getEventTime()), Long.valueOf(keyEvent.getDownTime()), Integer.valueOf(keyEvent.getRepeatCount()), Integer.valueOf(this._activityId));
+        return true;
+    }
+
+    public void onWindowFocusChanged(boolean z) {
+        if (z) {
+            this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, AdUnitEvent.ON_FOCUS_GAINED, Integer.valueOf(this._activityId));
+        } else {
+            this._eventSender.sendEvent(WebViewEventCategory.ADUNIT, AdUnitEvent.ON_FOCUS_LOST, Integer.valueOf(this._activityId));
+        }
+    }
+
+    public void onRequestPermissionsResult(int i, String[] strArr, int[] iArr) {
+        try {
+            JSONArray jSONArray = new JSONArray();
+            JSONArray jSONArray2 = new JSONArray();
+            for (String str : strArr) {
+                jSONArray.put(str);
+            }
+            for (int i2 : iArr) {
+                jSONArray2.put(i2);
+            }
+            this._eventSender.sendEvent(WebViewEventCategory.PERMISSIONS, PermissionsEvent.PERMISSIONS_RESULT, Integer.valueOf(i), jSONArray, jSONArray2);
+        } catch (Exception e) {
+            this._eventSender.sendEvent(WebViewEventCategory.PERMISSIONS, PermissionsEvent.PERMISSIONS_ERROR, e.getMessage());
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:6:0x0025  */
+    /* JADX WARN: Removed duplicated region for block: B:9:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public void setViewFrame(java.lang.String r3, int r4, int r5, int r6, int r7) {
+        /*
+            r2 = this;
+            com.unity3d.services.ads.adunit.IAdUnitViewHandler r0 = r2.getViewHandler(r3)
+            java.lang.String r1 = "adunit"
+            boolean r3 = r3.equals(r1)
+            r1 = 0
+            if (r3 == 0) goto L1b
+            android.widget.FrameLayout$LayoutParams r3 = new android.widget.FrameLayout$LayoutParams
+            r3.<init>(r6, r7)
+            r3.setMargins(r4, r5, r1, r1)
+            com.unity3d.services.ads.adunit.AdUnitRelativeLayout r0 = r2._layout
+            r0.setLayoutParams(r3)
+            goto L22
+        L1b:
+            if (r0 == 0) goto L22
+            android.view.View r3 = r0.getView()
+            goto L23
+        L22:
+            r3 = 0
+        L23:
+            if (r3 == 0) goto L30
+            android.widget.RelativeLayout$LayoutParams r0 = new android.widget.RelativeLayout$LayoutParams
+            r0.<init>(r6, r7)
+            r0.setMargins(r4, r5, r1, r1)
+            r3.setLayoutParams(r0)
+        L30:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.unity3d.services.ads.adunit.AdUnitActivityController.setViewFrame(java.lang.String, int, int, int, int):void");
+    }
+
+    public Map<String, Integer> getViewFrame(String str) {
+        IAdUnitViewHandler viewHandler = getViewHandler(str);
+        if (str.equals("adunit")) {
+            FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) this._layout.getLayoutParams();
+            HashMap hashMap = new HashMap();
+            hashMap.put("x", Integer.valueOf(layoutParams.leftMargin));
+            hashMap.put("y", Integer.valueOf(layoutParams.topMargin));
+            hashMap.put("width", Integer.valueOf(this._layout.getWidth()));
+            hashMap.put("height", Integer.valueOf(this._layout.getHeight()));
+            return hashMap;
+        }
+        View view = viewHandler != null ? viewHandler.getView() : null;
+        if (view == null) {
+            return null;
+        }
+        RelativeLayout.LayoutParams layoutParams2 = (RelativeLayout.LayoutParams) view.getLayoutParams();
+        HashMap hashMap2 = new HashMap();
+        hashMap2.put("x", Integer.valueOf(layoutParams2.leftMargin));
+        hashMap2.put("y", Integer.valueOf(layoutParams2.topMargin));
+        hashMap2.put("width", Integer.valueOf(view.getWidth()));
+        hashMap2.put("height", Integer.valueOf(view.getHeight()));
+        return hashMap2;
+    }
+
+    public void setViews(String[] strArr) {
+        if (strArr == null) {
+            strArr = new String[0];
+        }
+        ArrayList arrayList = new ArrayList(Arrays.asList(strArr));
+        if (this._views == null) {
+            this._views = new String[0];
+        }
+        ArrayList arrayList2 = new ArrayList(Arrays.asList(this._views));
+        arrayList2.removeAll(arrayList);
+        Iterator it = arrayList2.iterator();
+        while (it.hasNext()) {
+            getViewHandler((String) it.next()).destroy();
+        }
+        this._views = strArr;
+        for (String str : strArr) {
+            if (str != null) {
+                IAdUnitViewHandler viewHandler = getViewHandler(str);
+                viewHandler.create(this._adUnitActivity);
+                if (!handleViewPlacement(viewHandler.getView())) {
+                    return;
+                }
+            }
+        }
+    }
+
+    private boolean handleViewPlacement(View view) {
+        if (view == null) {
+            this._adUnitActivity.finish();
+            DeviceLog.error("Could not place view because it is null, finishing activity");
+            return false;
+        }
+        if (view.getParent() != null && view.getParent().equals(this._layout)) {
+            this._layout.bringChildToFront(view);
+            return true;
+        }
+        ViewUtilities.removeViewFromParent(view);
+        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-1, -1);
+        layoutParams.addRule(13);
+        layoutParams.setMargins(0, 0, 0, 0);
+        view.setPadding(0, 0, 0, 0);
+        this._layout.addView(view, layoutParams);
+        return true;
+    }
+
+    public void setOrientation(int i) {
+        this._orientation = i;
+        this._adUnitActivity.setRequestedOrientation(i);
+    }
+
+    public boolean setKeepScreenOn(boolean z) {
+        this._keepScreenOn = z;
+        if (this._adUnitActivity.getWindow() == null) {
+            return false;
+        }
+        if (z) {
+            this._adUnitActivity.getWindow().addFlags(128);
+            return true;
+        }
+        this._adUnitActivity.getWindow().clearFlags(128);
+        return true;
+    }
+
+    public boolean setSystemUiVisibility(int i) {
+        this._systemUiVisibility = i;
+        try {
+            this._adUnitActivity.getWindow().getDecorView().setSystemUiVisibility(i);
+            return true;
+        } catch (Exception e) {
+            DeviceLog.exception("Error while setting SystemUIVisibility", e);
+            return false;
+        }
+    }
+
+    public IAdUnitViewHandler getViewHandler(String str) {
+        Map<String, IAdUnitViewHandler> map = this._viewHandlers;
+        if (map != null && map.containsKey(str)) {
+            return this._viewHandlers.get(str);
+        }
+        IAdUnitViewHandler createViewHandler = createViewHandler(str);
+        if (createViewHandler != null) {
+            if (this._viewHandlers == null) {
+                this._viewHandlers = new HashMap();
+            }
+            this._viewHandlers.put(str, createViewHandler);
+        }
+        return createViewHandler;
+    }
+
+    public void setLayoutInDisplayCutoutMode(int i) {
+        this._displayCutoutMode = i;
+        if (Build.VERSION.SDK_INT < 28 || this._adUnitActivity.getWindow() == null) {
+            return;
+        }
+        WindowManager.LayoutParams attributes = this._adUnitActivity.getWindow().getAttributes();
+        try {
+            attributes.getClass().getField("layoutInDisplayCutoutMode").setInt(attributes, i);
+        } catch (IllegalAccessException e) {
+            DeviceLog.debug("Error setting layoutInDisplayCutoutMode", e);
+        } catch (NoSuchFieldException e2) {
+            DeviceLog.debug("Error getting layoutInDisplayCutoutMode", e2);
+        }
+    }
+
+    public void createLayout() {
+        if (this._layout != null) {
+            return;
+        }
+        AdUnitRelativeLayout adUnitRelativeLayout = new AdUnitRelativeLayout(this._adUnitActivity.getContext());
+        this._layout = adUnitRelativeLayout;
+        adUnitRelativeLayout.setLayoutParams(new RelativeLayout.LayoutParams(-1, -1));
+        ViewUtilities.setBackground(this._layout, new ColorDrawable(ViewCompat.MEASURED_STATE_MASK));
+    }
+
+    private IAdUnitViewHandler createViewHandler(String str) {
+        return this._adUnitViewHandlerFactory.createViewHandler(str);
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitError.java

@@ -0,0 +1,21 @@
+package com.unity3d.services.ads.adunit;
+
+/* loaded from: classes4.dex */
+public enum AdUnitError {
+    ADUNIT_NULL,
+    ACTIVITY_ID,
+    GENERIC,
+    ORIENTATION,
+    SCREENVISIBILITY,
+    CORRUPTED_VIEWLIST,
+    CORRUPTED_KEYEVENTLIST,
+    SYSTEM_UI_VISIBILITY,
+    UNKNOWN_VIEW,
+    LAYOUT_NULL,
+    MAX_MOTION_EVENT_COUNT_REACHED,
+    API_LEVEL_ERROR,
+    NO_DISPLAY_CUTOUT_AVAILABLE,
+    DISPLAY_CUTOUT_METHOD_NOT_AVAILABLE,
+    DISPLAY_CUTOUT_JSON_ERROR,
+    DISPLAY_CUTOUT_INVOKE_FAILED
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitEvent.java

@@ -0,0 +1,15 @@
+package com.unity3d.services.ads.adunit;
+
+/* loaded from: classes4.dex */
+public enum AdUnitEvent {
+    ON_START,
+    ON_CREATE,
+    ON_RESUME,
+    ON_DESTROY,
+    ON_PAUSE,
+    KEY_DOWN,
+    ON_RESTORE,
+    ON_STOP,
+    ON_FOCUS_GAINED,
+    ON_FOCUS_LOST
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitMotionEvent.java

@@ -0,0 +1,68 @@
+package com.unity3d.services.ads.adunit;
+
+/* loaded from: classes4.dex */
+public class AdUnitMotionEvent {
+    private int _action;
+    private int _deviceId;
+    private long _eventTime;
+    private boolean _isObscured;
+    private float _pressure;
+    private float _size;
+    private int _source;
+    private int _toolType;
+    private float _x;
+    private float _y;
+
+    public int getAction() {
+        return this._action;
+    }
+
+    public int getDeviceId() {
+        return this._deviceId;
+    }
+
+    public long getEventTime() {
+        return this._eventTime;
+    }
+
+    public float getPressure() {
+        return this._pressure;
+    }
+
+    public float getSize() {
+        return this._size;
+    }
+
+    public int getSource() {
+        return this._source;
+    }
+
+    public int getToolType() {
+        return this._toolType;
+    }
+
+    public float getX() {
+        return this._x;
+    }
+
+    public float getY() {
+        return this._y;
+    }
+
+    public boolean isObscured() {
+        return this._isObscured;
+    }
+
+    public AdUnitMotionEvent(int i, boolean z, int i2, int i3, int i4, float f, float f2, long j, float f3, float f4) {
+        this._action = i;
+        this._isObscured = z;
+        this._toolType = i2;
+        this._source = i3;
+        this._deviceId = i4;
+        this._x = f;
+        this._y = f2;
+        this._eventTime = j;
+        this._pressure = f3;
+        this._size = f4;
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitOpen.java

@@ -0,0 +1,53 @@
+package com.unity3d.services.ads.adunit;
+
+import android.os.ConditionVariable;
+import com.ironsource.v8;
+import com.unity3d.services.core.configuration.Configuration;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.request.metrics.AdOperationError;
+import com.unity3d.services.core.request.metrics.AdOperationMetric;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.webview.WebViewApp;
+import com.unity3d.services.core.webview.bridge.CallbackStatus;
+import java.lang.reflect.Method;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class AdUnitOpen {
+    private static Configuration _configuration;
+    private static final SDKMetricsSender _sdkMetricsSender = (SDKMetricsSender) Utilities.getService(SDKMetricsSender.class);
+    private static ConditionVariable _waitShowStatus;
+
+    public static void setConfiguration(Configuration configuration) {
+        _configuration = configuration;
+    }
+
+    public static synchronized boolean open(String str, JSONObject jSONObject) throws NoSuchMethodException {
+        boolean block;
+        synchronized (AdUnitOpen.class) {
+            try {
+                Method method = AdUnitOpen.class.getMethod("showCallback", CallbackStatus.class);
+                _waitShowStatus = new ConditionVariable();
+                if (_configuration == null) {
+                    _configuration = new Configuration();
+                }
+                WebViewApp.getCurrentApp().invokeMethod(v8.h.K, "show", method, str, jSONObject);
+                block = _waitShowStatus.block(_configuration.getShowTimeout());
+                _waitShowStatus = null;
+                if (!block) {
+                    _sdkMetricsSender.sendMetric(AdOperationMetric.newAdShowFailure(AdOperationError.timeout, Long.valueOf(_configuration.getShowTimeout())));
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return block;
+    }
+
+    public static void showCallback(CallbackStatus callbackStatus) {
+        if (_waitShowStatus == null || !callbackStatus.equals(CallbackStatus.OK)) {
+            return;
+        }
+        _waitShowStatus.open();
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitRelativeLayout.java

@@ -0,0 +1,127 @@
+package com.unity3d.services.ads.adunit;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.util.SparseArray;
+import android.util.SparseIntArray;
+import android.view.InputEvent;
+import android.view.MotionEvent;
+import android.widget.RelativeLayout;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes4.dex */
+public class AdUnitRelativeLayout extends RelativeLayout {
+    private InputEvent _lastInputEvent;
+    private int _maxEvents;
+    private final ArrayList<AdUnitMotionEvent> _motionEvents;
+    private boolean _shouldCapture;
+
+    public void endCapture() {
+        this._shouldCapture = false;
+    }
+
+    public InputEvent getLastInputEvent() {
+        return this._lastInputEvent;
+    }
+
+    public int getMaxEventCount() {
+        return this._maxEvents;
+    }
+
+    public void startCapture(int i) {
+        this._maxEvents = i;
+        this._shouldCapture = true;
+    }
+
+    public AdUnitRelativeLayout(Context context) {
+        super(context);
+        this._motionEvents = new ArrayList<>();
+        this._maxEvents = 10000;
+        this._shouldCapture = false;
+    }
+
+    @Override // android.view.ViewGroup
+    @TargetApi(14)
+    public boolean onInterceptTouchEvent(MotionEvent motionEvent) {
+        super.onInterceptTouchEvent(motionEvent);
+        if (motionEvent.getActionMasked() == 1 || motionEvent.getActionMasked() == 0 || motionEvent.getActionMasked() == 6 || motionEvent.getActionMasked() == 5) {
+            this._lastInputEvent = motionEvent;
+        }
+        if (!this._shouldCapture || this._motionEvents.size() >= this._maxEvents) {
+            return false;
+        }
+        boolean z = (motionEvent.getFlags() & 1) != 0;
+        synchronized (this._motionEvents) {
+            this._motionEvents.add(new AdUnitMotionEvent(motionEvent.getActionMasked(), z, motionEvent.getToolType(0), motionEvent.getSource(), motionEvent.getDeviceId(), motionEvent.getX(0), motionEvent.getY(0), motionEvent.getEventTime(), motionEvent.getPressure(0), motionEvent.getSize(0)));
+        }
+        return false;
+    }
+
+    public void clearCapture() {
+        synchronized (this._motionEvents) {
+            this._motionEvents.clear();
+        }
+    }
+
+    public int getCurrentEventCount() {
+        int size;
+        synchronized (this._motionEvents) {
+            size = this._motionEvents.size();
+        }
+        return size;
+    }
+
+    public SparseArray<SparseArray<AdUnitMotionEvent>> getEvents(SparseArray<ArrayList<Integer>> sparseArray) {
+        SparseIntArray sparseIntArray = new SparseIntArray();
+        SparseArray<SparseArray<AdUnitMotionEvent>> sparseArray2 = new SparseArray<>();
+        synchronized (this._motionEvents) {
+            try {
+                Iterator<AdUnitMotionEvent> it = this._motionEvents.iterator();
+                while (it.hasNext()) {
+                    AdUnitMotionEvent next = it.next();
+                    ArrayList<Integer> arrayList = sparseArray.get(next.getAction());
+                    if (arrayList != null) {
+                        int intValue = arrayList.get(0).intValue();
+                        if (sparseIntArray.get(next.getAction(), 0) == intValue) {
+                            if (sparseArray2.get(next.getAction()) == null) {
+                                sparseArray2.put(next.getAction(), new SparseArray<>());
+                            }
+                            sparseArray2.get(next.getAction()).put(intValue, next);
+                            arrayList.remove(0);
+                        }
+                        sparseIntArray.put(next.getAction(), sparseIntArray.get(next.getAction()) + 1);
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return sparseArray2;
+    }
+
+    public SparseIntArray getEventCount(ArrayList<Integer> arrayList) {
+        SparseIntArray sparseIntArray = new SparseIntArray();
+        synchronized (this._motionEvents) {
+            try {
+                Iterator<AdUnitMotionEvent> it = this._motionEvents.iterator();
+                while (it.hasNext()) {
+                    AdUnitMotionEvent next = it.next();
+                    Iterator<Integer> it2 = arrayList.iterator();
+                    while (true) {
+                        if (it2.hasNext()) {
+                            Integer next2 = it2.next();
+                            if (next.getAction() == next2.intValue()) {
+                                sparseIntArray.put(next2.intValue(), sparseIntArray.get(next2.intValue(), 0) + 1);
+                                break;
+                            }
+                        }
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return sparseIntArray;
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitSoftwareActivity.java

@@ -0,0 +1,5 @@
+package com.unity3d.services.ads.adunit;
+
+/* loaded from: classes4.dex */
+public class AdUnitSoftwareActivity extends AdUnitActivity {
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitTransparentActivity.java

@@ -0,0 +1,20 @@
+package com.unity3d.services.ads.adunit;
+
+import android.graphics.drawable.ColorDrawable;
+import android.os.Bundle;
+import com.unity3d.services.core.misc.ViewUtilities;
+import com.unity3d.services.core.webview.bridge.SharedInstances;
+
+/* loaded from: classes4.dex */
+public class AdUnitTransparentActivity extends AdUnitActivity {
+    @Override // com.unity3d.services.ads.adunit.AdUnitActivity, android.app.Activity
+    public void onCreate(Bundle bundle) {
+        super.onCreate(bundle);
+        ViewUtilities.setBackground(this._controller._layout, new ColorDrawable(0));
+    }
+
+    @Override // com.unity3d.services.ads.adunit.AdUnitActivity
+    public AdUnitActivityController createController() {
+        return new AdUnitTransparentActivityController(this, SharedInstances.INSTANCE.getWebViewEventSender(), new AdUnitViewHandlerFactory());
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitTransparentActivityController.java

@@ -0,0 +1,18 @@
+package com.unity3d.services.ads.adunit;
+
+import android.graphics.drawable.ColorDrawable;
+import com.unity3d.services.core.misc.ViewUtilities;
+import com.unity3d.services.core.webview.bridge.IEventSender;
+
+/* loaded from: classes4.dex */
+public class AdUnitTransparentActivityController extends AdUnitActivityController {
+    public AdUnitTransparentActivityController(IAdUnitActivity iAdUnitActivity, IEventSender iEventSender, IAdUnitViewHandlerFactory iAdUnitViewHandlerFactory) {
+        super(iAdUnitActivity, iEventSender, iAdUnitViewHandlerFactory);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.AdUnitActivityController
+    public void createLayout() {
+        super.createLayout();
+        ViewUtilities.setBackground(this._layout, new ColorDrawable(0));
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitTransparentSoftwareActivity.java

@@ -0,0 +1,5 @@
+package com.unity3d.services.ads.adunit;
+
+/* loaded from: classes4.dex */
+public class AdUnitTransparentSoftwareActivity extends AdUnitTransparentActivity {
+}

decompiled/sources/com/unity3d/services/ads/adunit/AdUnitViewHandlerFactory.java

@@ -0,0 +1,31 @@
+package com.unity3d.services.ads.adunit;
+
+import com.unity3d.services.ads.configuration.IAdsModuleConfiguration;
+import com.unity3d.services.core.configuration.Configuration;
+import com.unity3d.services.core.configuration.IModuleConfiguration;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.webview.WebViewApp;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class AdUnitViewHandlerFactory implements IAdUnitViewHandlerFactory {
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandlerFactory
+    public IAdUnitViewHandler createViewHandler(String str) {
+        Map<String, Class> adUnitViewHandlers;
+        if (WebViewApp.getCurrentApp() != null) {
+            Configuration configuration = WebViewApp.getCurrentApp().getConfiguration();
+            for (Class cls : configuration.getModuleConfigurationList()) {
+                IModuleConfiguration moduleConfiguration = configuration.getModuleConfiguration(cls);
+                if ((moduleConfiguration instanceof IAdsModuleConfiguration) && (adUnitViewHandlers = ((IAdsModuleConfiguration) moduleConfiguration).getAdUnitViewHandlers()) != null && adUnitViewHandlers.containsKey(str)) {
+                    try {
+                        return (IAdUnitViewHandler) adUnitViewHandlers.get(str).newInstance();
+                    } catch (Exception unused) {
+                        DeviceLog.error("Error creating view: " + str);
+                        return null;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/IAdUnitActivity.java

@@ -0,0 +1,53 @@
+package com.unity3d.services.ads.adunit;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import java.util.ArrayList;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface IAdUnitActivity {
+    void addContentView(View view, ViewGroup.LayoutParams layoutParams);
+
+    void finish();
+
+    Activity getActivity();
+
+    Context getContext();
+
+    Intent getIntent();
+
+    AdUnitRelativeLayout getLayout();
+
+    int getRequestedOrientation();
+
+    Map<String, Integer> getViewFrame(String str);
+
+    String[] getViews();
+
+    Window getWindow();
+
+    boolean isFinishing();
+
+    void requestPermissions(String[] strArr, int i);
+
+    boolean setKeepScreenOn(boolean z);
+
+    void setKeyEventList(ArrayList<Integer> arrayList);
+
+    void setLayoutInDisplayCutoutMode(int i);
+
+    void setOrientation(int i);
+
+    void setRequestedOrientation(int i);
+
+    boolean setSystemUiVisibility(int i);
+
+    void setViewFrame(String str, int i, int i2, int i3, int i4);
+
+    void setViews(String[] strArr);
+}

decompiled/sources/com/unity3d/services/ads/adunit/IAdUnitViewHandler.java

@@ -0,0 +1,25 @@
+package com.unity3d.services.ads.adunit;
+
+import android.os.Bundle;
+import android.view.View;
+
+/* loaded from: classes4.dex */
+public interface IAdUnitViewHandler {
+    boolean create(IAdUnitActivity iAdUnitActivity);
+
+    boolean destroy();
+
+    View getView();
+
+    void onCreate(IAdUnitActivity iAdUnitActivity, Bundle bundle);
+
+    void onDestroy(IAdUnitActivity iAdUnitActivity);
+
+    void onPause(IAdUnitActivity iAdUnitActivity);
+
+    void onResume(IAdUnitActivity iAdUnitActivity);
+
+    void onStart(IAdUnitActivity iAdUnitActivity);
+
+    void onStop(IAdUnitActivity iAdUnitActivity);
+}

decompiled/sources/com/unity3d/services/ads/adunit/IAdUnitViewHandlerFactory.java

@@ -0,0 +1,6 @@
+package com.unity3d.services.ads.adunit;
+
+/* loaded from: classes4.dex */
+public interface IAdUnitViewHandlerFactory {
+    IAdUnitViewHandler createViewHandler(String str);
+}

decompiled/sources/com/unity3d/services/ads/adunit/PermissionsEvent.java

@@ -0,0 +1,7 @@
+package com.unity3d.services.ads.adunit;
+
+/* loaded from: classes4.dex */
+public enum PermissionsEvent {
+    PERMISSIONS_RESULT,
+    PERMISSIONS_ERROR
+}

decompiled/sources/com/unity3d/services/ads/adunit/VideoPlayerHandler.java

@@ -0,0 +1,86 @@
+package com.unity3d.services.ads.adunit;
+
+import android.os.Bundle;
+import android.view.View;
+import android.widget.RelativeLayout;
+import com.unity3d.services.ads.api.VideoPlayer;
+import com.unity3d.services.ads.video.VideoPlayerView;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.misc.ViewUtilities;
+
+/* loaded from: classes4.dex */
+public class VideoPlayerHandler implements IAdUnitViewHandler {
+    private RelativeLayout _videoContainer;
+    private VideoPlayerView _videoView;
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public View getView() {
+        return this._videoContainer;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onDestroy(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onResume(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onStart(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onStop(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public boolean create(IAdUnitActivity iAdUnitActivity) {
+        DeviceLog.entered();
+        if (this._videoContainer == null) {
+            this._videoContainer = new RelativeLayout(iAdUnitActivity.getContext());
+        }
+        if (this._videoView != null) {
+            return true;
+        }
+        this._videoView = new VideoPlayerView(iAdUnitActivity.getContext());
+        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-1, -1);
+        layoutParams.addRule(13);
+        this._videoView.setLayoutParams(layoutParams);
+        this._videoContainer.addView(this._videoView);
+        VideoPlayer.setVideoPlayerView(this._videoView);
+        return true;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public boolean destroy() {
+        DeviceLog.entered();
+        VideoPlayerView videoPlayerView = this._videoView;
+        if (videoPlayerView != null) {
+            videoPlayerView.stopVideoProgressTimer();
+            this._videoView.stopPlayback();
+            ViewUtilities.removeViewFromParent(this._videoView);
+            if (this._videoView.equals(VideoPlayer.getVideoPlayerView())) {
+                VideoPlayer.setVideoPlayerView(null);
+            }
+            this._videoView = null;
+        }
+        RelativeLayout relativeLayout = this._videoContainer;
+        if (relativeLayout == null) {
+            return true;
+        }
+        ViewUtilities.removeViewFromParent(relativeLayout);
+        this._videoContainer = null;
+        return true;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onCreate(IAdUnitActivity iAdUnitActivity, Bundle bundle) {
+        create(iAdUnitActivity);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onPause(IAdUnitActivity iAdUnitActivity) {
+        destroy();
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/WebPlayerHandler.java

@@ -0,0 +1,75 @@
+package com.unity3d.services.ads.adunit;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.view.View;
+import com.unity3d.services.ads.webplayer.WebPlayerSettingsCache;
+import com.unity3d.services.ads.webplayer.WebPlayerView;
+import com.unity3d.services.ads.webplayer.WebPlayerViewCache;
+import com.unity3d.services.core.misc.ViewUtilities;
+
+/* loaded from: classes4.dex */
+public class WebPlayerHandler implements IAdUnitViewHandler {
+    private static String webPlayerViewId = "webplayer";
+    private WebPlayerView _webPlayerView;
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public View getView() {
+        return this._webPlayerView;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onPause(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onResume(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onStart(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onStop(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public boolean create(IAdUnitActivity iAdUnitActivity) {
+        if (this._webPlayerView != null) {
+            return true;
+        }
+        WebPlayerSettingsCache webPlayerSettingsCache = WebPlayerSettingsCache.getInstance();
+        Context context = iAdUnitActivity.getContext();
+        String str = webPlayerViewId;
+        WebPlayerView webPlayerView = new WebPlayerView(context, str, webPlayerSettingsCache.getWebSettings(str), webPlayerSettingsCache.getWebPlayerSettings(webPlayerViewId));
+        this._webPlayerView = webPlayerView;
+        webPlayerView.setEventSettings(webPlayerSettingsCache.getWebPlayerEventSettings(webPlayerViewId));
+        WebPlayerViewCache.getInstance().addWebPlayer(webPlayerViewId, this._webPlayerView);
+        return true;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public boolean destroy() {
+        WebPlayerView webPlayerView = this._webPlayerView;
+        if (webPlayerView != null) {
+            ViewUtilities.removeViewFromParent(webPlayerView);
+            this._webPlayerView.destroy();
+        }
+        WebPlayerViewCache.getInstance().removeWebPlayer(webPlayerViewId);
+        this._webPlayerView = null;
+        return true;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onCreate(IAdUnitActivity iAdUnitActivity, Bundle bundle) {
+        create(iAdUnitActivity);
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onDestroy(IAdUnitActivity iAdUnitActivity) {
+        if (iAdUnitActivity.isFinishing()) {
+            destroy();
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/adunit/WebViewHandler.java

@@ -0,0 +1,56 @@
+package com.unity3d.services.ads.adunit;
+
+import android.os.Bundle;
+import android.view.View;
+import com.unity3d.services.core.misc.ViewUtilities;
+import com.unity3d.services.core.webview.WebViewApp;
+
+/* loaded from: classes4.dex */
+public class WebViewHandler implements IAdUnitViewHandler {
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public boolean create(IAdUnitActivity iAdUnitActivity) {
+        return true;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onCreate(IAdUnitActivity iAdUnitActivity, Bundle bundle) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onPause(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onResume(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onStart(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onStop(IAdUnitActivity iAdUnitActivity) {
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public boolean destroy() {
+        if (WebViewApp.getCurrentApp() == null || WebViewApp.getCurrentApp().getWebView() == null) {
+            return true;
+        }
+        ViewUtilities.removeViewFromParent(WebViewApp.getCurrentApp().getWebView());
+        return true;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public View getView() {
+        if (WebViewApp.getCurrentApp() != null) {
+            return WebViewApp.getCurrentApp().getWebView();
+        }
+        return null;
+    }
+
+    @Override // com.unity3d.services.ads.adunit.IAdUnitViewHandler
+    public void onDestroy(IAdUnitActivity iAdUnitActivity) {
+        destroy();
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/AdUnit.java

@@ -0,0 +1,545 @@
+package com.unity3d.services.ads.api;
+
+import android.content.Intent;
+import android.os.Build;
+import android.util.SparseArray;
+import android.util.SparseIntArray;
+import android.view.WindowInsets;
+import com.facebook.share.internal.ShareConstants;
+import com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlNode;
+import com.unity3d.services.ads.adunit.AdUnitActivity;
+import com.unity3d.services.ads.adunit.AdUnitError;
+import com.unity3d.services.ads.adunit.AdUnitMotionEvent;
+import com.unity3d.services.ads.adunit.AdUnitSoftwareActivity;
+import com.unity3d.services.ads.adunit.AdUnitTransparentActivity;
+import com.unity3d.services.ads.adunit.AdUnitTransparentSoftwareActivity;
+import com.unity3d.services.ads.adunit.IAdUnitActivity;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.properties.ClientProperties;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+import csdk.gluads.Consts;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class AdUnit {
+    private static IAdUnitActivity _adUnitActivity = null;
+    private static int _currentActivityId = -1;
+
+    public static IAdUnitActivity getAdUnitActivity() {
+        return _adUnitActivity;
+    }
+
+    public static int getCurrentAdUnitActivityId() {
+        return _currentActivityId;
+    }
+
+    public static void setAdUnitActivity(IAdUnitActivity iAdUnitActivity) {
+        _adUnitActivity = iAdUnitActivity;
+    }
+
+    public static void setCurrentAdUnitActivityId(int i) {
+        _currentActivityId = i;
+    }
+
+    private AdUnit() {
+    }
+
+    @WebViewExposed
+    public static void open(Integer num, JSONArray jSONArray, Integer num2, WebViewCallback webViewCallback) {
+        open(num, jSONArray, num2, null, webViewCallback);
+    }
+
+    @WebViewExposed
+    public static void open(Integer num, JSONArray jSONArray, Integer num2, JSONArray jSONArray2, WebViewCallback webViewCallback) {
+        open(num, jSONArray, num2, jSONArray2, 0, Boolean.TRUE, webViewCallback);
+    }
+
+    @WebViewExposed
+    public static void open(Integer num, JSONArray jSONArray, Integer num2, JSONArray jSONArray2, Integer num3, Boolean bool, WebViewCallback webViewCallback) {
+        open(num, jSONArray, num2, jSONArray2, num3, bool, Boolean.FALSE, webViewCallback);
+    }
+
+    @WebViewExposed
+    public static void open(Integer num, JSONArray jSONArray, Integer num2, JSONArray jSONArray2, Integer num3, Boolean bool, Boolean bool2, WebViewCallback webViewCallback) {
+        open(num, jSONArray, num2, jSONArray2, num3, bool, bool2, 0, webViewCallback);
+    }
+
+    @WebViewExposed
+    public static void open(Integer num, JSONArray jSONArray, Integer num2, JSONArray jSONArray2, Integer num3, Boolean bool, Boolean bool2, Integer num4, WebViewCallback webViewCallback) {
+        Intent intent;
+        if (!bool.booleanValue() && bool2.booleanValue()) {
+            DeviceLog.debug("Unity Ads opening new transparent ad unit activity, hardware acceleration disabled");
+            intent = new Intent(ClientProperties.getActivity(), (Class<?>) AdUnitTransparentSoftwareActivity.class);
+        } else if (bool.booleanValue() && !bool2.booleanValue()) {
+            DeviceLog.debug("Unity Ads opening new hardware accelerated ad unit activity");
+            intent = new Intent(ClientProperties.getActivity(), (Class<?>) AdUnitActivity.class);
+        } else if (bool.booleanValue() && bool2.booleanValue()) {
+            DeviceLog.debug("Unity Ads opening new hardware accelerated transparent ad unit activity");
+            intent = new Intent(ClientProperties.getActivity(), (Class<?>) AdUnitTransparentActivity.class);
+        } else {
+            DeviceLog.debug("Unity Ads opening new ad unit activity, hardware acceleration disabled");
+            intent = new Intent(ClientProperties.getActivity(), (Class<?>) AdUnitSoftwareActivity.class);
+        }
+        intent.addFlags(268500992);
+        if (num != null) {
+            try {
+                intent.putExtra(AdUnitActivity.EXTRA_ACTIVITY_ID, num.intValue());
+                setCurrentAdUnitActivityId(num.intValue());
+                try {
+                    intent.putExtra(AdUnitActivity.EXTRA_VIEWS, getViewList(jSONArray));
+                    if (jSONArray2 != null) {
+                        try {
+                            intent.putExtra(AdUnitActivity.EXTRA_KEY_EVENT_LIST, getKeyEventList(jSONArray2));
+                        } catch (Exception e) {
+                            DeviceLog.exception("Error parsing views from viewList", e);
+                            webViewCallback.error(AdUnitError.CORRUPTED_KEYEVENTLIST, jSONArray2, e.getMessage());
+                            return;
+                        }
+                    }
+                    intent.putExtra(AdUnitActivity.EXTRA_SYSTEM_UI_VISIBILITY, num3);
+                    intent.putExtra("orientation", num2);
+                    intent.putExtra(AdUnitActivity.EXTRA_DISPLAY_CUTOUT_MODE, num4);
+                    ClientProperties.getActivity().startActivity(intent);
+                    DeviceLog.debug("Opened AdUnitActivity with: " + jSONArray.toString());
+                    webViewCallback.invoke(new Object[0]);
+                    return;
+                } catch (Exception e2) {
+                    DeviceLog.exception("Error parsing views from viewList", e2);
+                    webViewCallback.error(AdUnitError.CORRUPTED_VIEWLIST, jSONArray, e2.getMessage());
+                    return;
+                }
+            } catch (Exception e3) {
+                DeviceLog.exception("Could not set activityId for intent", e3);
+                webViewCallback.error(AdUnitError.ACTIVITY_ID, Integer.valueOf(num.intValue()), e3.getMessage());
+                return;
+            }
+        }
+        DeviceLog.error("Activity ID is NULL");
+        webViewCallback.error(AdUnitError.ACTIVITY_ID, "Activity ID NULL");
+    }
+
+    @WebViewExposed
+    public static void close(WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            getAdUnitActivity().finish();
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setViews(final JSONArray jSONArray, WebViewCallback webViewCallback) {
+        try {
+            getViewList(jSONArray);
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.AdUnit.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (AdUnit.getAdUnitActivity() != null) {
+                        try {
+                            AdUnit.getAdUnitActivity().setViews(AdUnit.getViewList(jSONArray));
+                        } catch (Exception e) {
+                            DeviceLog.exception("Corrupted viewlist", e);
+                        }
+                    }
+                }
+            });
+        } catch (JSONException unused) {
+            webViewCallback.error(AdUnitError.CORRUPTED_VIEWLIST, jSONArray);
+        }
+        if (getAdUnitActivity() != null) {
+            webViewCallback.invoke(jSONArray);
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getViews(WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            webViewCallback.invoke(new JSONArray((Collection) Arrays.asList(getAdUnitActivity().getViews())));
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setOrientation(final Integer num, WebViewCallback webViewCallback) {
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.AdUnit.2
+            @Override // java.lang.Runnable
+            public void run() {
+                if (AdUnit.getAdUnitActivity() != null) {
+                    AdUnit.getAdUnitActivity().setOrientation(num.intValue());
+                }
+            }
+        });
+        if (getAdUnitActivity() != null) {
+            webViewCallback.invoke(num);
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getOrientation(WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            webViewCallback.invoke(Integer.valueOf(getAdUnitActivity().getRequestedOrientation()));
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setKeepScreenOn(final Boolean bool, WebViewCallback webViewCallback) {
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.AdUnit.3
+            @Override // java.lang.Runnable
+            public void run() {
+                if (AdUnit.getAdUnitActivity() != null) {
+                    AdUnit.getAdUnitActivity().setKeepScreenOn(bool.booleanValue());
+                }
+            }
+        });
+        if (getAdUnitActivity() != null) {
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setSystemUiVisibility(final Integer num, WebViewCallback webViewCallback) {
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.AdUnit.4
+            @Override // java.lang.Runnable
+            public void run() {
+                if (AdUnit.getAdUnitActivity() != null) {
+                    AdUnit.getAdUnitActivity().setSystemUiVisibility(num.intValue());
+                }
+            }
+        });
+        if (getAdUnitActivity() != null) {
+            webViewCallback.invoke(num);
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setKeyEventList(JSONArray jSONArray, WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            try {
+                getAdUnitActivity().setKeyEventList(getKeyEventList(jSONArray));
+                webViewCallback.invoke(jSONArray);
+                return;
+            } catch (Exception e) {
+                DeviceLog.exception("Error parsing views from viewList", e);
+                webViewCallback.error(AdUnitError.CORRUPTED_KEYEVENTLIST, jSONArray, e.getMessage());
+                return;
+            }
+        }
+        webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void setViewFrame(final String str, final Integer num, final Integer num2, final Integer num3, final Integer num4, WebViewCallback webViewCallback) {
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.AdUnit.5
+            @Override // java.lang.Runnable
+            public void run() {
+                if (AdUnit.getAdUnitActivity() != null) {
+                    AdUnit.getAdUnitActivity().setViewFrame(str, num.intValue(), num2.intValue(), num3.intValue(), num4.intValue());
+                }
+            }
+        });
+        if (getAdUnitActivity() != null) {
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getViewFrame(String str, WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            if (getAdUnitActivity().getViewFrame(str) != null) {
+                Map<String, Integer> viewFrame = getAdUnitActivity().getViewFrame(str);
+                webViewCallback.invoke(viewFrame.get("x"), viewFrame.get("y"), viewFrame.get("width"), viewFrame.get("height"));
+                return;
+            } else {
+                webViewCallback.error(AdUnitError.UNKNOWN_VIEW, new Object[0]);
+                return;
+            }
+        }
+        webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void startMotionEventCapture(Integer num, WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            if (getAdUnitActivity().getLayout() != null) {
+                getAdUnitActivity().getLayout().startCapture(num.intValue());
+                webViewCallback.invoke(new Object[0]);
+                return;
+            } else {
+                webViewCallback.error(AdUnitError.LAYOUT_NULL, new Object[0]);
+                return;
+            }
+        }
+        webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void endMotionEventCapture(WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            if (getAdUnitActivity().getLayout() != null) {
+                getAdUnitActivity().getLayout().endCapture();
+                webViewCallback.invoke(new Object[0]);
+                return;
+            } else {
+                webViewCallback.error(AdUnitError.LAYOUT_NULL, new Object[0]);
+                return;
+            }
+        }
+        webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void clearMotionEventCapture(WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            if (getAdUnitActivity().getLayout() != null) {
+                getAdUnitActivity().getLayout().clearCapture();
+                webViewCallback.invoke(new Object[0]);
+                return;
+            } else {
+                webViewCallback.error(AdUnitError.LAYOUT_NULL, new Object[0]);
+                return;
+            }
+        }
+        webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void getMotionEventCount(JSONArray jSONArray, WebViewCallback webViewCallback) {
+        ArrayList<Integer> arrayList = new ArrayList<>();
+        for (int i = 0; i < jSONArray.length(); i++) {
+            try {
+                arrayList.add(Integer.valueOf(jSONArray.getInt(i)));
+            } catch (Exception e) {
+                DeviceLog.exception("Error retrieving int from eventTypes", e);
+            }
+        }
+        if (getAdUnitActivity() != null) {
+            if (getAdUnitActivity().getLayout() != null) {
+                if (getAdUnitActivity().getLayout().getCurrentEventCount() >= getAdUnitActivity().getLayout().getMaxEventCount()) {
+                    webViewCallback.error(AdUnitError.MAX_MOTION_EVENT_COUNT_REACHED, new Object[0]);
+                    return;
+                }
+                SparseIntArray eventCount = getAdUnitActivity().getLayout().getEventCount(arrayList);
+                JSONObject jSONObject = new JSONObject();
+                for (int i2 = 0; i2 < eventCount.size(); i2++) {
+                    int keyAt = eventCount.keyAt(i2);
+                    try {
+                        jSONObject.put(Integer.toString(keyAt), eventCount.get(keyAt));
+                    } catch (Exception e2) {
+                        DeviceLog.exception("Error building response JSON", e2);
+                    }
+                }
+                webViewCallback.invoke(jSONObject);
+                return;
+            }
+            webViewCallback.error(AdUnitError.LAYOUT_NULL, new Object[0]);
+            return;
+        }
+        webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void getMotionEventData(JSONObject jSONObject, WebViewCallback webViewCallback) {
+        JSONArray jSONArray;
+        Iterator<String> keys = jSONObject.keys();
+        SparseArray<ArrayList<Integer>> sparseArray = new SparseArray<>();
+        while (true) {
+            if (!keys.hasNext()) {
+                break;
+            }
+            String next = keys.next();
+            int parseInt = Integer.parseInt(next);
+            if (sparseArray.get(parseInt) == null) {
+                sparseArray.put(parseInt, new ArrayList<>());
+            }
+            try {
+                jSONArray = jSONObject.getJSONArray(next);
+            } catch (Exception e) {
+                DeviceLog.exception("Couldn't fetch keyIndices", e);
+                jSONArray = null;
+            }
+            if (jSONArray != null) {
+                for (int i = 0; i < jSONArray.length(); i++) {
+                    try {
+                        sparseArray.get(parseInt).add(Integer.valueOf(jSONArray.getInt(i)));
+                    } catch (Exception e2) {
+                        DeviceLog.exception("Couldn't add value to requested infos", e2);
+                    }
+                }
+            }
+        }
+        if (getAdUnitActivity() != null) {
+            if (getAdUnitActivity().getLayout() != null) {
+                if (getAdUnitActivity().getLayout().getCurrentEventCount() >= getAdUnitActivity().getLayout().getMaxEventCount()) {
+                    webViewCallback.error(AdUnitError.MAX_MOTION_EVENT_COUNT_REACHED, new Object[0]);
+                    return;
+                }
+                SparseArray<SparseArray<AdUnitMotionEvent>> events = getAdUnitActivity().getLayout().getEvents(sparseArray);
+                JSONObject jSONObject2 = new JSONObject();
+                for (int i2 = 0; i2 < events.size(); i2++) {
+                    int keyAt = events.keyAt(i2);
+                    SparseArray<AdUnitMotionEvent> sparseArray2 = events.get(keyAt);
+                    JSONObject jSONObject3 = new JSONObject();
+                    for (int i3 = 0; i3 < sparseArray2.size(); i3++) {
+                        JSONObject jSONObject4 = new JSONObject();
+                        int keyAt2 = sparseArray2.keyAt(i3);
+                        AdUnitMotionEvent adUnitMotionEvent = sparseArray2.get(keyAt2);
+                        try {
+                            jSONObject4.put("action", adUnitMotionEvent.getAction());
+                            jSONObject4.put("isObscured", adUnitMotionEvent.isObscured());
+                            jSONObject4.put("toolType", adUnitMotionEvent.getToolType());
+                            jSONObject4.put(ShareConstants.FEED_SOURCE_PARAM, adUnitMotionEvent.getSource());
+                            jSONObject4.put("deviceId", adUnitMotionEvent.getDeviceId());
+                            jSONObject4.put("x", adUnitMotionEvent.getX());
+                            jSONObject4.put("y", adUnitMotionEvent.getY());
+                            jSONObject4.put("eventTime", adUnitMotionEvent.getEventTime());
+                            jSONObject4.put("pressure", adUnitMotionEvent.getPressure());
+                            jSONObject4.put("size", adUnitMotionEvent.getSize());
+                            jSONObject3.put(Integer.toString(keyAt2), jSONObject4);
+                        } catch (Exception e3) {
+                            DeviceLog.debug("Couldn't construct event info", e3);
+                        }
+                    }
+                    try {
+                        jSONObject2.put(Integer.toString(keyAt), jSONObject3);
+                    } catch (Exception e4) {
+                        DeviceLog.debug("Couldn't construct info object", e4);
+                    }
+                }
+                webViewCallback.invoke(jSONObject2);
+                return;
+            }
+            webViewCallback.error(AdUnitError.LAYOUT_NULL, new Object[0]);
+            return;
+        }
+        webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void getCurrentMotionEventCount(WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() != null) {
+            if (getAdUnitActivity().getLayout() != null) {
+                webViewCallback.invoke(Integer.valueOf(getAdUnitActivity().getLayout().getCurrentEventCount()));
+                return;
+            } else {
+                webViewCallback.error(AdUnitError.LAYOUT_NULL, new Object[0]);
+                return;
+            }
+        }
+        webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void getSafeAreaInsets(WebViewCallback webViewCallback) {
+        if (getAdUnitActivity() == null || getAdUnitActivity().getLayout() == null) {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+            return;
+        }
+        if (Build.VERSION.SDK_INT >= 28) {
+            WindowInsets rootWindowInsets = getAdUnitActivity().getLayout().getRootWindowInsets();
+            if (rootWindowInsets != null) {
+                JSONObject jSONObject = new JSONObject();
+                try {
+                    Object invoke = rootWindowInsets.getClass().getMethod("getDisplayCutout", new Class[0]).invoke(rootWindowInsets, new Object[0]);
+                    if (invoke != null) {
+                        Object invoke2 = invoke.getClass().getMethod("getSafeInsetTop", new Class[0]).invoke(invoke, new Object[0]);
+                        Object invoke3 = invoke.getClass().getMethod("getSafeInsetRight", new Class[0]).invoke(invoke, new Object[0]);
+                        Object invoke4 = invoke.getClass().getMethod("getSafeInsetBottom", new Class[0]).invoke(invoke, new Object[0]);
+                        Object invoke5 = invoke.getClass().getMethod("getSafeInsetLeft", new Class[0]).invoke(invoke, new Object[0]);
+                        jSONObject.put("top", invoke2);
+                        jSONObject.put(TtmlNode.RIGHT, invoke3);
+                        jSONObject.put(Consts.SDK_BANNER_POSITION_BOTTOM, invoke4);
+                        jSONObject.put("left", invoke5);
+                        webViewCallback.invoke(jSONObject);
+                    } else {
+                        webViewCallback.error(AdUnitError.NO_DISPLAY_CUTOUT_AVAILABLE, new Object[0]);
+                    }
+                    return;
+                } catch (IllegalAccessException e) {
+                    e = e;
+                    webViewCallback.error(AdUnitError.DISPLAY_CUTOUT_INVOKE_FAILED, new Object[0]);
+                    DeviceLog.debug("Error while calling displayCutout getter", e);
+                    return;
+                } catch (NoSuchMethodException e2) {
+                    webViewCallback.error(AdUnitError.DISPLAY_CUTOUT_METHOD_NOT_AVAILABLE, new Object[0]);
+                    DeviceLog.debug("Method getDisplayCutout not found", e2);
+                    return;
+                } catch (InvocationTargetException e3) {
+                    e = e3;
+                    webViewCallback.error(AdUnitError.DISPLAY_CUTOUT_INVOKE_FAILED, new Object[0]);
+                    DeviceLog.debug("Error while calling displayCutout getter", e);
+                    return;
+                } catch (JSONException e4) {
+                    webViewCallback.error(AdUnitError.DISPLAY_CUTOUT_JSON_ERROR, new Object[0]);
+                    DeviceLog.debug("JSON error while constructing display cutout object", e4);
+                    return;
+                }
+            }
+            webViewCallback.error(AdUnitError.NO_DISPLAY_CUTOUT_AVAILABLE, new Object[0]);
+            return;
+        }
+        webViewCallback.error(AdUnitError.API_LEVEL_ERROR, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void setLayoutInDisplayCutoutMode(final Integer num, WebViewCallback webViewCallback) {
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.AdUnit.6
+            @Override // java.lang.Runnable
+            public void run() {
+                if (AdUnit.getAdUnitActivity() != null) {
+                    AdUnit.getAdUnitActivity().setLayoutInDisplayCutoutMode(num.intValue());
+                }
+            }
+        });
+        if (getAdUnitActivity() != null) {
+            webViewCallback.invoke(num);
+        } else {
+            webViewCallback.error(AdUnitError.ADUNIT_NULL, new Object[0]);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static String[] getViewList(JSONArray jSONArray) throws JSONException {
+        String[] strArr = new String[jSONArray.length()];
+        for (int i = 0; i < jSONArray.length(); i++) {
+            strArr[i] = jSONArray.getString(i);
+        }
+        return strArr;
+    }
+
+    private static ArrayList<Integer> getKeyEventList(JSONArray jSONArray) throws JSONException {
+        ArrayList<Integer> arrayList = new ArrayList<>();
+        int i = 0;
+        while (true) {
+            Integer valueOf = Integer.valueOf(i);
+            if (valueOf.intValue() >= jSONArray.length()) {
+                return arrayList;
+            }
+            arrayList.add(Integer.valueOf(jSONArray.getInt(valueOf.intValue())));
+            i = valueOf.intValue() + 1;
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/GMAScar.java

@@ -0,0 +1,47 @@
+package com.unity3d.services.ads.api;
+
+import com.unity3d.scar.adapter.common.scarads.UnityAdFormat;
+import com.unity3d.services.ads.gmascar.GMA;
+import com.unity3d.services.ads.gmascar.GMAScarAdapterBridge;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+
+/* loaded from: classes4.dex */
+public class GMAScar {
+    private static final GMAScarAdapterBridge gmaScarAdapterBridge = GMA.getInstance().getBridge();
+
+    @WebViewExposed
+    public static void initializeScar(WebViewCallback webViewCallback) {
+        gmaScarAdapterBridge.initializeScar();
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void getVersion(WebViewCallback webViewCallback) {
+        gmaScarAdapterBridge.getVersion();
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    public static void isInitialized(WebViewCallback webViewCallback) {
+        gmaScarAdapterBridge.isInitialized();
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void getSCARSignal(String str, String str2, WebViewCallback webViewCallback) {
+        gmaScarAdapterBridge.getSCARSignal(str, UnityAdFormat.valueOf(str2.toUpperCase()));
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void load(String str, String str2, Boolean bool, String str3, String str4, Integer num, WebViewCallback webViewCallback) {
+        gmaScarAdapterBridge.load(bool.booleanValue(), str, str2, str4, str3, num.intValue());
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void show(String str, String str2, Boolean bool, WebViewCallback webViewCallback) {
+        gmaScarAdapterBridge.show(str, str2, bool.booleanValue());
+        webViewCallback.invoke(new Object[0]);
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/Load.java

@@ -0,0 +1,21 @@
+package com.unity3d.services.ads.api;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.ads.operation.load.LoadModule;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+
+/* loaded from: classes4.dex */
+public class Load {
+    @WebViewExposed
+    public static void sendAdLoaded(String str, String str2, WebViewCallback webViewCallback) {
+        LoadModule.getInstance().onUnityAdsAdLoaded(str2);
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void sendAdFailedToLoad(String str, String str2, String str3, String str4, WebViewCallback webViewCallback) {
+        LoadModule.getInstance().onUnityAdsFailedToLoad(str2, UnityAds.UnityAdsLoadError.valueOf(str3), str4);
+        webViewCallback.invoke(new Object[0]);
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/Measurements.java

@@ -0,0 +1,44 @@
+package com.unity3d.services.ads.api;
+
+import android.view.InputEvent;
+import com.unity3d.services.ads.measurements.MeasurementsErrors;
+import com.unity3d.services.ads.measurements.MeasurementsService;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+
+/* loaded from: classes4.dex */
+public class Measurements {
+    private static final MeasurementsService measurementsService = (MeasurementsService) Utilities.getService(MeasurementsService.class);
+
+    @WebViewExposed
+    public static void checkAvailability(WebViewCallback webViewCallback) {
+        measurementsService.checkAvailability();
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void registerView(String str, WebViewCallback webViewCallback) {
+        measurementsService.registerView(str);
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void registerClick(String str, WebViewCallback webViewCallback) {
+        if (AdUnit.getAdUnitActivity() == null) {
+            webViewCallback.error(MeasurementsErrors.ERROR_AD_UNIT_NULL, new Object[0]);
+            return;
+        }
+        if (AdUnit.getAdUnitActivity().getLayout() == null) {
+            webViewCallback.error(MeasurementsErrors.ERROR_LAYOUT_NULL, new Object[0]);
+            return;
+        }
+        InputEvent lastInputEvent = AdUnit.getAdUnitActivity().getLayout().getLastInputEvent();
+        if (lastInputEvent == null) {
+            webViewCallback.error(MeasurementsErrors.ERROR_LAST_INPUT_EVENT_NULL, new Object[0]);
+        } else {
+            measurementsService.registerClick(str, lastInputEvent);
+            webViewCallback.invoke(new Object[0]);
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/Show.java

@@ -0,0 +1,39 @@
+package com.unity3d.services.ads.api;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.ads.operation.show.ShowModule;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+
+/* loaded from: classes4.dex */
+public class Show {
+    @WebViewExposed
+    public static void sendShowFailedEvent(String str, String str2, String str3, String str4, WebViewCallback webViewCallback) {
+        ShowModule.getInstance().onUnityAdsShowFailure(str2, UnityAds.UnityAdsShowError.valueOf(str3), str4);
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void sendShowConsentEvent(String str, String str2, WebViewCallback webViewCallback) {
+        ShowModule.getInstance().onUnityAdsShowConsent(str2);
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void sendShowStartEvent(String str, String str2, WebViewCallback webViewCallback) {
+        ShowModule.getInstance().onUnityAdsShowStart(str2);
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void sendShowClickEvent(String str, String str2, WebViewCallback webViewCallback) {
+        ShowModule.getInstance().onUnityAdsShowClick(str2);
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void sendShowCompleteEvent(String str, String str2, String str3, WebViewCallback webViewCallback) {
+        ShowModule.getInstance().onUnityAdsShowComplete(str2, UnityAds.UnityAdsShowCompletionState.valueOf(str3));
+        webViewCallback.invoke(new Object[0]);
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/Token.java

@@ -0,0 +1,46 @@
+package com.unity3d.services.ads.api;
+
+import com.unity3d.services.ads.token.TokenError;
+import com.unity3d.services.ads.token.TokenStorage;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+/* loaded from: classes4.dex */
+public class Token {
+    private static final TokenStorage tokenStorage = (TokenStorage) Utilities.getService(TokenStorage.class);
+
+    @WebViewExposed
+    public static void createTokens(JSONArray jSONArray, WebViewCallback webViewCallback) {
+        try {
+            tokenStorage.createTokens(jSONArray);
+            webViewCallback.invoke(new Object[0]);
+        } catch (JSONException e) {
+            webViewCallback.error(TokenError.JSON_EXCEPTION, e.getMessage());
+        }
+    }
+
+    @WebViewExposed
+    public static void appendTokens(JSONArray jSONArray, WebViewCallback webViewCallback) {
+        try {
+            tokenStorage.appendTokens(jSONArray);
+            webViewCallback.invoke(new Object[0]);
+        } catch (JSONException e) {
+            webViewCallback.error(TokenError.JSON_EXCEPTION, e.getMessage());
+        }
+    }
+
+    @WebViewExposed
+    public static void deleteTokens(WebViewCallback webViewCallback) {
+        tokenStorage.deleteTokens();
+        webViewCallback.invoke(new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void getNativeGeneratedToken(WebViewCallback webViewCallback) {
+        tokenStorage.getNativeGeneratedToken();
+        webViewCallback.invoke(new Object[0]);
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/Topics.java

@@ -0,0 +1,22 @@
+package com.unity3d.services.ads.api;
+
+import com.unity3d.services.ads.topics.TopicsService;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+
+/* loaded from: classes4.dex */
+public class Topics {
+    private static final TopicsService topicsService = (TopicsService) Utilities.getService(TopicsService.class);
+
+    @WebViewExposed
+    public static void checkAvailability(WebViewCallback webViewCallback) {
+        webViewCallback.invoke(topicsService.checkAvailability());
+    }
+
+    @WebViewExposed
+    public static void getTopics(String str, Boolean bool, WebViewCallback webViewCallback) {
+        topicsService.getTopics(str, bool.booleanValue());
+        webViewCallback.invoke(new Object[0]);
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/VideoPlayer.java

@@ -0,0 +1,194 @@
+package com.unity3d.services.ads.api;
+
+import com.unity3d.services.ads.video.VideoPlayerError;
+import com.unity3d.services.ads.video.VideoPlayerEvent;
+import com.unity3d.services.ads.video.VideoPlayerView;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+
+/* loaded from: classes4.dex */
+public class VideoPlayer {
+    private static VideoPlayerView _videoPlayerView;
+
+    public static VideoPlayerView getVideoPlayerView() {
+        return _videoPlayerView;
+    }
+
+    public static void setVideoPlayerView(VideoPlayerView videoPlayerView) {
+        _videoPlayerView = videoPlayerView;
+    }
+
+    @WebViewExposed
+    public static void setProgressEventInterval(final Integer num, WebViewCallback webViewCallback) {
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.VideoPlayer.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (VideoPlayer.getVideoPlayerView() != null) {
+                    VideoPlayer.getVideoPlayerView().setProgressEventInterval(num.intValue());
+                }
+            }
+        });
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getProgressEventInterval(WebViewCallback webViewCallback) {
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(Integer.valueOf(getVideoPlayerView().getProgressEventInterval()));
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void prepare(String str, Double d, WebViewCallback webViewCallback) {
+        prepare(str, d, 0, webViewCallback);
+    }
+
+    @WebViewExposed
+    public static void prepare(final String str, final Double d, final Integer num, WebViewCallback webViewCallback) {
+        DeviceLog.debug("Preparing video for playback: " + str);
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.VideoPlayer.2
+            @Override // java.lang.Runnable
+            public void run() {
+                if (VideoPlayer.getVideoPlayerView() != null) {
+                    VideoPlayer.getVideoPlayerView().prepare(str, d.floatValue(), num.intValue());
+                }
+            }
+        });
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(str);
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void play(WebViewCallback webViewCallback) {
+        DeviceLog.debug("Starting playback of prepared video");
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.VideoPlayer.3
+            @Override // java.lang.Runnable
+            public void run() {
+                if (VideoPlayer.getVideoPlayerView() != null) {
+                    VideoPlayer.getVideoPlayerView().play();
+                }
+            }
+        });
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void pause(WebViewCallback webViewCallback) {
+        DeviceLog.debug("Pausing current video");
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.VideoPlayer.4
+            @Override // java.lang.Runnable
+            public void run() {
+                if (VideoPlayer.getVideoPlayerView() != null) {
+                    VideoPlayer.getVideoPlayerView().pause();
+                }
+            }
+        });
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void stop(WebViewCallback webViewCallback) {
+        DeviceLog.debug("Stopping current video");
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.VideoPlayer.5
+            @Override // java.lang.Runnable
+            public void run() {
+                if (VideoPlayer.getVideoPlayerView() != null) {
+                    VideoPlayer.getVideoPlayerView().stop();
+                }
+            }
+        });
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void seekTo(final Integer num, WebViewCallback webViewCallback) {
+        DeviceLog.debug("Seeking video to time: " + num);
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.VideoPlayer.6
+            @Override // java.lang.Runnable
+            public void run() {
+                if (VideoPlayer.getVideoPlayerView() != null) {
+                    VideoPlayer.getVideoPlayerView().seekTo(num.intValue());
+                }
+            }
+        });
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getCurrentPosition(WebViewCallback webViewCallback) {
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(Integer.valueOf(getVideoPlayerView().getCurrentPosition()));
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getVolume(WebViewCallback webViewCallback) {
+        if (getVideoPlayerView() != null) {
+            webViewCallback.invoke(Float.valueOf(getVideoPlayerView().getVolume()));
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setVolume(Double d, WebViewCallback webViewCallback) {
+        DeviceLog.debug("Setting video volume: " + d);
+        if (getVideoPlayerView() != null) {
+            getVideoPlayerView().setVolume(Float.valueOf(d.floatValue()));
+            webViewCallback.invoke(d);
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setInfoListenerEnabled(boolean z, WebViewCallback webViewCallback) {
+        if (getVideoPlayerView() != null) {
+            getVideoPlayerView().setInfoListenerEnabled(z);
+            webViewCallback.invoke(WebViewEventCategory.VIDEOPLAYER, VideoPlayerEvent.INFO, Boolean.valueOf(z));
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getVideoViewRectangle(WebViewCallback webViewCallback) {
+        VideoPlayerView videoPlayerView = getVideoPlayerView();
+        if (videoPlayerView != null) {
+            int[] videoViewRectangle = videoPlayerView.getVideoViewRectangle();
+            webViewCallback.invoke(Integer.valueOf(videoViewRectangle[0]), Integer.valueOf(videoViewRectangle[1]), Integer.valueOf(videoViewRectangle[2]), Integer.valueOf(videoViewRectangle[3]));
+        } else {
+            webViewCallback.error(VideoPlayerError.VIDEOVIEW_NULL, new Object[0]);
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/api/WebPlayer.java

@@ -0,0 +1,168 @@
+package com.unity3d.services.ads.api;
+
+import com.unity3d.services.ads.webplayer.WebPlayerError;
+import com.unity3d.services.ads.webplayer.WebPlayerEventBridge;
+import com.unity3d.services.ads.webplayer.WebPlayerSettingsCache;
+import com.unity3d.services.ads.webplayer.WebPlayerView;
+import com.unity3d.services.ads.webplayer.WebPlayerViewCache;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.webview.bridge.WebViewCallback;
+import com.unity3d.services.core.webview.bridge.WebViewExposed;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class WebPlayer {
+    @WebViewExposed
+    public static void setUrl(final String str, String str2, WebViewCallback webViewCallback) {
+        final WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str2);
+        if (webPlayer != null) {
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.WebPlayer.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    WebPlayerView.this.loadUrl(str);
+                }
+            });
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(WebPlayerError.WEBPLAYER_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setData(final String str, final String str2, final String str3, String str4, WebViewCallback webViewCallback) {
+        final WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str4);
+        if (webPlayer != null) {
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.WebPlayer.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    WebPlayerView.this.loadData(str, str2, str3);
+                }
+            });
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(WebPlayerError.WEBPLAYER_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setDataWithUrl(final String str, final String str2, final String str3, final String str4, String str5, WebViewCallback webViewCallback) {
+        final WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str5);
+        if (webPlayer != null) {
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.WebPlayer.3
+                @Override // java.lang.Runnable
+                public void run() {
+                    WebPlayerView.this.loadDataWithBaseURL(str, str2, str3, str4, null);
+                }
+            });
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(WebPlayerError.WEBPLAYER_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setSettings(final JSONObject jSONObject, final JSONObject jSONObject2, String str, WebViewCallback webViewCallback) {
+        WebPlayerSettingsCache.getInstance().addWebSettings(str, jSONObject);
+        WebPlayerSettingsCache.getInstance().addWebPlayerSettings(str, jSONObject2);
+        final WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str);
+        if (webPlayer != null) {
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.WebPlayer.4
+                @Override // java.lang.Runnable
+                public void run() {
+                    WebPlayerView.this.setSettings(jSONObject, jSONObject2);
+                }
+            });
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(WebPlayerError.WEBPLAYER_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void setEventSettings(final JSONObject jSONObject, String str, WebViewCallback webViewCallback) {
+        WebPlayerSettingsCache.getInstance().addWebPlayerEventSettings(str, jSONObject);
+        final WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str);
+        if (webPlayer != null) {
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.WebPlayer.5
+                @Override // java.lang.Runnable
+                public void run() {
+                    WebPlayerView.this.setEventSettings(jSONObject);
+                }
+            });
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(WebPlayerError.WEBPLAYER_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void clearSettings(String str, WebViewCallback webViewCallback) {
+        WebPlayerSettingsCache webPlayerSettingsCache = WebPlayerSettingsCache.getInstance();
+        webPlayerSettingsCache.removeWebSettings(str);
+        webPlayerSettingsCache.removeWebPlayerSettings(str);
+        webPlayerSettingsCache.removeWebPlayerEventSettings(str);
+        final WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str);
+        if (webPlayer != null) {
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.WebPlayer.6
+                @Override // java.lang.Runnable
+                public void run() {
+                    WebPlayerView.this.setSettings(new JSONObject(), new JSONObject());
+                    WebPlayerView.this.setEventSettings(new JSONObject());
+                }
+            });
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(WebPlayerError.WEBPLAYER_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getErroredSettings(String str, WebViewCallback webViewCallback) {
+        WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str);
+        if (webPlayer != null) {
+            Map<String, String> erroredSettings = webPlayer.getErroredSettings();
+            JSONObject jSONObject = new JSONObject();
+            try {
+                for (Map.Entry<String, String> entry : erroredSettings.entrySet()) {
+                    jSONObject.put(entry.getKey(), entry.getValue());
+                }
+            } catch (Exception e) {
+                DeviceLog.exception("Error forming JSON object", e);
+            }
+            webViewCallback.invoke(jSONObject);
+            webViewCallback.invoke(new Object[0]);
+            return;
+        }
+        webViewCallback.error(WebPlayerError.WEBPLAYER_NULL, new Object[0]);
+    }
+
+    @WebViewExposed
+    public static void sendEvent(JSONArray jSONArray, String str, WebViewCallback webViewCallback) {
+        WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str);
+        if (webPlayer != null) {
+            webPlayer.sendEvent(jSONArray);
+            webViewCallback.invoke(new Object[0]);
+        } else {
+            webViewCallback.error(WebPlayerError.WEBPLAYER_NULL, new Object[0]);
+        }
+    }
+
+    @WebViewExposed
+    public static void getFrame(final String str, final String str2, WebViewCallback webViewCallback) {
+        webViewCallback.invoke(new Object[0]);
+        final WebPlayerView webPlayer = WebPlayerViewCache.getInstance().getWebPlayer(str2);
+        if (webPlayer != null) {
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.api.WebPlayer.7
+                @Override // java.lang.Runnable
+                public void run() {
+                    int[] iArr = new int[2];
+                    WebPlayerView.this.getLocationOnScreen(iArr);
+                    WebPlayerEventBridge.sendGetFrameResponse(str, str2, iArr[0], iArr[1], WebPlayerView.this.getWidth(), WebPlayerView.this.getHeight(), WebPlayerView.this.getAlpha());
+                }
+            });
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/configuration/AdsModuleConfiguration.java

@@ -0,0 +1,70 @@
+package com.unity3d.services.ads.configuration;
+
+import com.ironsource.v8;
+import com.unity3d.services.ads.UnityAdsImplementation;
+import com.unity3d.services.ads.adunit.AdUnitOpen;
+import com.unity3d.services.ads.adunit.VideoPlayerHandler;
+import com.unity3d.services.ads.adunit.WebPlayerHandler;
+import com.unity3d.services.ads.adunit.WebViewHandler;
+import com.unity3d.services.ads.api.AdUnit;
+import com.unity3d.services.ads.api.GMAScar;
+import com.unity3d.services.ads.api.Load;
+import com.unity3d.services.ads.api.Measurements;
+import com.unity3d.services.ads.api.Show;
+import com.unity3d.services.ads.api.Token;
+import com.unity3d.services.ads.api.Topics;
+import com.unity3d.services.ads.api.VideoPlayer;
+import com.unity3d.services.ads.api.WebPlayer;
+import com.unity3d.services.ads.token.AsyncTokenStorage;
+import com.unity3d.services.ads.token.TokenStorage;
+import com.unity3d.services.core.configuration.Configuration;
+import com.unity3d.services.core.configuration.ErrorState;
+import com.unity3d.services.core.misc.Utilities;
+import java.net.InetAddress;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class AdsModuleConfiguration implements IAdsModuleConfiguration {
+    private InetAddress _address;
+    private final TokenStorage tokenStorage = (TokenStorage) Utilities.getService(TokenStorage.class);
+    private final AsyncTokenStorage asyncTokenStorage = (AsyncTokenStorage) Utilities.getService(AsyncTokenStorage.class);
+
+    @Override // com.unity3d.services.core.configuration.IModuleConfiguration
+    public Class[] getWebAppApiClassList() {
+        return new Class[]{AdUnit.class, VideoPlayer.class, WebPlayer.class, Load.class, Show.class, Token.class, GMAScar.class, Measurements.class, Topics.class};
+    }
+
+    @Override // com.unity3d.services.core.configuration.IModuleConfiguration
+    public boolean resetState(Configuration configuration) {
+        AdUnitOpen.setConfiguration(configuration);
+        UnityAdsImplementation.setConfiguration(configuration);
+        this.tokenStorage.deleteTokens();
+        this.asyncTokenStorage.setConfiguration(configuration);
+        return true;
+    }
+
+    @Override // com.unity3d.services.core.configuration.IModuleConfiguration
+    public boolean initErrorState(Configuration configuration, ErrorState errorState, String str) {
+        this.tokenStorage.setInitToken(null);
+        this.tokenStorage.deleteTokens();
+        return true;
+    }
+
+    @Override // com.unity3d.services.core.configuration.IModuleConfiguration
+    public boolean initCompleteState(Configuration configuration) {
+        AdUnitOpen.setConfiguration(configuration);
+        UnityAdsImplementation.setConfiguration(configuration);
+        this.asyncTokenStorage.setConfiguration(configuration);
+        return true;
+    }
+
+    @Override // com.unity3d.services.ads.configuration.IAdsModuleConfiguration
+    public Map<String, Class> getAdUnitViewHandlers() {
+        HashMap hashMap = new HashMap();
+        hashMap.put("videoplayer", VideoPlayerHandler.class);
+        hashMap.put("webplayer", WebPlayerHandler.class);
+        hashMap.put(v8.h.K, WebViewHandler.class);
+        return hashMap;
+    }
+}

decompiled/sources/com/unity3d/services/ads/configuration/IAdsModuleConfiguration.java

@@ -0,0 +1,9 @@
+package com.unity3d.services.ads.configuration;
+
+import com.unity3d.services.core.configuration.IModuleConfiguration;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface IAdsModuleConfiguration extends IModuleConfiguration {
+    Map<String, Class> getAdUnitViewHandlers();
+}

decompiled/sources/com/unity3d/services/ads/gmascar/GMA.java

@@ -0,0 +1,39 @@
+package com.unity3d.services.ads.gmascar;
+
+import com.unity3d.services.ads.gmascar.adapters.ScarAdapterFactory;
+import com.unity3d.services.ads.gmascar.bridges.AdapterStatusBridge;
+import com.unity3d.services.ads.gmascar.bridges.InitializationStatusBridge;
+import com.unity3d.services.ads.gmascar.bridges.InitializeListenerBridge;
+import com.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridgeFactory;
+import com.unity3d.services.ads.gmascar.handlers.BiddingSignalsHandler;
+import com.unity3d.services.ads.gmascar.handlers.WebViewErrorHandler;
+import com.unity3d.services.ads.gmascar.listeners.IBiddingSignalsListener;
+import com.unity3d.services.ads.gmascar.utils.GMAEventSender;
+
+/* loaded from: classes4.dex */
+public class GMA {
+    private static GMAScarAdapterBridge _gmaScarAdapterBridge = new GMAScarAdapterBridge(new MobileAdsBridgeFactory().createMobileAdsBridge(), new InitializeListenerBridge(), new InitializationStatusBridge(), new AdapterStatusBridge(), new WebViewErrorHandler(), new ScarAdapterFactory(), new GMAEventSender());
+    private static GMA instance;
+
+    public GMAScarAdapterBridge getBridge() {
+        return _gmaScarAdapterBridge;
+    }
+
+    private GMA() {
+    }
+
+    public static GMA getInstance() {
+        if (instance == null) {
+            instance = new GMA();
+        }
+        return instance;
+    }
+
+    public boolean hasSCARBiddingSupport() {
+        return _gmaScarAdapterBridge.hasSCARBiddingSupport();
+    }
+
+    public void getSCARBiddingSignals(boolean z, IBiddingSignalsListener iBiddingSignalsListener) {
+        _gmaScarAdapterBridge.getSCARBiddingSignals(z, new BiddingSignalsHandler(z, iBiddingSignalsListener));
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/GMAScarAdapterBridge.java

@@ -0,0 +1,173 @@
+package com.unity3d.services.ads.gmascar;
+
+import android.content.Context;
+import com.unity3d.scar.adapter.common.GMAAdsError;
+import com.unity3d.scar.adapter.common.GMAEvent;
+import com.unity3d.scar.adapter.common.IScarAdapter;
+import com.unity3d.scar.adapter.common.WebViewAdsError;
+import com.unity3d.scar.adapter.common.scarads.ScarAdMetadata;
+import com.unity3d.scar.adapter.common.scarads.UnityAdFormat;
+import com.unity3d.services.ads.gmascar.adapters.ScarAdapterFactory;
+import com.unity3d.services.ads.gmascar.bridges.AdapterStatusBridge;
+import com.unity3d.services.ads.gmascar.bridges.InitializationStatusBridge;
+import com.unity3d.services.ads.gmascar.bridges.InitializeListenerBridge;
+import com.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridgeBase;
+import com.unity3d.services.ads.gmascar.finder.GMAInitializer;
+import com.unity3d.services.ads.gmascar.finder.PresenceDetector;
+import com.unity3d.services.ads.gmascar.finder.ScarVersionFinder;
+import com.unity3d.services.ads.gmascar.handlers.BiddingSignalsHandler;
+import com.unity3d.services.ads.gmascar.handlers.ScarBannerAdHandler;
+import com.unity3d.services.ads.gmascar.handlers.ScarInterstitialAdHandler;
+import com.unity3d.services.ads.gmascar.handlers.ScarRewardedAdHandler;
+import com.unity3d.services.ads.gmascar.handlers.SignalsHandler;
+import com.unity3d.services.ads.gmascar.handlers.WebViewErrorHandler;
+import com.unity3d.services.ads.gmascar.utils.GMAEventSender;
+import com.unity3d.services.banners.BannerView;
+import com.unity3d.services.banners.UnityBannerSize;
+import com.unity3d.services.banners.bridge.BannerBridge;
+import com.unity3d.services.core.misc.EventSubject;
+import com.unity3d.services.core.properties.ClientProperties;
+import com.unity3d.services.core.timer.DefaultIntervalTimerFactory;
+import com.unity3d.services.core.webview.WebViewApp;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public class GMAScarAdapterBridge {
+    private final AdapterStatusBridge _adapterStatusBridge;
+    private final GMAEventSender _gmaEventSender;
+    private final GMAInitializer _gmaInitializer;
+    private final InitializeListenerBridge _initializationListenerBridge;
+    private final InitializationStatusBridge _initializationStatusBridge;
+    private final MobileAdsBridgeBase _mobileAdsBridge;
+    private final PresenceDetector _presenceDetector;
+    private IScarAdapter _scarAdapter;
+    private final ScarAdapterFactory _scarAdapterFactory;
+    private final ScarVersionFinder _scarVersionFinder;
+    private final WebViewErrorHandler _webViewErrorHandler;
+
+    public GMAScarAdapterBridge(MobileAdsBridgeBase mobileAdsBridgeBase, InitializeListenerBridge initializeListenerBridge, InitializationStatusBridge initializationStatusBridge, AdapterStatusBridge adapterStatusBridge, WebViewErrorHandler webViewErrorHandler, ScarAdapterFactory scarAdapterFactory, GMAEventSender gMAEventSender) {
+        this._initializationStatusBridge = initializationStatusBridge;
+        this._initializationListenerBridge = initializeListenerBridge;
+        this._adapterStatusBridge = adapterStatusBridge;
+        this._webViewErrorHandler = webViewErrorHandler;
+        this._scarAdapterFactory = scarAdapterFactory;
+        this._mobileAdsBridge = mobileAdsBridgeBase;
+        this._gmaEventSender = gMAEventSender;
+        PresenceDetector presenceDetector = new PresenceDetector(mobileAdsBridgeBase, initializeListenerBridge, initializationStatusBridge, adapterStatusBridge);
+        this._presenceDetector = presenceDetector;
+        GMAInitializer gMAInitializer = new GMAInitializer(mobileAdsBridgeBase, initializeListenerBridge, initializationStatusBridge, adapterStatusBridge, gMAEventSender);
+        this._gmaInitializer = gMAInitializer;
+        this._scarVersionFinder = new ScarVersionFinder(mobileAdsBridgeBase, presenceDetector, gMAInitializer, gMAEventSender);
+    }
+
+    public void initializeScar() {
+        if (this._presenceDetector.areGMAClassesPresent()) {
+            this._gmaEventSender.send(GMAEvent.SCAR_PRESENT, new Object[0]);
+            this._gmaInitializer.initializeGMA();
+        } else {
+            this._webViewErrorHandler.handleError((WebViewAdsError) new GMAAdsError(GMAEvent.SCAR_NOT_PRESENT, new Object[0]));
+        }
+    }
+
+    public boolean isInitialized() {
+        return this._gmaInitializer.isInitialized();
+    }
+
+    public void getVersion() {
+        this._scarVersionFinder.getVersion();
+    }
+
+    public void getSCARSignal(String str, UnityAdFormat unityAdFormat) {
+        this._scarAdapter = getScarAdapterObject();
+        SignalsHandler signalsHandler = new SignalsHandler(this._gmaEventSender);
+        IScarAdapter iScarAdapter = this._scarAdapter;
+        if (iScarAdapter != null) {
+            iScarAdapter.getSCARSignal(ClientProperties.getApplicationContext(), str, unityAdFormat, signalsHandler);
+        } else {
+            this._webViewErrorHandler.handleError((WebViewAdsError) GMAAdsError.InternalSignalsError("Could not create SCAR adapter object"));
+        }
+    }
+
+    public boolean hasSCARBiddingSupport() {
+        MobileAdsBridgeBase mobileAdsBridgeBase = this._mobileAdsBridge;
+        if (mobileAdsBridgeBase == null || !mobileAdsBridgeBase.hasSCARBiddingSupport()) {
+            return false;
+        }
+        IScarAdapter scarAdapterObject = getScarAdapterObject();
+        this._scarAdapter = scarAdapterObject;
+        return scarAdapterObject != null;
+    }
+
+    public void getSCARBiddingSignals(boolean z, BiddingSignalsHandler biddingSignalsHandler) {
+        MobileAdsBridgeBase mobileAdsBridgeBase = this._mobileAdsBridge;
+        if (mobileAdsBridgeBase != null && mobileAdsBridgeBase.hasSCARBiddingSupport()) {
+            IScarAdapter scarAdapterObject = getScarAdapterObject();
+            this._scarAdapter = scarAdapterObject;
+            if (scarAdapterObject != null) {
+                scarAdapterObject.getSCARBiddingSignals(ClientProperties.getApplicationContext(), z, biddingSignalsHandler);
+                return;
+            } else {
+                biddingSignalsHandler.onSignalsCollectionFailed("Could not create SCAR adapter object.");
+                return;
+            }
+        }
+        biddingSignalsHandler.onSignalsCollectionFailed("SCAR bidding unsupported.");
+    }
+
+    public void load(boolean z, String str, String str2, String str3, String str4, int i) {
+        ScarAdMetadata scarAdMetadata = new ScarAdMetadata(str, str2, str4, str3, Integer.valueOf(i));
+        IScarAdapter scarAdapterObject = getScarAdapterObject();
+        this._scarAdapter = scarAdapterObject;
+        if (scarAdapterObject == null) {
+            this._webViewErrorHandler.handleError((WebViewAdsError) GMAAdsError.InternalLoadError(scarAdMetadata, "Scar Adapter object is null"));
+        } else if (z) {
+            loadInterstitialAd(scarAdMetadata);
+        } else {
+            loadRewardedAd(scarAdMetadata);
+        }
+    }
+
+    private void loadInterstitialAd(ScarAdMetadata scarAdMetadata) {
+        this._scarAdapter.loadInterstitialAd(ClientProperties.getApplicationContext(), scarAdMetadata, new ScarInterstitialAdHandler(scarAdMetadata, getScarEventSubject(scarAdMetadata.getVideoLengthMs()), this._gmaEventSender));
+    }
+
+    private void loadRewardedAd(ScarAdMetadata scarAdMetadata) {
+        this._scarAdapter.loadRewardedAd(ClientProperties.getApplicationContext(), scarAdMetadata, new ScarRewardedAdHandler(scarAdMetadata, getScarEventSubject(scarAdMetadata.getVideoLengthMs()), this._gmaEventSender));
+    }
+
+    public void loadBanner(Context context, BannerView bannerView, String str, ScarAdMetadata scarAdMetadata, UnityBannerSize unityBannerSize) {
+        this._scarAdapter = getScarAdapterObject();
+        ScarBannerAdHandler scarBannerAdHandler = new ScarBannerAdHandler(str);
+        IScarAdapter iScarAdapter = this._scarAdapter;
+        if (iScarAdapter != null) {
+            iScarAdapter.loadBannerAd(context, bannerView, scarAdMetadata, unityBannerSize.getWidth(), unityBannerSize.getHeight(), scarBannerAdHandler);
+        } else {
+            WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.BANNER, BannerBridge.BannerEvent.SCAR_BANNER_LOAD_FAILED, str);
+        }
+    }
+
+    public void show(String str, String str2, boolean z) {
+        ScarAdMetadata scarAdMetadata = new ScarAdMetadata(str, str2);
+        IScarAdapter scarAdapterObject = getScarAdapterObject();
+        this._scarAdapter = scarAdapterObject;
+        if (scarAdapterObject != null) {
+            scarAdapterObject.show(ClientProperties.getActivity(), str2, str);
+        } else {
+            this._webViewErrorHandler.handleError((WebViewAdsError) GMAAdsError.InternalShowError(scarAdMetadata, "Scar Adapter object is null"));
+        }
+    }
+
+    private EventSubject getScarEventSubject(Integer num) {
+        return new EventSubject(new ArrayDeque(Arrays.asList(GMAEvent.FIRST_QUARTILE, GMAEvent.MIDPOINT, GMAEvent.THIRD_QUARTILE, GMAEvent.LAST_QUARTILE)), num, new DefaultIntervalTimerFactory());
+    }
+
+    private IScarAdapter getScarAdapterObject() {
+        MobileAdsBridgeBase mobileAdsBridgeBase;
+        if (this._scarAdapter == null && (mobileAdsBridgeBase = this._mobileAdsBridge) != null) {
+            this._scarAdapter = this._scarAdapterFactory.createScarAdapter(mobileAdsBridgeBase.getAdapterVersion(this._scarVersionFinder.getVersionCode()), this._webViewErrorHandler);
+        }
+        return this._scarAdapter;
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/adapters/ScarAdapterFactory.java

@@ -0,0 +1,61 @@
+package com.unity3d.services.ads.gmascar.adapters;
+
+import com.unity3d.scar.adapter.common.GMAAdsError;
+import com.unity3d.scar.adapter.common.IAdsErrorHandler;
+import com.unity3d.scar.adapter.common.IScarAdapter;
+import com.unity3d.scar.adapter.common.WebViewAdsError;
+import com.unity3d.scar.adapter.v2000.ScarAdapter;
+import com.unity3d.services.ads.gmascar.finder.ScarAdapterVersion;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.properties.SdkProperties;
+
+/* loaded from: classes4.dex */
+public class ScarAdapterFactory {
+
+    /* renamed from: com.unity3d.services.ads.gmascar.adapters.ScarAdapterFactory$1, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass1 {
+        static final /* synthetic */ int[] $SwitchMap$com$unity3d$services$ads$gmascar$finder$ScarAdapterVersion;
+
+        static {
+            int[] iArr = new int[ScarAdapterVersion.values().length];
+            $SwitchMap$com$unity3d$services$ads$gmascar$finder$ScarAdapterVersion = iArr;
+            try {
+                iArr[ScarAdapterVersion.V20.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$com$unity3d$services$ads$gmascar$finder$ScarAdapterVersion[ScarAdapterVersion.V21.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+            try {
+                $SwitchMap$com$unity3d$services$ads$gmascar$finder$ScarAdapterVersion[ScarAdapterVersion.V23.ordinal()] = 3;
+            } catch (NoSuchFieldError unused3) {
+            }
+            try {
+                $SwitchMap$com$unity3d$services$ads$gmascar$finder$ScarAdapterVersion[ScarAdapterVersion.NA.ordinal()] = 4;
+            } catch (NoSuchFieldError unused4) {
+            }
+        }
+    }
+
+    public IScarAdapter createScarAdapter(ScarAdapterVersion scarAdapterVersion, IAdsErrorHandler<WebViewAdsError> iAdsErrorHandler) {
+        int i = AnonymousClass1.$SwitchMap$com$unity3d$services$ads$gmascar$finder$ScarAdapterVersion[scarAdapterVersion.ordinal()];
+        if (i == 1) {
+            return new ScarAdapter(iAdsErrorHandler);
+        }
+        if (i == 2) {
+            return new com.unity3d.scar.adapter.v2100.ScarAdapter(iAdsErrorHandler, SdkProperties.getVersionName());
+        }
+        if (i == 3) {
+            return new com.unity3d.scar.adapter.v2300.ScarAdapter(iAdsErrorHandler, SdkProperties.getVersionName());
+        }
+        reportAdapterFailure(scarAdapterVersion, iAdsErrorHandler);
+        return null;
+    }
+
+    private void reportAdapterFailure(ScarAdapterVersion scarAdapterVersion, IAdsErrorHandler<WebViewAdsError> iAdsErrorHandler) {
+        String format = String.format("SCAR version %s is not supported.", scarAdapterVersion.name());
+        iAdsErrorHandler.handleError(GMAAdsError.AdapterCreationError(format));
+        DeviceLog.debug(format);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/AdapterStatusBridge.java

@@ -0,0 +1,43 @@
+package com.unity3d.services.ads.gmascar.bridges;
+
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.reflection.GenericBridge;
+import java.util.HashMap;
+
+/* loaded from: classes4.dex */
+public class AdapterStatusBridge extends GenericBridge {
+    private static final String initializeStateMethodName = "getInitializationState";
+    private Class _adapterStateClass;
+
+    @Override // com.unity3d.services.core.reflection.GenericBridge
+    public String getClassName() {
+        return "com.google.android.gms.ads.initialization.AdapterStatus";
+    }
+
+    public AdapterStatusBridge() {
+        super(new HashMap<String, Class<?>[]>() { // from class: com.unity3d.services.ads.gmascar.bridges.AdapterStatusBridge.1
+            {
+                put(AdapterStatusBridge.initializeStateMethodName, new Class[0]);
+            }
+        });
+        AdapterStatusStateBridge adapterStatusStateBridge = new AdapterStatusStateBridge();
+        try {
+            this._adapterStateClass = Class.forName(adapterStatusStateBridge.getClassName());
+        } catch (ClassNotFoundException e) {
+            DeviceLog.debug("ERROR: Could not find class %s %s", adapterStatusStateBridge.getClassName(), e.getLocalizedMessage());
+        }
+    }
+
+    public boolean isGMAInitialized(Object obj) {
+        Object[] adapterStatesEnum = getAdapterStatesEnum();
+        if (adapterStatesEnum != null) {
+            return callNonVoidMethod(initializeStateMethodName, obj, new Object[0]) == adapterStatesEnum[1];
+        }
+        DeviceLog.debug("ERROR: Could not get adapter states enum from AdapterStatus.State");
+        return false;
+    }
+
+    public Object[] getAdapterStatesEnum() {
+        return this._adapterStateClass.getEnumConstants();
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/AdapterStatusStateBridge.java

@@ -0,0 +1,8 @@
+package com.unity3d.services.ads.gmascar.bridges;
+
+/* loaded from: classes4.dex */
+public class AdapterStatusStateBridge {
+    public String getClassName() {
+        return "com.google.android.gms.ads.initialization.AdapterStatus$State";
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/InitializationStatusBridge.java

@@ -0,0 +1,27 @@
+package com.unity3d.services.ads.gmascar.bridges;
+
+import com.unity3d.services.core.reflection.GenericBridge;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class InitializationStatusBridge extends GenericBridge {
+    private static final String adapterStatusMapMethodName = "getAdapterStatusMap";
+
+    @Override // com.unity3d.services.core.reflection.GenericBridge
+    public String getClassName() {
+        return "com.google.android.gms.ads.initialization.InitializationStatus";
+    }
+
+    public InitializationStatusBridge() {
+        super(new HashMap<String, Class<?>[]>() { // from class: com.unity3d.services.ads.gmascar.bridges.InitializationStatusBridge.1
+            {
+                put(InitializationStatusBridge.adapterStatusMapMethodName, new Class[0]);
+            }
+        });
+    }
+
+    public Map<String, Object> getAdapterStatusMap(Object obj) {
+        return (Map) callNonVoidMethod(adapterStatusMapMethodName, obj, new Object[0]);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/InitializeListenerBridge.java

@@ -0,0 +1,55 @@
+package com.unity3d.services.ads.gmascar.bridges;
+
+import com.google.android.gms.ads.initialization.InitializationStatus;
+import com.unity3d.services.ads.gmascar.listeners.IInitializationStatusListener;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.reflection.GenericBridge;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.HashMap;
+
+/* loaded from: classes4.dex */
+public class InitializeListenerBridge extends GenericBridge {
+    private static final String initializationCompleteMethodName = "onInitializationComplete";
+    private IInitializationStatusListener _initializationStatusListener;
+
+    @Override // com.unity3d.services.core.reflection.GenericBridge
+    public String getClassName() {
+        return "com.google.android.gms.ads.initialization.OnInitializationCompleteListener";
+    }
+
+    public void setStatusListener(IInitializationStatusListener iInitializationStatusListener) {
+        this._initializationStatusListener = iInitializationStatusListener;
+    }
+
+    public InitializeListenerBridge() {
+        super(new HashMap<String, Class<?>[]>() { // from class: com.unity3d.services.ads.gmascar.bridges.InitializeListenerBridge.1
+            {
+                try {
+                    put(InitializeListenerBridge.initializationCompleteMethodName, new Class[]{InitializationStatus.class});
+                } catch (ClassNotFoundException e) {
+                    DeviceLog.debug("Could not find class \"com.google.android.gms.ads.initialization.InitializationStatus\" %s", e.getLocalizedMessage());
+                }
+            }
+        });
+    }
+
+    public Object createInitializeListenerProxy() {
+        try {
+            return Proxy.newProxyInstance(classForName().getClassLoader(), new Class[]{classForName()}, new InvocationHandler() { // from class: com.unity3d.services.ads.gmascar.bridges.InitializeListenerBridge.2
+                @Override // java.lang.reflect.InvocationHandler
+                public Object invoke(Object obj, Method method, Object[] objArr) {
+                    if (!method.getName().equals(InitializeListenerBridge.initializationCompleteMethodName) || InitializeListenerBridge.this._initializationStatusListener == null) {
+                        return null;
+                    }
+                    InitializeListenerBridge.this._initializationStatusListener.onInitializationComplete(objArr[0]);
+                    return null;
+                }
+            });
+        } catch (Exception unused) {
+            DeviceLog.debug("ERROR: Could not create InitializeCompletionListener");
+            return null;
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/mobileads/IMobileAdsBridge.java

@@ -0,0 +1,21 @@
+package com.unity3d.services.ads.gmascar.bridges.mobileads;
+
+import android.content.Context;
+import com.unity3d.services.ads.gmascar.finder.ScarAdapterVersion;
+
+/* loaded from: classes4.dex */
+public interface IMobileAdsBridge {
+    ScarAdapterVersion getAdapterVersion(int i);
+
+    Object getInitializationStatus();
+
+    int getVersionCodeIndex();
+
+    String getVersionMethodName();
+
+    String getVersionString();
+
+    void initialize(Context context, Object obj);
+
+    boolean shouldInitialize();
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/mobileads/MobileAdsBridge.java

@@ -0,0 +1,61 @@
+package com.unity3d.services.ads.gmascar.bridges.mobileads;
+
+import android.content.Context;
+import com.google.android.gms.ads.initialization.OnInitializationCompleteListener;
+import com.unity3d.services.ads.gmascar.finder.ScarAdapterVersion;
+import com.unity3d.services.core.configuration.ConfigurationReader;
+import com.unity3d.services.core.log.DeviceLog;
+import java.util.HashMap;
+
+/* loaded from: classes4.dex */
+public class MobileAdsBridge extends MobileAdsBridgeBase {
+    public static final int CODE_21 = 21;
+    public static final String versionMethodName = "getVersion";
+    private ConfigurationReader _configurationReader;
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public int getVersionCodeIndex() {
+        return 0;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public String getVersionMethodName() {
+        return versionMethodName;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridgeBase
+    public boolean hasSCARBiddingSupport() {
+        return true;
+    }
+
+    public MobileAdsBridge() {
+        super(new HashMap<String, Class<?>[]>() { // from class: com.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridge.1
+            {
+                try {
+                    put(MobileAdsBridgeBase.initializeMethodName, new Class[]{Context.class, OnInitializationCompleteListener.class});
+                } catch (ClassNotFoundException e) {
+                    DeviceLog.debug("Could not find class \"com.google.android.gms.ads.initialization.OnInitializationCompleteListener\" %s", e.getLocalizedMessage());
+                }
+                put(MobileAdsBridgeBase.initializationStatusMethodName, new Class[0]);
+                put(MobileAdsBridge.versionMethodName, new Class[0]);
+            }
+        });
+        this._configurationReader = new ConfigurationReader();
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public ScarAdapterVersion getAdapterVersion(int i) {
+        if (i == -1) {
+            return ScarAdapterVersion.NA;
+        }
+        if (i < 23) {
+            return ScarAdapterVersion.V21;
+        }
+        return ScarAdapterVersion.V23;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public boolean shouldInitialize() {
+        return this._configurationReader.getCurrentConfiguration().getExperiments().isScarInitEnabled();
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/mobileads/MobileAdsBridgeBase.java

@@ -0,0 +1,38 @@
+package com.unity3d.services.ads.gmascar.bridges.mobileads;
+
+import android.content.Context;
+import com.unity3d.services.core.reflection.GenericBridge;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public abstract class MobileAdsBridgeBase extends GenericBridge implements IMobileAdsBridge {
+    public static final String initializationStatusMethodName = "getInitializationStatus";
+    public static final String initializeMethodName = "initialize";
+
+    @Override // com.unity3d.services.core.reflection.GenericBridge
+    public String getClassName() {
+        return "com.google.android.gms.ads.MobileAds";
+    }
+
+    public abstract boolean hasSCARBiddingSupport();
+
+    public MobileAdsBridgeBase(Map<String, Class<?>[]> map) {
+        super(map);
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public void initialize(Context context, Object obj) {
+        callVoidMethod(initializeMethodName, null, context, obj);
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public Object getInitializationStatus() {
+        return callNonVoidMethod(initializationStatusMethodName, null, new Object[0]);
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public String getVersionString() {
+        Object callNonVoidMethod = callNonVoidMethod(getVersionMethodName(), null, new Object[0]);
+        return callNonVoidMethod == null ? "0.0.0" : callNonVoidMethod.toString();
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/mobileads/MobileAdsBridgeFactory.java

@@ -0,0 +1,16 @@
+package com.unity3d.services.ads.gmascar.bridges.mobileads;
+
+/* loaded from: classes4.dex */
+public class MobileAdsBridgeFactory {
+    public MobileAdsBridgeBase createMobileAdsBridge() {
+        MobileAdsBridge mobileAdsBridge = new MobileAdsBridge();
+        if (mobileAdsBridge.exists()) {
+            return mobileAdsBridge;
+        }
+        MobileAdsBridgeLegacy mobileAdsBridgeLegacy = new MobileAdsBridgeLegacy();
+        if (mobileAdsBridgeLegacy.exists()) {
+            return mobileAdsBridgeLegacy;
+        }
+        return null;
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/bridges/mobileads/MobileAdsBridgeLegacy.java

@@ -0,0 +1,56 @@
+package com.unity3d.services.ads.gmascar.bridges.mobileads;
+
+import android.content.Context;
+import com.google.android.gms.ads.initialization.OnInitializationCompleteListener;
+import com.unity3d.services.ads.gmascar.finder.ScarAdapterVersion;
+import com.unity3d.services.core.log.DeviceLog;
+import java.util.HashMap;
+
+/* loaded from: classes4.dex */
+public class MobileAdsBridgeLegacy extends MobileAdsBridgeBase {
+    public static final int CODE_20_0 = 210402000;
+    public static final int CODE_21_0 = 221310000;
+    public static final String versionStringMethodName = "getVersionString";
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public int getVersionCodeIndex() {
+        return 1;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public String getVersionMethodName() {
+        return versionStringMethodName;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridgeBase
+    public boolean hasSCARBiddingSupport() {
+        return false;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public boolean shouldInitialize() {
+        return true;
+    }
+
+    public MobileAdsBridgeLegacy() {
+        super(new HashMap<String, Class<?>[]>() { // from class: com.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridgeLegacy.1
+            {
+                try {
+                    put(MobileAdsBridgeBase.initializeMethodName, new Class[]{Context.class, OnInitializationCompleteListener.class});
+                } catch (ClassNotFoundException e) {
+                    DeviceLog.debug("Could not find class \"com.google.android.gms.ads.initialization.OnInitializationCompleteListener\" %s", e.getLocalizedMessage());
+                }
+                put(MobileAdsBridgeBase.initializationStatusMethodName, new Class[0]);
+                put(MobileAdsBridgeLegacy.versionStringMethodName, new Class[0]);
+            }
+        });
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge
+    public ScarAdapterVersion getAdapterVersion(int i) {
+        if (i >= 210402000 && i < 221310000) {
+            return ScarAdapterVersion.V20;
+        }
+        return ScarAdapterVersion.NA;
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/finder/GMAInitializer.java

@@ -0,0 +1,66 @@
+package com.unity3d.services.ads.gmascar.finder;
+
+import com.unity3d.scar.adapter.common.GMAEvent;
+import com.unity3d.services.ads.gmascar.bridges.AdapterStatusBridge;
+import com.unity3d.services.ads.gmascar.bridges.InitializationStatusBridge;
+import com.unity3d.services.ads.gmascar.bridges.InitializeListenerBridge;
+import com.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridgeBase;
+import com.unity3d.services.ads.gmascar.utils.GMAEventSender;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.properties.ClientProperties;
+
+/* loaded from: classes4.dex */
+public class GMAInitializer {
+    private AdapterStatusBridge _adapterStatusBridge;
+    private GMAEventSender _gmaEventSender;
+    private InitializeListenerBridge _initializationListenerBridge;
+    private InitializationStatusBridge _initializationStatusBridge;
+    private MobileAdsBridgeBase _mobileAdsBridge;
+
+    public InitializeListenerBridge getInitializeListenerBridge() {
+        return this._initializationListenerBridge;
+    }
+
+    public GMAInitializer(MobileAdsBridgeBase mobileAdsBridgeBase, InitializeListenerBridge initializeListenerBridge, InitializationStatusBridge initializationStatusBridge, AdapterStatusBridge adapterStatusBridge, GMAEventSender gMAEventSender) {
+        this._mobileAdsBridge = mobileAdsBridgeBase;
+        this._initializationListenerBridge = initializeListenerBridge;
+        this._initializationStatusBridge = initializationStatusBridge;
+        this._adapterStatusBridge = adapterStatusBridge;
+        this._gmaEventSender = gMAEventSender;
+    }
+
+    public void initializeGMA() {
+        if (shouldInitialize()) {
+            this._mobileAdsBridge.initialize(ClientProperties.getApplicationContext(), this._initializationListenerBridge.createInitializeListenerProxy());
+        }
+    }
+
+    public boolean initSuccessful(Object obj) {
+        Object obj2 = this._initializationStatusBridge.getAdapterStatusMap(obj).get(this._mobileAdsBridge.getClassName());
+        if (obj2 != null) {
+            if (this._adapterStatusBridge.isGMAInitialized(obj2)) {
+                this._gmaEventSender.send(GMAEvent.INIT_SUCCESS, new Object[0]);
+                return true;
+            }
+            this._gmaEventSender.send(GMAEvent.INIT_ERROR, new Object[0]);
+        }
+        return false;
+    }
+
+    public boolean isInitialized() {
+        try {
+            return initSuccessful(this._mobileAdsBridge.getInitializationStatus());
+        } catch (Exception e) {
+            DeviceLog.debug("ERROR: Could not get initialization status of GMA SDK - %s", e.getLocalizedMessage());
+            return false;
+        }
+    }
+
+    public boolean shouldInitialize() {
+        if (isInitialized()) {
+            this._gmaEventSender.send(GMAEvent.ALREADY_INITIALIZED, new Object[0]);
+            return false;
+        }
+        return this._mobileAdsBridge.shouldInitialize();
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/finder/PresenceDetector.java

@@ -0,0 +1,26 @@
+package com.unity3d.services.ads.gmascar.finder;
+
+import com.unity3d.services.ads.gmascar.bridges.AdapterStatusBridge;
+import com.unity3d.services.ads.gmascar.bridges.InitializationStatusBridge;
+import com.unity3d.services.ads.gmascar.bridges.InitializeListenerBridge;
+import com.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridgeBase;
+
+/* loaded from: classes4.dex */
+public class PresenceDetector {
+    private AdapterStatusBridge _adapterStatusBridge;
+    private InitializeListenerBridge _initializationListenerBridge;
+    private InitializationStatusBridge _initializationStatusBridge;
+    private MobileAdsBridgeBase _mobileAdsBridge;
+
+    public PresenceDetector(MobileAdsBridgeBase mobileAdsBridgeBase, InitializeListenerBridge initializeListenerBridge, InitializationStatusBridge initializationStatusBridge, AdapterStatusBridge adapterStatusBridge) {
+        this._mobileAdsBridge = mobileAdsBridgeBase;
+        this._initializationListenerBridge = initializeListenerBridge;
+        this._initializationStatusBridge = initializationStatusBridge;
+        this._adapterStatusBridge = adapterStatusBridge;
+    }
+
+    public boolean areGMAClassesPresent() {
+        MobileAdsBridgeBase mobileAdsBridgeBase = this._mobileAdsBridge;
+        return mobileAdsBridgeBase != null && this._initializationListenerBridge != null && this._initializationStatusBridge != null && this._adapterStatusBridge != null && mobileAdsBridgeBase.exists() && this._initializationListenerBridge.exists() && this._initializationStatusBridge.exists() && this._adapterStatusBridge.exists();
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/finder/ScarAdapterVersion.java

@@ -0,0 +1,9 @@
+package com.unity3d.services.ads.gmascar.finder;
+
+/* loaded from: classes4.dex */
+public enum ScarAdapterVersion {
+    V20,
+    V21,
+    V23,
+    NA
+}

decompiled/sources/com/unity3d/services/ads/gmascar/finder/ScarVersionFinder.java

@@ -0,0 +1,61 @@
+package com.unity3d.services.ads.gmascar.finder;
+
+import com.unity3d.services.ads.gmascar.bridges.mobileads.IMobileAdsBridge;
+import com.unity3d.services.ads.gmascar.listeners.IInitializationStatusListener;
+import com.unity3d.services.ads.gmascar.utils.GMAEventSender;
+import com.unity3d.services.core.log.DeviceLog;
+
+/* loaded from: classes4.dex */
+public class ScarVersionFinder implements IInitializationStatusListener {
+    private static IMobileAdsBridge _mobileAdsBridge;
+    private GMAEventSender _gmaEventSender;
+    private GMAInitializer _gmaInitializer;
+    private int _gmaSdkVersionCode = -1;
+    private PresenceDetector _presenceDetector;
+
+    public ScarVersionFinder(IMobileAdsBridge iMobileAdsBridge, PresenceDetector presenceDetector, GMAInitializer gMAInitializer, GMAEventSender gMAEventSender) {
+        _mobileAdsBridge = iMobileAdsBridge;
+        this._presenceDetector = presenceDetector;
+        this._gmaInitializer = gMAInitializer;
+        this._gmaEventSender = gMAEventSender;
+        gMAInitializer.getInitializeListenerBridge().setStatusListener(this);
+    }
+
+    public void getVersion() {
+        try {
+            if (!this._presenceDetector.areGMAClassesPresent()) {
+                this._gmaEventSender.sendVersion("0.0.0");
+            } else if (this._gmaInitializer.shouldInitialize()) {
+                this._gmaInitializer.initializeGMA();
+            } else {
+                findAndSendVersion(true);
+            }
+        } catch (Exception e) {
+            DeviceLog.debug("Got exception finding GMA SDK: %s", e.getLocalizedMessage());
+        }
+    }
+
+    public void findAndSendVersion(boolean z) {
+        this._gmaEventSender.sendVersion(z ? _mobileAdsBridge.getVersionString() : "0.0.0");
+    }
+
+    public int getVersionCode() {
+        String versionString;
+        if (this._gmaSdkVersionCode == -1 && (versionString = _mobileAdsBridge.getVersionString()) != null) {
+            String[] split = versionString.split("\\.");
+            if (split.length > _mobileAdsBridge.getVersionCodeIndex()) {
+                try {
+                    this._gmaSdkVersionCode = Integer.parseInt(split[_mobileAdsBridge.getVersionCodeIndex()]);
+                } catch (NumberFormatException e) {
+                    DeviceLog.debug("Could not parse %s to an Integer: %s", split[_mobileAdsBridge.getVersionCodeIndex()], e.getLocalizedMessage());
+                }
+            }
+        }
+        return this._gmaSdkVersionCode;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.listeners.IInitializationStatusListener
+    public void onInitializationComplete(Object obj) {
+        findAndSendVersion(this._gmaInitializer.initSuccessful(obj));
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/handlers/BiddingSignalsHandler.java

@@ -0,0 +1,45 @@
+package com.unity3d.services.ads.gmascar.handlers;
+
+import com.unity3d.scar.adapter.common.signals.ISignalCollectionListener;
+import com.unity3d.scar.adapter.common.signals.SignalsCollectorBase;
+import com.unity3d.services.ads.gmascar.listeners.IBiddingSignalsListener;
+import com.unity3d.services.ads.gmascar.models.BiddingSignals;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class BiddingSignalsHandler implements ISignalCollectionListener {
+    private final boolean isBannerEnabled;
+    private final IBiddingSignalsListener listener;
+
+    public BiddingSignalsHandler(boolean z, IBiddingSignalsListener iBiddingSignalsListener) {
+        this.listener = iBiddingSignalsListener;
+        this.isBannerEnabled = z;
+    }
+
+    @Override // com.unity3d.scar.adapter.common.signals.ISignalCollectionListener
+    public void onSignalsCollected(String str) {
+        this.listener.onSignalsReady(getSignals(str));
+    }
+
+    @Override // com.unity3d.scar.adapter.common.signals.ISignalCollectionListener
+    public void onSignalsCollectionFailed(String str) {
+        this.listener.onSignalsFailure(str);
+    }
+
+    private BiddingSignals getSignals(String str) {
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            if (this.isBannerEnabled) {
+                return new BiddingSignals(getSignalFromJson(jSONObject, SignalsCollectorBase.SCAR_RV_SIGNAL), getSignalFromJson(jSONObject, SignalsCollectorBase.SCAR_INT_SIGNAL), getSignalFromJson(jSONObject, SignalsCollectorBase.SCAR_BAN_SIGNAL));
+            }
+            return new BiddingSignals(getSignalFromJson(jSONObject, SignalsCollectorBase.SCAR_RV_SIGNAL), getSignalFromJson(jSONObject, SignalsCollectorBase.SCAR_INT_SIGNAL));
+        } catch (JSONException unused) {
+            return null;
+        }
+    }
+
+    private String getSignalFromJson(JSONObject jSONObject, String str) {
+        return jSONObject.optString(str);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/handlers/ScarAdHandlerBase.java

@@ -0,0 +1,53 @@
+package com.unity3d.services.ads.gmascar.handlers;
+
+import com.unity3d.scar.adapter.common.GMAEvent;
+import com.unity3d.scar.adapter.common.IScarAdListenerWrapper;
+import com.unity3d.scar.adapter.common.scarads.ScarAdMetadata;
+import com.unity3d.services.ads.gmascar.utils.GMAEventSender;
+import com.unity3d.services.core.misc.EventSubject;
+import com.unity3d.services.core.misc.IEventListener;
+
+/* loaded from: classes4.dex */
+public abstract class ScarAdHandlerBase implements IScarAdListenerWrapper {
+    protected final EventSubject<GMAEvent> _eventSubject;
+    protected final GMAEventSender _gmaEventSender;
+    protected final ScarAdMetadata _scarAdMetadata;
+
+    public ScarAdHandlerBase(ScarAdMetadata scarAdMetadata, EventSubject<GMAEvent> eventSubject, GMAEventSender gMAEventSender) {
+        this._scarAdMetadata = scarAdMetadata;
+        this._eventSubject = eventSubject;
+        this._gmaEventSender = gMAEventSender;
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdLoaded() {
+        this._gmaEventSender.send(GMAEvent.AD_LOADED, this._scarAdMetadata.getPlacementId(), this._scarAdMetadata.getQueryId());
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdFailedToLoad(int i, String str) {
+        this._gmaEventSender.send(GMAEvent.LOAD_ERROR, this._scarAdMetadata.getPlacementId(), this._scarAdMetadata.getQueryId(), str, Integer.valueOf(i));
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdOpened() {
+        this._gmaEventSender.send(GMAEvent.AD_STARTED, new Object[0]);
+        this._eventSubject.subscribe(new IEventListener<GMAEvent>() { // from class: com.unity3d.services.ads.gmascar.handlers.ScarAdHandlerBase.1
+            @Override // com.unity3d.services.core.misc.IEventListener
+            public void onNextEvent(GMAEvent gMAEvent) {
+                ScarAdHandlerBase.this._gmaEventSender.send(gMAEvent, new Object[0]);
+            }
+        });
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdClicked() {
+        this._gmaEventSender.send(GMAEvent.AD_CLICKED, new Object[0]);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdClosed() {
+        this._gmaEventSender.send(GMAEvent.AD_CLOSED, new Object[0]);
+        this._eventSubject.unsubscribe();
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/handlers/ScarBannerAdHandler.java

@@ -0,0 +1,47 @@
+package com.unity3d.services.ads.gmascar.handlers;
+
+import com.unity3d.scar.adapter.common.IScarBannerAdListenerWrapper;
+import com.unity3d.services.banners.BannerViewCache;
+import com.unity3d.services.banners.bridge.BannerBridge;
+import com.unity3d.services.core.webview.WebViewApp;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+
+/* loaded from: classes4.dex */
+public class ScarBannerAdHandler implements IScarBannerAdListenerWrapper {
+    private String _operationId;
+
+    public ScarBannerAdHandler(String str) {
+        this._operationId = str;
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdLoaded() {
+        BannerViewCache.getInstance().addScarContainer(this._operationId);
+        WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.BANNER, BannerBridge.BannerEvent.SCAR_BANNER_LOADED, this._operationId);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdFailedToLoad(int i, String str) {
+        WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.BANNER, BannerBridge.BannerEvent.SCAR_BANNER_LOAD_FAILED, this._operationId, Integer.valueOf(i), str);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdOpened() {
+        WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.BANNER, BannerBridge.BannerEvent.SCAR_BANNER_OPENED, this._operationId);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdClicked() {
+        WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.BANNER, BannerBridge.BannerEvent.SCAR_BANNER_CLICKED, this._operationId);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdClosed() {
+        WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.BANNER, BannerBridge.BannerEvent.SCAR_BANNER_CLOSED, this._operationId);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarBannerAdListenerWrapper
+    public void onAdImpression() {
+        WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.BANNER, BannerBridge.BannerEvent.SCAR_BANNER_IMPRESSION, this._operationId);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/handlers/ScarInterstitialAdHandler.java

@@ -0,0 +1,42 @@
+package com.unity3d.services.ads.gmascar.handlers;
+
+import com.unity3d.scar.adapter.common.GMAEvent;
+import com.unity3d.scar.adapter.common.IScarInterstitialAdListenerWrapper;
+import com.unity3d.scar.adapter.common.scarads.ScarAdMetadata;
+import com.unity3d.services.ads.gmascar.utils.GMAEventSender;
+import com.unity3d.services.core.misc.EventSubject;
+
+/* loaded from: classes4.dex */
+public class ScarInterstitialAdHandler extends ScarAdHandlerBase implements IScarInterstitialAdListenerWrapper {
+    public ScarInterstitialAdHandler(ScarAdMetadata scarAdMetadata, EventSubject<GMAEvent> eventSubject, GMAEventSender gMAEventSender) {
+        super(scarAdMetadata, eventSubject, gMAEventSender);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarInterstitialAdListenerWrapper
+    public void onAdFailedToShow(int i, String str) {
+        this._gmaEventSender.send(GMAEvent.INTERSTITIAL_SHOW_ERROR, this._scarAdMetadata.getPlacementId(), this._scarAdMetadata.getQueryId(), str, Integer.valueOf(i));
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarInterstitialAdListenerWrapper
+    public void onAdSkipped() {
+        this._gmaEventSender.send(GMAEvent.AD_SKIPPED, new Object[0]);
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.handlers.ScarAdHandlerBase, com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdClosed() {
+        if (!this._eventSubject.eventQueueIsEmpty()) {
+            onAdSkipped();
+        }
+        super.onAdClosed();
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarInterstitialAdListenerWrapper
+    public void onAdLeftApplication() {
+        this._gmaEventSender.send(GMAEvent.AD_LEFT_APPLICATION, new Object[0]);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarInterstitialAdListenerWrapper
+    public void onAdImpression() {
+        this._gmaEventSender.send(GMAEvent.INTERSTITIAL_IMPRESSION_RECORDED, new Object[0]);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/handlers/ScarRewardedAdHandler.java

@@ -0,0 +1,46 @@
+package com.unity3d.services.ads.gmascar.handlers;
+
+import com.unity3d.scar.adapter.common.GMAEvent;
+import com.unity3d.scar.adapter.common.IScarRewardedAdListenerWrapper;
+import com.unity3d.scar.adapter.common.scarads.ScarAdMetadata;
+import com.unity3d.services.ads.gmascar.utils.GMAEventSender;
+import com.unity3d.services.core.misc.EventSubject;
+
+/* loaded from: classes4.dex */
+public class ScarRewardedAdHandler extends ScarAdHandlerBase implements IScarRewardedAdListenerWrapper {
+    private boolean _hasEarnedReward;
+
+    public ScarRewardedAdHandler(ScarAdMetadata scarAdMetadata, EventSubject<GMAEvent> eventSubject, GMAEventSender gMAEventSender) {
+        super(scarAdMetadata, eventSubject, gMAEventSender);
+        this._hasEarnedReward = false;
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarRewardedAdListenerWrapper
+    public void onAdFailedToShow(int i, String str) {
+        this._gmaEventSender.send(GMAEvent.REWARDED_SHOW_ERROR, this._scarAdMetadata.getPlacementId(), this._scarAdMetadata.getQueryId(), str, Integer.valueOf(i));
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarRewardedAdListenerWrapper
+    public void onUserEarnedReward() {
+        this._hasEarnedReward = true;
+        this._gmaEventSender.send(GMAEvent.AD_EARNED_REWARD, new Object[0]);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarRewardedAdListenerWrapper
+    public void onAdSkipped() {
+        this._gmaEventSender.send(GMAEvent.AD_SKIPPED, new Object[0]);
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.handlers.ScarAdHandlerBase, com.unity3d.scar.adapter.common.IScarAdListenerWrapper
+    public void onAdClosed() {
+        if (!this._hasEarnedReward) {
+            onAdSkipped();
+        }
+        super.onAdClosed();
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IScarRewardedAdListenerWrapper
+    public void onAdImpression() {
+        this._gmaEventSender.send(GMAEvent.REWARDED_IMPRESSION_RECORDED, new Object[0]);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/handlers/SignalsHandler.java

@@ -0,0 +1,24 @@
+package com.unity3d.services.ads.gmascar.handlers;
+
+import com.unity3d.scar.adapter.common.GMAEvent;
+import com.unity3d.scar.adapter.common.signals.ISignalCollectionListener;
+import com.unity3d.services.ads.gmascar.utils.GMAEventSender;
+
+/* loaded from: classes4.dex */
+public class SignalsHandler implements ISignalCollectionListener {
+    private GMAEventSender _gmaEventSender;
+
+    public SignalsHandler(GMAEventSender gMAEventSender) {
+        this._gmaEventSender = gMAEventSender;
+    }
+
+    @Override // com.unity3d.scar.adapter.common.signals.ISignalCollectionListener
+    public void onSignalsCollected(String str) {
+        this._gmaEventSender.send(GMAEvent.SIGNALS, str);
+    }
+
+    @Override // com.unity3d.scar.adapter.common.signals.ISignalCollectionListener
+    public void onSignalsCollectionFailed(String str) {
+        this._gmaEventSender.send(GMAEvent.SIGNALS_ERROR, str);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/handlers/WebViewErrorHandler.java

@@ -0,0 +1,25 @@
+package com.unity3d.services.ads.gmascar.handlers;
+
+import com.unity3d.scar.adapter.common.IAdsErrorHandler;
+import com.unity3d.scar.adapter.common.WebViewAdsError;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import com.unity3d.services.core.webview.bridge.IEventSender;
+import com.unity3d.services.core.webview.bridge.SharedInstances;
+
+/* loaded from: classes4.dex */
+public class WebViewErrorHandler implements IAdsErrorHandler<WebViewAdsError> {
+    private final IEventSender _eventSender;
+
+    public WebViewErrorHandler() {
+        this(SharedInstances.INSTANCE.getWebViewEventSender());
+    }
+
+    public WebViewErrorHandler(IEventSender iEventSender) {
+        this._eventSender = iEventSender;
+    }
+
+    @Override // com.unity3d.scar.adapter.common.IAdsErrorHandler
+    public void handleError(WebViewAdsError webViewAdsError) {
+        this._eventSender.sendEvent(WebViewEventCategory.valueOf(webViewAdsError.getDomain()), webViewAdsError.getErrorCategory(), webViewAdsError.getErrorArguments());
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/listeners/IBiddingSignalsListener.java

@@ -0,0 +1,10 @@
+package com.unity3d.services.ads.gmascar.listeners;
+
+import com.unity3d.services.ads.gmascar.models.BiddingSignals;
+
+/* loaded from: classes4.dex */
+public interface IBiddingSignalsListener {
+    void onSignalsFailure(String str);
+
+    void onSignalsReady(BiddingSignals biddingSignals);
+}

decompiled/sources/com/unity3d/services/ads/gmascar/listeners/IInitializationStatusListener.java

@@ -0,0 +1,6 @@
+package com.unity3d.services.ads.gmascar.listeners;
+
+/* loaded from: classes4.dex */
+public interface IInitializationStatusListener {
+    void onInitializationComplete(Object obj);
+}

decompiled/sources/com/unity3d/services/ads/gmascar/managers/BiddingBaseManager.java

@@ -0,0 +1,156 @@
+package com.unity3d.services.ads.gmascar.managers;
+
+import com.unity3d.ads.IUnityAdsTokenListener;
+import com.unity3d.services.ads.gmascar.GMA;
+import com.unity3d.services.ads.gmascar.listeners.IBiddingSignalsListener;
+import com.unity3d.services.ads.gmascar.models.BiddingSignals;
+import com.unity3d.services.ads.gmascar.utils.ScarConstants;
+import com.unity3d.services.ads.gmascar.utils.ScarRequestHandler;
+import com.unity3d.services.core.configuration.ConfigurationReader;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.request.metrics.ScarMetric;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes4.dex */
+public abstract class BiddingBaseManager implements IBiddingManager {
+    private final boolean _isAsyncTokenCall;
+    private final boolean _isBannerEnabled;
+    private final ScarRequestHandler _scarRequestHandler;
+    protected final AtomicBoolean isUploadPermitted;
+    private final AtomicReference<BiddingSignals> signals;
+    private final String tokenIdentifier;
+    private final IUnityAdsTokenListener unityAdsTokenListener;
+
+    @Override // com.unity3d.services.ads.gmascar.managers.IBiddingManager
+    public String getTokenIdentifier() {
+        return this.tokenIdentifier;
+    }
+
+    public abstract void start();
+
+    public BiddingBaseManager(boolean z, IUnityAdsTokenListener iUnityAdsTokenListener) {
+        this(z, iUnityAdsTokenListener, new ScarRequestHandler());
+    }
+
+    public BiddingBaseManager(boolean z, IUnityAdsTokenListener iUnityAdsTokenListener, ScarRequestHandler scarRequestHandler) {
+        this.isUploadPermitted = new AtomicBoolean(false);
+        this.signals = new AtomicReference<>();
+        this.tokenIdentifier = UUID.randomUUID().toString();
+        this._isBannerEnabled = z;
+        this.unityAdsTokenListener = iUnityAdsTokenListener;
+        this._isAsyncTokenCall = iUnityAdsTokenListener != null;
+        this._scarRequestHandler = scarRequestHandler;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.managers.IBiddingManager
+    public String getFormattedToken(String str) {
+        if (str == null || str.isEmpty()) {
+            return null;
+        }
+        String tokenIdentifier = getTokenIdentifier();
+        return (tokenIdentifier == null || tokenIdentifier.isEmpty()) ? str : String.format(ScarConstants.TOKEN_WITH_SCAR_FORMAT, tokenIdentifier, str);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$onUnityAdsTokenReady$0(String str) {
+        this.unityAdsTokenListener.onUnityAdsTokenReady(str);
+    }
+
+    @Override // com.unity3d.ads.IUnityAdsTokenListener
+    public final void onUnityAdsTokenReady(final String str) {
+        if (this.unityAdsTokenListener != null) {
+            Utilities.wrapCustomerListener(new Runnable() { // from class: com.unity3d.services.ads.gmascar.managers.BiddingBaseManager$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    BiddingBaseManager.this.lambda$onUnityAdsTokenReady$0(str);
+                }
+            });
+        }
+    }
+
+    public void permitUpload() {
+        this.isUploadPermitted.set(true);
+    }
+
+    public void permitSignalsUpload() {
+        this.isUploadPermitted.set(true);
+        attemptUpload();
+    }
+
+    public void fetchSignals() {
+        getMetricSender().sendMetric(ScarMetric.hbSignalsFetchStart(this._isAsyncTokenCall));
+        new Thread(new Runnable() { // from class: com.unity3d.services.ads.gmascar.managers.BiddingBaseManager$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                BiddingBaseManager.this.lambda$fetchSignals$1();
+            }
+        }).start();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$fetchSignals$1() {
+        GMA.getInstance().getSCARBiddingSignals(this._isBannerEnabled, new IBiddingSignalsListener() { // from class: com.unity3d.services.ads.gmascar.managers.BiddingBaseManager.1
+            @Override // com.unity3d.services.ads.gmascar.listeners.IBiddingSignalsListener
+            public void onSignalsReady(BiddingSignals biddingSignals) {
+                BiddingBaseManager.this.onSignalsReady(biddingSignals);
+                BiddingBaseManager.this.sendFetchResult("");
+            }
+
+            @Override // com.unity3d.services.ads.gmascar.listeners.IBiddingSignalsListener
+            public void onSignalsFailure(String str) {
+                BiddingBaseManager.this.sendFetchResult(str);
+            }
+        });
+    }
+
+    public void sendFetchResult(String str) {
+        if (str != "") {
+            getMetricSender().sendMetric(ScarMetric.hbSignalsFetchFailure(this._isAsyncTokenCall, str));
+        } else {
+            getMetricSender().sendMetric(ScarMetric.hbSignalsFetchSuccess(this._isAsyncTokenCall));
+        }
+    }
+
+    public void onSignalsReady(BiddingSignals biddingSignals) {
+        this.signals.set(biddingSignals);
+        attemptUpload();
+    }
+
+    private synchronized void attemptUpload() {
+        if (this.signals.get() != null && this.isUploadPermitted.compareAndSet(true, false)) {
+            uploadSignals();
+        }
+    }
+
+    public void uploadSignals() {
+        getMetricSender().sendMetric(ScarMetric.hbSignalsUploadStart(this._isAsyncTokenCall));
+        final BiddingSignals biddingSignals = this.signals.get();
+        if (biddingSignals == null || biddingSignals.isEmpty()) {
+            getMetricSender().sendMetric(ScarMetric.hbSignalsUploadFailure(this._isAsyncTokenCall, "null or empty signals"));
+        } else {
+            new Thread(new Runnable() { // from class: com.unity3d.services.ads.gmascar.managers.BiddingBaseManager$$ExternalSyntheticLambda2
+                @Override // java.lang.Runnable
+                public final void run() {
+                    BiddingBaseManager.this.lambda$uploadSignals$2(biddingSignals);
+                }
+            }).start();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$uploadSignals$2(BiddingSignals biddingSignals) {
+        try {
+            this._scarRequestHandler.makeUploadRequest(this.tokenIdentifier, biddingSignals, new ConfigurationReader().getCurrentConfiguration().getScarBiddingUrl());
+            getMetricSender().sendMetric(ScarMetric.hbSignalsUploadSuccess(this._isAsyncTokenCall));
+        } catch (Exception e) {
+            getMetricSender().sendMetric(ScarMetric.hbSignalsUploadFailure(this._isAsyncTokenCall, e.getLocalizedMessage()));
+        }
+    }
+
+    public SDKMetricsSender getMetricSender() {
+        return (SDKMetricsSender) Utilities.getService(SDKMetricsSender.class);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/managers/BiddingDisabledManager.java

@@ -0,0 +1,19 @@
+package com.unity3d.services.ads.gmascar.managers;
+
+import com.unity3d.ads.IUnityAdsTokenListener;
+
+/* loaded from: classes4.dex */
+public class BiddingDisabledManager extends BiddingBaseManager {
+    @Override // com.unity3d.services.ads.gmascar.managers.BiddingBaseManager, com.unity3d.services.ads.gmascar.managers.IBiddingManager
+    public String getTokenIdentifier() {
+        return null;
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.managers.BiddingBaseManager
+    public void start() {
+    }
+
+    public BiddingDisabledManager(IUnityAdsTokenListener iUnityAdsTokenListener) {
+        super(false, iUnityAdsTokenListener);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/managers/BiddingEagerManager.java

@@ -0,0 +1,16 @@
+package com.unity3d.services.ads.gmascar.managers;
+
+import com.unity3d.ads.IUnityAdsTokenListener;
+
+/* loaded from: classes4.dex */
+public class BiddingEagerManager extends BiddingBaseManager {
+    public BiddingEagerManager(boolean z, IUnityAdsTokenListener iUnityAdsTokenListener) {
+        super(z, iUnityAdsTokenListener);
+    }
+
+    @Override // com.unity3d.services.ads.gmascar.managers.BiddingBaseManager
+    public void start() {
+        permitSignalsUpload();
+        fetchSignals();
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/managers/BiddingManagerFactory.java

@@ -0,0 +1,55 @@
+package com.unity3d.services.ads.gmascar.managers;
+
+import com.unity3d.ads.IUnityAdsTokenListener;
+import com.unity3d.services.ads.gmascar.GMA;
+import com.unity3d.services.core.configuration.IExperiments;
+
+/* loaded from: classes4.dex */
+public class BiddingManagerFactory {
+    private static BiddingManagerFactory instance;
+
+    private BiddingManagerFactory() {
+    }
+
+    public static BiddingManagerFactory getInstance() {
+        if (instance == null) {
+            instance = new BiddingManagerFactory();
+        }
+        return instance;
+    }
+
+    public BiddingBaseManager createManager(IUnityAdsTokenListener iUnityAdsTokenListener, IExperiments iExperiments) {
+        if (GMA.getInstance().hasSCARBiddingSupport()) {
+            return getExperiment(iUnityAdsTokenListener, iExperiments);
+        }
+        return new BiddingDisabledManager(iUnityAdsTokenListener);
+    }
+
+    private BiddingBaseManager getExperiment(IUnityAdsTokenListener iUnityAdsTokenListener, IExperiments iExperiments) {
+        if (iExperiments == null || iExperiments.getScarBiddingManager() == null) {
+            return new BiddingDisabledManager(iUnityAdsTokenListener);
+        }
+        if (AnonymousClass1.$SwitchMap$com$unity3d$services$ads$gmascar$managers$ScarBiddingManagerType[ScarBiddingManagerType.fromName(iExperiments.getScarBiddingManager()).ordinal()] == 1) {
+            return new BiddingEagerManager(iExperiments.isScarBannerHbEnabled(), iUnityAdsTokenListener);
+        }
+        return new BiddingDisabledManager(iUnityAdsTokenListener);
+    }
+
+    /* renamed from: com.unity3d.services.ads.gmascar.managers.BiddingManagerFactory$1, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass1 {
+        static final /* synthetic */ int[] $SwitchMap$com$unity3d$services$ads$gmascar$managers$ScarBiddingManagerType;
+
+        static {
+            int[] iArr = new int[ScarBiddingManagerType.values().length];
+            $SwitchMap$com$unity3d$services$ads$gmascar$managers$ScarBiddingManagerType = iArr;
+            try {
+                iArr[ScarBiddingManagerType.EAGER.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$com$unity3d$services$ads$gmascar$managers$ScarBiddingManagerType[ScarBiddingManagerType.DISABLED.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/managers/IBiddingManager.java

@@ -0,0 +1,10 @@
+package com.unity3d.services.ads.gmascar.managers;
+
+import com.unity3d.ads.IUnityAdsTokenListener;
+
+/* loaded from: classes4.dex */
+public interface IBiddingManager extends IUnityAdsTokenListener {
+    String getFormattedToken(String str);
+
+    String getTokenIdentifier();
+}

decompiled/sources/com/unity3d/services/ads/gmascar/managers/ScarBiddingManagerType.java

@@ -0,0 +1,30 @@
+package com.unity3d.services.ads.gmascar.managers;
+
+/* loaded from: classes4.dex */
+public enum ScarBiddingManagerType {
+    DISABLED("dis"),
+    EAGER("eag");
+
+    private final String name;
+
+    public String getName() {
+        return this.name;
+    }
+
+    ScarBiddingManagerType(String str) {
+        this.name = str;
+    }
+
+    public static ScarBiddingManagerType fromName(String str) {
+        int hashCode = str.hashCode();
+        return (hashCode != 99470 && hashCode == 100171 && str.equals("eag")) ? EAGER : DISABLED;
+    }
+
+    public static class Constants {
+        private static final String DIS = "dis";
+        private static final String EAG = "eag";
+
+        private Constants() {
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/models/BiddingSignals.java

@@ -0,0 +1,55 @@
+package com.unity3d.services.ads.gmascar.models;
+
+import android.text.TextUtils;
+import com.unity3d.services.ads.gmascar.utils.ScarConstants;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class BiddingSignals {
+    private final String bannerSignal;
+    private final String interstitialSignal;
+    private final String rvSignal;
+
+    public String getBannerSignal() {
+        return this.bannerSignal;
+    }
+
+    public String getInterstitialSignal() {
+        return this.interstitialSignal;
+    }
+
+    public String getRvSignal() {
+        return this.rvSignal;
+    }
+
+    public BiddingSignals(String str, String str2, String str3) {
+        this.rvSignal = str;
+        this.interstitialSignal = str2;
+        this.bannerSignal = str3;
+    }
+
+    public BiddingSignals(String str, String str2) {
+        this.rvSignal = str;
+        this.interstitialSignal = str2;
+        this.bannerSignal = "";
+    }
+
+    public boolean isEmpty() {
+        return TextUtils.isEmpty(getRvSignal()) && TextUtils.isEmpty(getInterstitialSignal()) && TextUtils.isEmpty(getBannerSignal());
+    }
+
+    public Map<String, String> getMap() {
+        HashMap hashMap = new HashMap();
+        if (!TextUtils.isEmpty(getRvSignal())) {
+            hashMap.put("rv", getRvSignal());
+        }
+        if (!TextUtils.isEmpty(getInterstitialSignal())) {
+            hashMap.put(ScarConstants.IN_SIGNAL_KEY, getInterstitialSignal());
+        }
+        if (!TextUtils.isEmpty(getBannerSignal())) {
+            hashMap.put(ScarConstants.BN_SIGNAL_KEY, getBannerSignal());
+        }
+        return hashMap;
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/utils/GMAEventSender.java

@@ -0,0 +1,27 @@
+package com.unity3d.services.ads.gmascar.utils;
+
+import com.unity3d.scar.adapter.common.GMAEvent;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import com.unity3d.services.core.webview.bridge.IEventSender;
+import com.unity3d.services.core.webview.bridge.SharedInstances;
+
+/* loaded from: classes4.dex */
+public class GMAEventSender {
+    private final IEventSender _eventSender;
+
+    public GMAEventSender() {
+        this(SharedInstances.INSTANCE.getWebViewEventSender());
+    }
+
+    public GMAEventSender(IEventSender iEventSender) {
+        this._eventSender = iEventSender;
+    }
+
+    public void send(GMAEvent gMAEvent, Object... objArr) {
+        this._eventSender.sendEvent(WebViewEventCategory.GMA, gMAEvent, objArr);
+    }
+
+    public void sendVersion(String str) {
+        this._eventSender.sendEvent(WebViewEventCategory.INIT_GMA, GMAEvent.VERSION, str);
+    }
+}

decompiled/sources/com/unity3d/services/ads/gmascar/utils/ScarConstants.java

@@ -0,0 +1,13 @@
+package com.unity3d.services.ads.gmascar.utils;
+
+/* loaded from: classes4.dex */
+public class ScarConstants {
+    public static final String BN_SIGNAL_KEY = "bn";
+    public static final String IDFI_KEY = "idfi";
+    public static final String IN_SIGNAL_KEY = "in";
+    public static final String RV_SIGNAL_KEY = "rv";
+    public static final String SCAR_PRD_BIDDING_ENDPOINT = "https://scar.unityads.unity3d.com/v1/capture-scar-signals";
+    public static final String SCAR_TOKEN_IDENTIFIER_KEY = "scarId";
+    public static final String TOKEN_ID_KEY = "tid";
+    public static final String TOKEN_WITH_SCAR_FORMAT = "%s:%s";
+}

decompiled/sources/com/unity3d/services/ads/gmascar/utils/ScarRequestHandler.java

@@ -0,0 +1,28 @@
+package com.unity3d.services.ads.gmascar.utils;
+
+import com.ironsource.nb;
+import com.unity3d.services.ads.gmascar.models.BiddingSignals;
+import com.unity3d.services.core.device.Device;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.network.core.HttpClient;
+import com.unity3d.services.core.network.model.HttpRequest;
+import com.unity3d.services.core.network.model.RequestType;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class ScarRequestHandler {
+    private final HttpClient httpClient = (HttpClient) Utilities.getService(HttpClient.class);
+
+    public void makeUploadRequest(String str, BiddingSignals biddingSignals, String str2) throws Exception {
+        HashMap hashMap = new HashMap();
+        hashMap.put("Content-Type", Collections.singletonList(nb.L));
+        HashMap hashMap2 = new HashMap();
+        hashMap2.put(ScarConstants.IDFI_KEY, Device.getIdfi());
+        hashMap2.put(ScarConstants.TOKEN_ID_KEY, str);
+        hashMap2.putAll(biddingSignals.getMap());
+        this.httpClient.executeBlocking(new HttpRequest(str2, "", RequestType.POST, new JSONObject(hashMap2).toString().getBytes(StandardCharsets.UTF_8), hashMap));
+    }
+}

decompiled/sources/com/unity3d/services/ads/measurements/MeasurementsErrors.java

@@ -0,0 +1,13 @@
+package com.unity3d.services.ads.measurements;
+
+/* loaded from: classes4.dex */
+public enum MeasurementsErrors {
+    ERROR_AD_SERVICES_DISABLED,
+    ERROR_EXTENSION_BELOW_4,
+    ERROR_API_BELOW_33,
+    ERROR_MANAGER_NULL,
+    ERROR_EXCEPTION,
+    ERROR_AD_UNIT_NULL,
+    ERROR_LAYOUT_NULL,
+    ERROR_LAST_INPUT_EVENT_NULL
+}

decompiled/sources/com/unity3d/services/ads/measurements/MeasurementsEvents.java

@@ -0,0 +1,11 @@
+package com.unity3d.services.ads.measurements;
+
+/* loaded from: classes4.dex */
+public enum MeasurementsEvents {
+    NOT_AVAILABLE,
+    AVAILABLE,
+    VIEW_SUCCESSFUL,
+    VIEW_ERROR,
+    CLICK_SUCCESSFUL,
+    CLICK_ERROR
+}

decompiled/sources/com/unity3d/services/ads/measurements/MeasurementsReceiver.java

@@ -0,0 +1,34 @@
+package com.unity3d.services.ads.measurements;
+
+import android.annotation.SuppressLint;
+import android.os.OutcomeReceiver;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import com.unity3d.services.core.webview.bridge.IEventSender;
+import kotlin.jvm.internal.Intrinsics;
+
+@SuppressLint({"NewApi", "MissingPermission"})
+/* loaded from: classes4.dex */
+public final class MeasurementsReceiver implements OutcomeReceiver {
+    private final MeasurementsEvents errorEvent;
+    private final IEventSender eventSender;
+    private final MeasurementsEvents successEvent;
+
+    public MeasurementsReceiver(IEventSender eventSender, MeasurementsEvents successEvent, MeasurementsEvents errorEvent) {
+        Intrinsics.checkNotNullParameter(eventSender, "eventSender");
+        Intrinsics.checkNotNullParameter(successEvent, "successEvent");
+        Intrinsics.checkNotNullParameter(errorEvent, "errorEvent");
+        this.eventSender = eventSender;
+        this.successEvent = successEvent;
+        this.errorEvent = errorEvent;
+    }
+
+    public void onResult(Object p0) {
+        Intrinsics.checkNotNullParameter(p0, "p0");
+        this.eventSender.sendEvent(WebViewEventCategory.MEASUREMENTS, this.successEvent, new Object[0]);
+    }
+
+    public void onError(Exception error) {
+        Intrinsics.checkNotNullParameter(error, "error");
+        this.eventSender.sendEvent(WebViewEventCategory.MEASUREMENTS, this.errorEvent, error.toString());
+    }
+}

decompiled/sources/com/unity3d/services/ads/measurements/MeasurementsService.java

@@ -0,0 +1,88 @@
+package com.unity3d.services.ads.measurements;
+
+import android.adservices.AdServicesState;
+import android.adservices.measurement.MeasurementManager;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.net.Uri;
+import android.os.ext.SdkExtensions;
+import android.view.InputEvent;
+import androidx.core.os.OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0;
+import androidx.privacysandbox.ads.adservices.measurement.MeasurementManager$Api33Ext5Impl$$ExternalSyntheticApiModelOutline23;
+import androidx.privacysandbox.ads.adservices.measurement.MeasurementManager$Api33Ext5Impl$$ExternalSyntheticApiModelOutline24;
+import com.unity3d.services.core.device.Device;
+import com.unity3d.services.core.domain.ISDKDispatchers;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import com.unity3d.services.core.webview.bridge.IEventSender;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.ExecutorsKt;
+
+@SuppressLint({"NewApi", "MissingPermission"})
+/* loaded from: classes4.dex */
+public final class MeasurementsService {
+    private final ISDKDispatchers dispatchers;
+    private final IEventSender eventSender;
+    private final MeasurementManager measurementManager;
+
+    public MeasurementsService(Context context, ISDKDispatchers dispatchers, IEventSender eventSender) {
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(dispatchers, "dispatchers");
+        Intrinsics.checkNotNullParameter(eventSender, "eventSender");
+        this.dispatchers = dispatchers;
+        this.eventSender = eventSender;
+        this.measurementManager = getMeasurementManager(context);
+    }
+
+    public final void checkAvailability() {
+        int extensionVersion;
+        boolean isAdServicesStateEnabled;
+        if (Device.getApiLevel() < 33) {
+            this.eventSender.sendEvent(WebViewEventCategory.MEASUREMENTS, MeasurementsEvents.NOT_AVAILABLE, MeasurementsErrors.ERROR_API_BELOW_33);
+            return;
+        }
+        extensionVersion = SdkExtensions.getExtensionVersion(1000000);
+        if (extensionVersion < 4) {
+            this.eventSender.sendEvent(WebViewEventCategory.MEASUREMENTS, MeasurementsEvents.NOT_AVAILABLE, MeasurementsErrors.ERROR_EXTENSION_BELOW_4);
+            return;
+        }
+        if (this.measurementManager == null) {
+            this.eventSender.sendEvent(WebViewEventCategory.MEASUREMENTS, MeasurementsEvents.NOT_AVAILABLE, MeasurementsErrors.ERROR_MANAGER_NULL);
+            return;
+        }
+        isAdServicesStateEnabled = AdServicesState.isAdServicesStateEnabled();
+        if (!isAdServicesStateEnabled) {
+            this.eventSender.sendEvent(WebViewEventCategory.MEASUREMENTS, MeasurementsEvents.NOT_AVAILABLE, MeasurementsErrors.ERROR_AD_SERVICES_DISABLED);
+        } else {
+            this.measurementManager.getMeasurementApiStatus(ExecutorsKt.asExecutor(this.dispatchers.getDefault()), OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(new MeasurementsStatusReceiver(this.eventSender)));
+        }
+    }
+
+    public final void registerView(String url) {
+        Intrinsics.checkNotNullParameter(url, "url");
+        MeasurementManager measurementManager = this.measurementManager;
+        if (measurementManager != null) {
+            measurementManager.registerSource(Uri.parse(url), null, ExecutorsKt.asExecutor(this.dispatchers.getDefault()), OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(new MeasurementsReceiver(this.eventSender, MeasurementsEvents.VIEW_SUCCESSFUL, MeasurementsEvents.VIEW_ERROR)));
+        }
+    }
+
+    public final void registerClick(String url, InputEvent inputEvent) {
+        Intrinsics.checkNotNullParameter(url, "url");
+        Intrinsics.checkNotNullParameter(inputEvent, "inputEvent");
+        MeasurementManager measurementManager = this.measurementManager;
+        if (measurementManager != null) {
+            measurementManager.registerSource(Uri.parse(url), inputEvent, ExecutorsKt.asExecutor(this.dispatchers.getDefault()), OutcomeReceiverKt$$ExternalSyntheticApiModelOutline0.m(new MeasurementsReceiver(this.eventSender, MeasurementsEvents.CLICK_SUCCESSFUL, MeasurementsEvents.CLICK_ERROR)));
+        }
+    }
+
+    private final MeasurementManager getMeasurementManager(Context context) {
+        int extensionVersion;
+        if (Device.getApiLevel() < 33) {
+            return null;
+        }
+        extensionVersion = SdkExtensions.getExtensionVersion(1000000);
+        if (extensionVersion < 4) {
+            return null;
+        }
+        return MeasurementManager$Api33Ext5Impl$$ExternalSyntheticApiModelOutline24.m(context.getSystemService(MeasurementManager$Api33Ext5Impl$$ExternalSyntheticApiModelOutline23.m()));
+    }
+}

decompiled/sources/com/unity3d/services/ads/measurements/MeasurementsStatusReceiver.java

@@ -0,0 +1,31 @@
+package com.unity3d.services.ads.measurements;
+
+import android.annotation.SuppressLint;
+import android.os.OutcomeReceiver;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import com.unity3d.services.core.webview.bridge.IEventSender;
+import kotlin.jvm.internal.Intrinsics;
+
+@SuppressLint({"NewApi", "MissingPermission"})
+/* loaded from: classes4.dex */
+public final class MeasurementsStatusReceiver implements OutcomeReceiver {
+    private final IEventSender eventSender;
+
+    public MeasurementsStatusReceiver(IEventSender eventSender) {
+        Intrinsics.checkNotNullParameter(eventSender, "eventSender");
+        this.eventSender = eventSender;
+    }
+
+    public /* bridge */ /* synthetic */ void onResult(Object obj) {
+        onResult(((Number) obj).intValue());
+    }
+
+    public void onResult(int i) {
+        this.eventSender.sendEvent(WebViewEventCategory.MEASUREMENTS, MeasurementsEvents.AVAILABLE, Integer.valueOf(i));
+    }
+
+    public void onError(Exception error) {
+        Intrinsics.checkNotNullParameter(error, "error");
+        this.eventSender.sendEvent(WebViewEventCategory.MEASUREMENTS, MeasurementsEvents.NOT_AVAILABLE, MeasurementsErrors.ERROR_EXCEPTION, error.toString());
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/AdModule.java

@@ -0,0 +1,22 @@
+package com.unity3d.services.ads.operation;
+
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.webview.bridge.IWebViewSharedObject;
+import com.unity3d.services.core.webview.bridge.WebViewBridgeSharedObjectStore;
+import com.unity3d.services.core.webview.bridge.invocation.WebViewBridgeInvocationSingleThreadedExecutor;
+import java.util.concurrent.ExecutorService;
+
+/* loaded from: classes4.dex */
+public abstract class AdModule<T extends IWebViewSharedObject, T2> extends WebViewBridgeSharedObjectStore<T> implements IAdModule<T, T2> {
+    protected ExecutorService _executorService = WebViewBridgeInvocationSingleThreadedExecutor.getInstance().getExecutorService();
+    protected SDKMetricsSender _sdkMetrics;
+
+    @Override // com.unity3d.services.ads.operation.IAdModule
+    public SDKMetricsSender getMetricSender() {
+        return this._sdkMetrics;
+    }
+
+    public AdModule(SDKMetricsSender sDKMetricsSender) {
+        this._sdkMetrics = sDKMetricsSender;
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/AdOperation.java

@@ -0,0 +1,26 @@
+package com.unity3d.services.ads.operation;
+
+import com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocation;
+
+/* loaded from: classes4.dex */
+public abstract class AdOperation implements IAdOperation {
+    private static String invocationClassName = "webview";
+    private String _invocationMethodName;
+    private IWebViewBridgeInvocation _webViewBridgeInvocation;
+
+    public AdOperation(IWebViewBridgeInvocation iWebViewBridgeInvocation, String str) throws NullPointerException {
+        this._invocationMethodName = str;
+        if (str == null || str.isEmpty()) {
+            throw new IllegalArgumentException("invocationMethodName cannot be null");
+        }
+        this._webViewBridgeInvocation = iWebViewBridgeInvocation;
+        if (iWebViewBridgeInvocation == null) {
+            throw new IllegalArgumentException("webViewBridgeInvocation cannot be null");
+        }
+    }
+
+    @Override // com.unity3d.services.ads.operation.IAdOperation
+    public void invoke(int i, Object... objArr) {
+        this._webViewBridgeInvocation.invoke(invocationClassName, this._invocationMethodName, i, objArr);
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/IAdModule.java

@@ -0,0 +1,13 @@
+package com.unity3d.services.ads.operation;
+
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeInvoker;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeSharedObjectStore;
+import com.unity3d.services.core.webview.bridge.IWebViewSharedObject;
+
+/* loaded from: classes4.dex */
+public interface IAdModule<T extends IWebViewSharedObject, T2> extends IWebViewBridgeSharedObjectStore<T> {
+    void executeAdOperation(IWebViewBridgeInvoker iWebViewBridgeInvoker, T2 t2);
+
+    SDKMetricsSender getMetricSender();
+}

decompiled/sources/com/unity3d/services/ads/operation/IAdOperation.java

@@ -0,0 +1,8 @@
+package com.unity3d.services.ads.operation;
+
+import com.unity3d.services.core.webview.bridge.IWebViewSharedObject;
+
+/* loaded from: classes4.dex */
+public interface IAdOperation extends IWebViewSharedObject {
+    void invoke(int i, Object... objArr);
+}

decompiled/sources/com/unity3d/services/ads/operation/OperationState.java

@@ -0,0 +1,36 @@
+package com.unity3d.services.ads.operation;
+
+import com.unity3d.services.core.configuration.Configuration;
+import com.unity3d.services.core.timer.BaseTimer;
+import com.unity3d.services.core.webview.bridge.IWebViewSharedObject;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes4.dex */
+public class OperationState implements IWebViewSharedObject {
+    private static String _emptyPlacementId = "";
+    public Configuration configuration;
+    public String id;
+    public String placementId;
+    public long startTime;
+    public BaseTimer timeoutTimer;
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewSharedObject
+    public String getId() {
+        return this.id;
+    }
+
+    public OperationState(String str, Configuration configuration) {
+        this.placementId = str == null ? _emptyPlacementId : str;
+        this.configuration = configuration;
+        this.id = UUID.randomUUID().toString();
+    }
+
+    public void start() {
+        this.startTime = System.nanoTime();
+    }
+
+    public long duration() {
+        return TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - this.startTime);
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/BaseLoadModule.java

@@ -0,0 +1,124 @@
+package com.unity3d.services.ads.operation.load;
+
+import android.text.TextUtils;
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import com.ironsource.v8;
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.ads.operation.AdModule;
+import com.unity3d.services.core.device.Device;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.request.metrics.AdOperationError;
+import com.unity3d.services.core.request.metrics.AdOperationMetric;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.webview.bridge.CallbackStatus;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeInvoker;
+import com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocationCallback;
+import com.unity3d.services.core.webview.bridge.invocation.WebViewBridgeInvocation;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public abstract class BaseLoadModule extends AdModule<ILoadOperation, LoadOperationState> implements ILoadModule {
+    static final String errorMsgFailedToCreateLoadRequest = "[UnityAds] Failed to create load request";
+    static final String errorMsgInternalCommunicationFailure = "[UnityAds] Internal communication failure";
+    static final String errorMsgInternalCommunicationTimeout = "[UnityAds] Internal communication timeout";
+    static final String errorMsgPlacementIdNull = "[UnityAds] Placement ID cannot be null";
+
+    public abstract void addOptionalParameters(LoadOperationState loadOperationState, JSONObject jSONObject) throws JSONException;
+
+    public BaseLoadModule(SDKMetricsSender sDKMetricsSender) {
+        super(sDKMetricsSender);
+    }
+
+    @Override // com.unity3d.services.ads.operation.IAdModule
+    public void executeAdOperation(IWebViewBridgeInvoker iWebViewBridgeInvoker, final LoadOperationState loadOperationState) {
+        if (TextUtils.isEmpty(loadOperationState.placementId)) {
+            sendOnUnityAdsFailedToLoad(loadOperationState, UnityAds.UnityAdsLoadError.INVALID_ARGUMENT, "[UnityAds] Placement ID cannot be null", true);
+            return;
+        }
+        LoadOperation loadOperation = new LoadOperation(loadOperationState, new WebViewBridgeInvocation(this._executorService, iWebViewBridgeInvoker, new IWebViewBridgeInvocationCallback() { // from class: com.unity3d.services.ads.operation.load.BaseLoadModule.1
+            @Override // com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocationCallback
+            public void onSuccess() {
+            }
+
+            @Override // com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocationCallback
+            public void onFailure(String str, CallbackStatus callbackStatus) {
+                BaseLoadModule.this.getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdLoadFailure(AdOperationError.callback_error, Long.valueOf(loadOperationState.duration()), loadOperationState.isBanner(), loadOperationState.isHeaderBidding()));
+                BaseLoadModule.this.sendOnUnityAdsFailedToLoad(loadOperationState, UnityAds.UnityAdsLoadError.INTERNAL_ERROR, "[UnityAds] Internal communication failure", false);
+                BaseLoadModule.this.remove(loadOperationState.getId());
+            }
+
+            @Override // com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocationCallback
+            public void onTimeout() {
+                BaseLoadModule.this.getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdLoadFailure(AdOperationError.callback_timeout, Long.valueOf(loadOperationState.duration()), loadOperationState.isBanner(), loadOperationState.isHeaderBidding()));
+                BaseLoadModule.this.sendOnUnityAdsFailedToLoad(loadOperationState, UnityAds.UnityAdsLoadError.INTERNAL_ERROR, "[UnityAds] Internal communication timeout", false);
+                BaseLoadModule.this.remove(loadOperationState.getId());
+            }
+        }));
+        try {
+            JSONObject buildBaseParameters = buildBaseParameters(loadOperationState, loadOperation);
+            set(loadOperation);
+            loadOperation.invoke(loadOperationState.configuration.getWebViewBridgeTimeout(), buildBaseParameters);
+        } catch (NullPointerException | JSONException unused) {
+            sendOnUnityAdsFailedToLoad(loadOperationState, UnityAds.UnityAdsLoadError.INTERNAL_ERROR, "[UnityAds] Failed to create load request", true);
+        }
+    }
+
+    public JSONObject buildBaseParameters(LoadOperationState loadOperationState, LoadOperation loadOperation) throws JSONException {
+        JSONObject jSONObject = new JSONObject();
+        JSONObject buildBaseOptions = buildBaseOptions(loadOperationState);
+        buildBaseOptions.put("headerBiddingOptions", loadOperationState.loadOptions.getData());
+        jSONObject.put(SDKConstants.PARAM_GAME_REQUESTS_OPTIONS, buildBaseOptions);
+        jSONObject.put("listenerId", loadOperation.getId());
+        jSONObject.put(v8.j, loadOperationState.placementId);
+        jSONObject.put("time", Device.getElapsedRealtime());
+        addOptionalParameters(loadOperationState, jSONObject);
+        return jSONObject;
+    }
+
+    public JSONObject buildBaseOptions(LoadOperationState loadOperationState) throws JSONException {
+        JSONObject jSONObject = new JSONObject();
+        jSONObject.put("headerBiddingOptions", loadOperationState.loadOptions.getData());
+        return jSONObject;
+    }
+
+    @Override // com.unity3d.services.ads.operation.load.ILoadModule
+    public void onUnityAdsAdLoaded(String str) {
+        ILoadOperation iLoadOperation = (ILoadOperation) get(str);
+        if (iLoadOperation == null || iLoadOperation.getLoadOperationState() == null) {
+            return;
+        }
+        LoadOperationState loadOperationState = iLoadOperation.getLoadOperationState();
+        getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdLoadSuccess(Long.valueOf(loadOperationState.duration()), loadOperationState.isBanner(), loadOperationState.isHeaderBidding()));
+        iLoadOperation.onUnityAdsAdLoaded(loadOperationState.placementId);
+        remove(str);
+    }
+
+    @Override // com.unity3d.services.ads.operation.load.ILoadModule
+    public void onUnityAdsFailedToLoad(String str, UnityAds.UnityAdsLoadError unityAdsLoadError, String str2) {
+        ILoadOperation iLoadOperation = (ILoadOperation) get(str);
+        if (iLoadOperation == null || iLoadOperation.getLoadOperationState() == null) {
+            return;
+        }
+        LoadOperationState loadOperationState = iLoadOperation.getLoadOperationState();
+        getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdLoadFailure(unityAdsLoadError, Long.valueOf(loadOperationState.duration()), loadOperationState.isBanner(), loadOperationState.isHeaderBidding()));
+        iLoadOperation.onUnityAdsFailedToLoad(loadOperationState.placementId, unityAdsLoadError, str2);
+        remove(str);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void sendOnUnityAdsFailedToLoad(final LoadOperationState loadOperationState, final UnityAds.UnityAdsLoadError unityAdsLoadError, final String str, boolean z) {
+        if (loadOperationState == null || loadOperationState.listener == null) {
+            return;
+        }
+        if (z) {
+            getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdLoadFailure(unityAdsLoadError, Long.valueOf(loadOperationState.duration()), loadOperationState.isBanner(), loadOperationState.isHeaderBidding()));
+        }
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.load.BaseLoadModule.2
+            @Override // java.lang.Runnable
+            public void run() {
+                loadOperationState.onUnityAdsFailedToLoad(unityAdsLoadError, str);
+            }
+        });
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/ILoadModule.java

@@ -0,0 +1,11 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.ads.operation.IAdModule;
+
+/* loaded from: classes4.dex */
+public interface ILoadModule extends IAdModule<ILoadOperation, LoadOperationState> {
+    void onUnityAdsAdLoaded(String str);
+
+    void onUnityAdsFailedToLoad(String str, UnityAds.UnityAdsLoadError unityAdsLoadError, String str2);
+}

decompiled/sources/com/unity3d/services/ads/operation/load/ILoadOperation.java

@@ -0,0 +1,9 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.ads.IUnityAdsLoadListener;
+import com.unity3d.services.ads.operation.IAdOperation;
+
+/* loaded from: classes4.dex */
+public interface ILoadOperation extends IAdOperation, IUnityAdsLoadListener {
+    LoadOperationState getLoadOperationState();
+}

decompiled/sources/com/unity3d/services/ads/operation/load/LoadBannerModule.java

@@ -0,0 +1,33 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.services.core.configuration.ExperimentsReader;
+import com.unity3d.services.core.configuration.InitializationNotificationCenter;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class LoadBannerModule extends BaseLoadModule {
+    static ILoadModule _instance;
+
+    public static ILoadModule getInstance() {
+        if (_instance == null) {
+            _instance = new LoadModuleDecoratorTimeout(new LoadModuleDecoratorInitializationBuffer(new LoadBannerModule((SDKMetricsSender) Utilities.getService(SDKMetricsSender.class)), InitializationNotificationCenter.getInstance()), new ExperimentsReader());
+        }
+        return _instance;
+    }
+
+    public LoadBannerModule(SDKMetricsSender sDKMetricsSender) {
+        super(sDKMetricsSender);
+    }
+
+    @Override // com.unity3d.services.ads.operation.load.BaseLoadModule
+    public void addOptionalParameters(LoadOperationState loadOperationState, JSONObject jSONObject) throws JSONException {
+        if (loadOperationState instanceof LoadBannerOperationState) {
+            LoadBannerOperationState loadBannerOperationState = (LoadBannerOperationState) loadOperationState;
+            jSONObject.put("width", loadBannerOperationState.getSize().getWidth());
+            jSONObject.put("height", loadBannerOperationState.getSize().getHeight());
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/LoadBannerOperationState.java

@@ -0,0 +1,39 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.ads.IUnityAdsLoadListener;
+import com.unity3d.ads.UnityAdsLoadOptions;
+import com.unity3d.scar.adapter.common.scarads.ScarAdMetadata;
+import com.unity3d.services.banners.UnityBannerSize;
+import com.unity3d.services.core.configuration.Configuration;
+
+/* loaded from: classes4.dex */
+public class LoadBannerOperationState extends LoadOperationState {
+    private ScarAdMetadata _scarAdMetadata;
+    private UnityBannerSize _size;
+
+    public ScarAdMetadata getScarAdMetadata() {
+        return this._scarAdMetadata;
+    }
+
+    public UnityBannerSize getSize() {
+        return this._size;
+    }
+
+    public boolean isScarAd() {
+        return this._scarAdMetadata != null;
+    }
+
+    public void setScarAdMetadata(ScarAdMetadata scarAdMetadata) {
+        this._scarAdMetadata = scarAdMetadata;
+    }
+
+    public void setSize(UnityBannerSize unityBannerSize) {
+        this._size = unityBannerSize;
+    }
+
+    public LoadBannerOperationState(String str, String str2, UnityBannerSize unityBannerSize, IUnityAdsLoadListener iUnityAdsLoadListener, UnityAdsLoadOptions unityAdsLoadOptions, Configuration configuration) {
+        super(str, iUnityAdsLoadListener, unityAdsLoadOptions, configuration);
+        this.id = str2;
+        this._size = unityBannerSize;
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/LoadModule.java

@@ -0,0 +1,27 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.services.core.configuration.ExperimentsReader;
+import com.unity3d.services.core.configuration.InitializationNotificationCenter;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class LoadModule extends BaseLoadModule {
+    static ILoadModule _instance;
+
+    @Override // com.unity3d.services.ads.operation.load.BaseLoadModule
+    public void addOptionalParameters(LoadOperationState loadOperationState, JSONObject jSONObject) {
+    }
+
+    public static ILoadModule getInstance() {
+        if (_instance == null) {
+            _instance = new LoadModuleDecoratorTimeout(new LoadModuleDecoratorInitializationBuffer(new LoadModule((SDKMetricsSender) Utilities.getService(SDKMetricsSender.class)), InitializationNotificationCenter.getInstance()), new ExperimentsReader());
+        }
+        return _instance;
+    }
+
+    public LoadModule(SDKMetricsSender sDKMetricsSender) {
+        super(sDKMetricsSender);
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/LoadModuleDecorator.java

@@ -0,0 +1,49 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeInvoker;
+
+/* loaded from: classes4.dex */
+public class LoadModuleDecorator implements ILoadModule {
+    private final ILoadModule _loadModule;
+
+    public LoadModuleDecorator(ILoadModule iLoadModule) {
+        this._loadModule = iLoadModule;
+    }
+
+    @Override // com.unity3d.services.ads.operation.IAdModule
+    public void executeAdOperation(IWebViewBridgeInvoker iWebViewBridgeInvoker, LoadOperationState loadOperationState) {
+        this._loadModule.executeAdOperation(iWebViewBridgeInvoker, loadOperationState);
+    }
+
+    @Override // com.unity3d.services.ads.operation.IAdModule
+    public SDKMetricsSender getMetricSender() {
+        return this._loadModule.getMetricSender();
+    }
+
+    @Override // com.unity3d.services.ads.operation.load.ILoadModule
+    public void onUnityAdsAdLoaded(String str) {
+        this._loadModule.onUnityAdsAdLoaded(str);
+    }
+
+    @Override // com.unity3d.services.ads.operation.load.ILoadModule
+    public void onUnityAdsFailedToLoad(String str, UnityAds.UnityAdsLoadError unityAdsLoadError, String str2) {
+        this._loadModule.onUnityAdsFailedToLoad(str, unityAdsLoadError, str2);
+    }
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewBridgeSharedObjectStore
+    public ILoadOperation get(String str) {
+        return (ILoadOperation) this._loadModule.get(str);
+    }
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewBridgeSharedObjectStore
+    public void set(ILoadOperation iLoadOperation) {
+        this._loadModule.set(iLoadOperation);
+    }
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewBridgeSharedObjectStore
+    public void remove(String str) {
+        this._loadModule.remove(str);
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/LoadModuleDecoratorInitializationBuffer.java

@@ -0,0 +1,99 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.core.configuration.ErrorState;
+import com.unity3d.services.core.configuration.IInitializationListener;
+import com.unity3d.services.core.configuration.IInitializationNotificationCenter;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.properties.SdkProperties;
+import com.unity3d.services.core.request.metrics.AdOperationMetric;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeInvoker;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/* loaded from: classes4.dex */
+public class LoadModuleDecoratorInitializationBuffer extends LoadModuleDecorator implements IInitializationListener {
+    private static final String errorMsgInitializationFailed = "[UnityAds] SDK Initialization Failed";
+    private static final String errorMsgInitializationFailure = "[UnityAds] SDK Initialization Failure";
+    private ConcurrentHashMap<LoadOperationState, IWebViewBridgeInvoker> _queuedLoadEvents;
+
+    public LoadModuleDecoratorInitializationBuffer(ILoadModule iLoadModule, IInitializationNotificationCenter iInitializationNotificationCenter) {
+        super(iLoadModule);
+        iInitializationNotificationCenter.addListener(this);
+        this._queuedLoadEvents = new ConcurrentHashMap<>();
+    }
+
+    /* renamed from: com.unity3d.services.ads.operation.load.LoadModuleDecoratorInitializationBuffer$2, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass2 {
+        static final /* synthetic */ int[] $SwitchMap$com$unity3d$services$core$properties$SdkProperties$InitializationState;
+
+        static {
+            int[] iArr = new int[SdkProperties.InitializationState.values().length];
+            $SwitchMap$com$unity3d$services$core$properties$SdkProperties$InitializationState = iArr;
+            try {
+                iArr[SdkProperties.InitializationState.INITIALIZED_SUCCESSFULLY.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$com$unity3d$services$core$properties$SdkProperties$InitializationState[SdkProperties.InitializationState.INITIALIZED_FAILED.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+        }
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.unity3d.services.ads.operation.load.LoadModuleDecorator, com.unity3d.services.ads.operation.IAdModule
+    public void executeAdOperation(IWebViewBridgeInvoker iWebViewBridgeInvoker, LoadOperationState loadOperationState) {
+        if (loadOperationState == null) {
+            return;
+        }
+        int i = AnonymousClass2.$SwitchMap$com$unity3d$services$core$properties$SdkProperties$InitializationState[SdkProperties.getCurrentInitializationState().ordinal()];
+        if (i == 1) {
+            super.executeAdOperation(iWebViewBridgeInvoker, loadOperationState);
+        } else if (i == 2) {
+            sendOnUnityAdsFailedToLoad(loadOperationState, UnityAds.UnityAdsLoadError.INITIALIZE_FAILED, "[UnityAds] SDK Initialization Failed");
+        } else {
+            this._queuedLoadEvents.put(loadOperationState, iWebViewBridgeInvoker);
+        }
+    }
+
+    @Override // com.unity3d.services.core.configuration.IInitializationListener
+    public synchronized void onSdkInitialized() {
+        try {
+            for (Map.Entry<LoadOperationState, IWebViewBridgeInvoker> entry : this._queuedLoadEvents.entrySet()) {
+                super.executeAdOperation(entry.getValue(), entry.getKey());
+            }
+            this._queuedLoadEvents.clear();
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    @Override // com.unity3d.services.core.configuration.IInitializationListener
+    public synchronized void onSdkInitializationFailed(String str, ErrorState errorState, int i) {
+        try {
+            Iterator<LoadOperationState> it = this._queuedLoadEvents.keySet().iterator();
+            while (it.hasNext()) {
+                sendOnUnityAdsFailedToLoad(it.next(), UnityAds.UnityAdsLoadError.INITIALIZE_FAILED, "[UnityAds] SDK Initialization Failure");
+            }
+            this._queuedLoadEvents.clear();
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    private void sendOnUnityAdsFailedToLoad(final LoadOperationState loadOperationState, final UnityAds.UnityAdsLoadError unityAdsLoadError, final String str) {
+        if (loadOperationState == null || loadOperationState.listener == null) {
+            return;
+        }
+        getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdLoadFailure(unityAdsLoadError, Long.valueOf(loadOperationState.duration()), loadOperationState.isBanner(), loadOperationState.isHeaderBidding()));
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.load.LoadModuleDecoratorInitializationBuffer.1
+            @Override // java.lang.Runnable
+            public void run() {
+                LoadOperationState loadOperationState2 = loadOperationState;
+                loadOperationState2.listener.onUnityAdsFailedToLoad(loadOperationState2.placementId, unityAdsLoadError, str);
+            }
+        });
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/LoadModuleDecoratorTimeout.java

@@ -0,0 +1,88 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.core.configuration.ExperimentsReader;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.request.metrics.AdOperationError;
+import com.unity3d.services.core.request.metrics.AdOperationMetric;
+import com.unity3d.services.core.timer.BaseTimer;
+import com.unity3d.services.core.timer.ITimerListener;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeInvoker;
+import java.util.concurrent.Executors;
+
+/* loaded from: classes4.dex */
+public class LoadModuleDecoratorTimeout extends LoadModuleDecorator {
+    private static final String errorMsgTimeoutLoading = "[UnityAds] Timeout while loading ";
+    private final ExperimentsReader _experimentsReader;
+
+    public LoadModuleDecoratorTimeout(ILoadModule iLoadModule, ExperimentsReader experimentsReader) {
+        super(iLoadModule);
+        this._experimentsReader = experimentsReader;
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.unity3d.services.ads.operation.load.LoadModuleDecorator, com.unity3d.services.ads.operation.IAdModule
+    public void executeAdOperation(IWebViewBridgeInvoker iWebViewBridgeInvoker, LoadOperationState loadOperationState) {
+        getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdLoadStart(loadOperationState.isBanner(), loadOperationState.isHeaderBidding()));
+        loadOperationState.start();
+        if (!this._experimentsReader.getCurrentlyActiveExperiments().isNativeLoadTimeoutDisabled()) {
+            startLoadTimeout(loadOperationState);
+        }
+        super.executeAdOperation(iWebViewBridgeInvoker, loadOperationState);
+    }
+
+    private void startLoadTimeout(final LoadOperationState loadOperationState) {
+        if (loadOperationState == null) {
+            return;
+        }
+        BaseTimer baseTimer = new BaseTimer(Integer.valueOf(loadOperationState.configuration.getLoadTimeout()), new ITimerListener() { // from class: com.unity3d.services.ads.operation.load.LoadModuleDecoratorTimeout.1
+            @Override // com.unity3d.services.core.timer.ITimerListener
+            public void onTimerFinished() {
+                LoadModuleDecoratorTimeout.this.onOperationTimeout(loadOperationState);
+            }
+        });
+        loadOperationState.timeoutTimer = baseTimer;
+        baseTimer.start(Executors.newSingleThreadScheduledExecutor());
+    }
+
+    @Override // com.unity3d.services.ads.operation.load.LoadModuleDecorator, com.unity3d.services.ads.operation.load.ILoadModule
+    public void onUnityAdsAdLoaded(String str) {
+        releaseOperationTimeoutLock(str);
+        super.onUnityAdsAdLoaded(str);
+    }
+
+    @Override // com.unity3d.services.ads.operation.load.LoadModuleDecorator, com.unity3d.services.ads.operation.load.ILoadModule
+    public void onUnityAdsFailedToLoad(String str, UnityAds.UnityAdsLoadError unityAdsLoadError, String str2) {
+        releaseOperationTimeoutLock(str);
+        super.onUnityAdsFailedToLoad(str, unityAdsLoadError, str2);
+    }
+
+    private void releaseOperationTimeoutLock(String str) {
+        LoadOperationState loadOperationState;
+        BaseTimer baseTimer;
+        ILoadOperation iLoadOperation = get(str);
+        if (iLoadOperation == null || (loadOperationState = iLoadOperation.getLoadOperationState()) == null || (baseTimer = loadOperationState.timeoutTimer) == null) {
+            return;
+        }
+        baseTimer.kill();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onOperationTimeout(final LoadOperationState loadOperationState) {
+        if (loadOperationState != null) {
+            getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdLoadFailure(AdOperationError.timeout, Long.valueOf(loadOperationState.duration()), loadOperationState.isBanner(), loadOperationState.isHeaderBidding()));
+            remove(loadOperationState.id);
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.load.LoadModuleDecoratorTimeout$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    LoadModuleDecoratorTimeout.lambda$onOperationTimeout$0(LoadOperationState.this);
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static /* synthetic */ void lambda$onOperationTimeout$0(LoadOperationState loadOperationState) {
+        loadOperationState.onUnityAdsFailedToLoad(UnityAds.UnityAdsLoadError.TIMEOUT, "[UnityAds] Timeout while loading " + loadOperationState.placementId);
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/LoadOperation.java

@@ -0,0 +1,58 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.ads.operation.AdOperation;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocation;
+
+/* loaded from: classes4.dex */
+public class LoadOperation extends AdOperation implements ILoadOperation {
+    private LoadOperationState _loadOperationState;
+
+    @Override // com.unity3d.services.ads.operation.load.ILoadOperation
+    public LoadOperationState getLoadOperationState() {
+        return this._loadOperationState;
+    }
+
+    public LoadOperation(LoadOperationState loadOperationState, IWebViewBridgeInvocation iWebViewBridgeInvocation) {
+        super(iWebViewBridgeInvocation, "load");
+        this._loadOperationState = loadOperationState;
+    }
+
+    @Override // com.unity3d.ads.IUnityAdsLoadListener
+    public void onUnityAdsAdLoaded(String str) {
+        LoadOperationState loadOperationState = this._loadOperationState;
+        if (loadOperationState == null || loadOperationState.listener == null || str == null) {
+            return;
+        }
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.load.LoadOperation.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (LoadOperation.this._loadOperationState != null) {
+                    LoadOperation.this._loadOperationState.onUnityAdsAdLoaded();
+                }
+            }
+        });
+    }
+
+    @Override // com.unity3d.ads.IUnityAdsLoadListener
+    public void onUnityAdsFailedToLoad(String str, final UnityAds.UnityAdsLoadError unityAdsLoadError, final String str2) {
+        LoadOperationState loadOperationState = this._loadOperationState;
+        if (loadOperationState == null || loadOperationState.listener == null || str == null) {
+            return;
+        }
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.load.LoadOperation.2
+            @Override // java.lang.Runnable
+            public void run() {
+                if (LoadOperation.this._loadOperationState != null) {
+                    LoadOperation.this._loadOperationState.onUnityAdsFailedToLoad(unityAdsLoadError, str2);
+                }
+            }
+        });
+    }
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewSharedObject
+    public String getId() {
+        return this._loadOperationState.id;
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/load/LoadOperationState.java

@@ -0,0 +1,64 @@
+package com.unity3d.services.ads.operation.load;
+
+import com.unity3d.ads.IUnityAdsLoadListener;
+import com.unity3d.ads.UnityAds;
+import com.unity3d.ads.UnityAdsLoadOptions;
+import com.unity3d.services.ads.operation.OperationState;
+import com.unity3d.services.core.configuration.Configuration;
+import com.unity3d.services.core.misc.Utilities;
+
+/* loaded from: classes4.dex */
+public class LoadOperationState extends OperationState {
+    public IUnityAdsLoadListener listener;
+    public UnityAdsLoadOptions loadOptions;
+
+    public LoadOperationState(String str, IUnityAdsLoadListener iUnityAdsLoadListener, UnityAdsLoadOptions unityAdsLoadOptions, Configuration configuration) {
+        super(str, configuration);
+        this.listener = iUnityAdsLoadListener;
+        this.loadOptions = unityAdsLoadOptions;
+    }
+
+    public void onUnityAdsFailedToLoad(final UnityAds.UnityAdsLoadError unityAdsLoadError, final String str) {
+        if (this.listener != null) {
+            Utilities.wrapCustomerListener(new Runnable() { // from class: com.unity3d.services.ads.operation.load.LoadOperationState$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    LoadOperationState.this.lambda$onUnityAdsFailedToLoad$0(unityAdsLoadError, str);
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$onUnityAdsFailedToLoad$0(UnityAds.UnityAdsLoadError unityAdsLoadError, String str) {
+        this.listener.onUnityAdsFailedToLoad(this.placementId, unityAdsLoadError, str);
+    }
+
+    public void onUnityAdsAdLoaded() {
+        if (this.listener != null) {
+            Utilities.wrapCustomerListener(new Runnable() { // from class: com.unity3d.services.ads.operation.load.LoadOperationState$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    LoadOperationState.this.lambda$onUnityAdsAdLoaded$1();
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$onUnityAdsAdLoaded$1() {
+        this.listener.onUnityAdsAdLoaded(this.placementId);
+    }
+
+    public boolean isBanner() {
+        return this instanceof LoadBannerOperationState;
+    }
+
+    public boolean isHeaderBidding() {
+        UnityAdsLoadOptions unityAdsLoadOptions = this.loadOptions;
+        if (unityAdsLoadOptions == null || unityAdsLoadOptions.getData() == null) {
+            return false;
+        }
+        return this.loadOptions.getData().has("adMarkup");
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/show/IShowModule.java

@@ -0,0 +1,17 @@
+package com.unity3d.services.ads.operation.show;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.ads.operation.IAdModule;
+
+/* loaded from: classes4.dex */
+public interface IShowModule extends IAdModule<IShowOperation, ShowOperationState> {
+    void onUnityAdsShowClick(String str);
+
+    void onUnityAdsShowComplete(String str, UnityAds.UnityAdsShowCompletionState unityAdsShowCompletionState);
+
+    void onUnityAdsShowConsent(String str);
+
+    void onUnityAdsShowFailure(String str, UnityAds.UnityAdsShowError unityAdsShowError, String str2);
+
+    void onUnityAdsShowStart(String str);
+}

decompiled/sources/com/unity3d/services/ads/operation/show/IShowOperation.java

@@ -0,0 +1,9 @@
+package com.unity3d.services.ads.operation.show;
+
+import com.unity3d.ads.IUnityAdsShowListener;
+import com.unity3d.services.ads.operation.IAdOperation;
+
+/* loaded from: classes4.dex */
+public interface IShowOperation extends IAdOperation, IUnityAdsShowListener {
+    ShowOperationState getShowOperationState();
+}

decompiled/sources/com/unity3d/services/ads/operation/show/ShowModule.java

@@ -0,0 +1,163 @@
+package com.unity3d.services.ads.operation.show;
+
+import android.app.Activity;
+import android.graphics.Point;
+import android.text.TextUtils;
+import android.view.Display;
+import android.view.WindowManager;
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import com.ironsource.v8;
+import com.tapjoy.TJAdUnitConstants;
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.ads.operation.AdModule;
+import com.unity3d.services.core.configuration.ExperimentsReader;
+import com.unity3d.services.core.device.Device;
+import com.unity3d.services.core.device.reader.HdrInfoReader;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.properties.ClientProperties;
+import com.unity3d.services.core.request.metrics.AdOperationError;
+import com.unity3d.services.core.request.metrics.AdOperationMetric;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.webview.bridge.CallbackStatus;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeInvoker;
+import com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocationCallback;
+import com.unity3d.services.core.webview.bridge.invocation.WebViewBridgeInvocation;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class ShowModule extends AdModule<IShowOperation, ShowOperationState> implements IShowModule {
+    public static String errorMsgPlacementIdNull = "[UnityAds] Placement ID cannot be null";
+    private static IShowModule instance;
+
+    public static IShowModule getInstance() {
+        if (instance == null) {
+            instance = new ShowModuleDecoratorTimeout(new ShowModule((SDKMetricsSender) Utilities.getService(SDKMetricsSender.class)), new ExperimentsReader());
+        }
+        return instance;
+    }
+
+    public ShowModule(SDKMetricsSender sDKMetricsSender) {
+        super(sDKMetricsSender);
+    }
+
+    @Override // com.unity3d.services.ads.operation.IAdModule
+    public void executeAdOperation(IWebViewBridgeInvoker iWebViewBridgeInvoker, final ShowOperationState showOperationState) {
+        if (TextUtils.isEmpty(showOperationState.placementId)) {
+            sendOnUnityAdsFailedToShow(showOperationState, errorMsgPlacementIdNull, UnityAds.UnityAdsShowError.INVALID_ARGUMENT, true);
+            return;
+        }
+        ShowOperation showOperation = new ShowOperation(showOperationState, new WebViewBridgeInvocation(this._executorService, iWebViewBridgeInvoker, new IWebViewBridgeInvocationCallback() { // from class: com.unity3d.services.ads.operation.show.ShowModule.1
+            @Override // com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocationCallback
+            public void onSuccess() {
+            }
+
+            @Override // com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocationCallback
+            public void onFailure(String str, CallbackStatus callbackStatus) {
+                ShowModule.this.getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdShowFailure(AdOperationError.callback_error, Long.valueOf(showOperationState.duration())));
+                ShowModule.this.sendOnUnityAdsFailedToShow(showOperationState, str, UnityAds.UnityAdsShowError.INTERNAL_ERROR, false);
+                ShowModule.this.remove(showOperationState.id);
+            }
+
+            @Override // com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocationCallback
+            public void onTimeout() {
+                ShowModule.this.getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdShowFailure(AdOperationError.callback_timeout, Long.valueOf(showOperationState.duration())));
+                ShowModule.this.sendOnUnityAdsFailedToShow(showOperationState, "[UnityAds] Show Invocation Timeout", UnityAds.UnityAdsShowError.INTERNAL_ERROR, false);
+                ShowModule.this.remove(showOperationState.id);
+            }
+        }));
+        Activity activity = showOperationState.activity.get();
+        ClientProperties.setActivity(activity);
+        Display defaultDisplay = ((WindowManager) activity.getSystemService("window")).getDefaultDisplay();
+        JSONObject jSONObject = new JSONObject();
+        JSONObject jSONObject2 = new JSONObject();
+        JSONObject jSONObject3 = new JSONObject();
+        try {
+            jSONObject3.put("requestedOrientation", activity.getRequestedOrientation());
+            jSONObject3.put(TJAdUnitConstants.String.ROTATION, defaultDisplay.getRotation());
+            Point point = new Point();
+            defaultDisplay.getSize(point);
+            jSONObject3.put("width", point.x);
+            jSONObject3.put("height", point.y);
+            jSONObject2.put("display", jSONObject3);
+            jSONObject2.put("headerBiddingOptions", showOperationState.showOptions.getData());
+            jSONObject.put(SDKConstants.PARAM_GAME_REQUESTS_OPTIONS, jSONObject2);
+            jSONObject.put("listenerId", showOperation.getId());
+            jSONObject.put(v8.j, showOperationState.placementId);
+            jSONObject.put("time", Device.getElapsedRealtime());
+            set(showOperation);
+            showOperation.invoke(showOperationState.configuration.getWebViewBridgeTimeout(), jSONObject);
+            HdrInfoReader.getInstance().captureHDRCapabilityMetrics(activity, new ExperimentsReader());
+        } catch (NullPointerException unused) {
+            sendOnUnityAdsFailedToShow(showOperationState, "[UnityAds] Error creating show options", UnityAds.UnityAdsShowError.INTERNAL_ERROR, true);
+        } catch (JSONException unused2) {
+            sendOnUnityAdsFailedToShow(showOperationState, "[UnityAds] Error creating show options", UnityAds.UnityAdsShowError.INTERNAL_ERROR, true);
+        }
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowFailure(String str, UnityAds.UnityAdsShowError unityAdsShowError, String str2) {
+        IShowOperation iShowOperation = (IShowOperation) get(str);
+        if (iShowOperation == null || iShowOperation.getShowOperationState() == null) {
+            return;
+        }
+        ShowOperationState showOperationState = iShowOperation.getShowOperationState();
+        getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdShowFailure(unityAdsShowError, Long.valueOf(showOperationState.duration())));
+        iShowOperation.onUnityAdsShowFailure(showOperationState.placementId, unityAdsShowError, str2);
+        remove(str);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowConsent(String str) {
+        IShowOperation iShowOperation = (IShowOperation) get(str);
+        if (iShowOperation != null) {
+            iShowOperation.getShowOperationState();
+        }
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowStart(String str) {
+        IShowOperation iShowOperation = (IShowOperation) get(str);
+        if (iShowOperation == null || iShowOperation.getShowOperationState() == null) {
+            return;
+        }
+        iShowOperation.onUnityAdsShowStart(iShowOperation.getShowOperationState().placementId);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowClick(String str) {
+        IShowOperation iShowOperation = (IShowOperation) get(str);
+        if (iShowOperation == null || iShowOperation.getShowOperationState() == null) {
+            return;
+        }
+        iShowOperation.onUnityAdsShowClick(iShowOperation.getShowOperationState().placementId);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowComplete(String str, UnityAds.UnityAdsShowCompletionState unityAdsShowCompletionState) {
+        IShowOperation iShowOperation = (IShowOperation) get(str);
+        if (iShowOperation == null || iShowOperation.getShowOperationState() == null) {
+            return;
+        }
+        ShowOperationState showOperationState = iShowOperation.getShowOperationState();
+        getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdShowSuccess(Long.valueOf(showOperationState.duration())));
+        iShowOperation.onUnityAdsShowComplete(showOperationState.placementId, unityAdsShowCompletionState);
+        remove(str);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void sendOnUnityAdsFailedToShow(final ShowOperationState showOperationState, final String str, final UnityAds.UnityAdsShowError unityAdsShowError, boolean z) {
+        if (showOperationState == null || showOperationState.listener == null) {
+            return;
+        }
+        if (z) {
+            getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdShowFailure(unityAdsShowError, Long.valueOf(showOperationState.duration())));
+        }
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowModule.2
+            @Override // java.lang.Runnable
+            public void run() {
+                showOperationState.onUnityAdsShowFailure(unityAdsShowError, str);
+            }
+        });
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/show/ShowModuleDecorator.java

@@ -0,0 +1,64 @@
+package com.unity3d.services.ads.operation.show;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeInvoker;
+
+/* loaded from: classes4.dex */
+public class ShowModuleDecorator implements IShowModule {
+    private final IShowModule _showModule;
+
+    public ShowModuleDecorator(IShowModule iShowModule) {
+        this._showModule = iShowModule;
+    }
+
+    @Override // com.unity3d.services.ads.operation.IAdModule
+    public void executeAdOperation(IWebViewBridgeInvoker iWebViewBridgeInvoker, ShowOperationState showOperationState) {
+        this._showModule.executeAdOperation(iWebViewBridgeInvoker, showOperationState);
+    }
+
+    @Override // com.unity3d.services.ads.operation.IAdModule
+    public SDKMetricsSender getMetricSender() {
+        return this._showModule.getMetricSender();
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowFailure(String str, UnityAds.UnityAdsShowError unityAdsShowError, String str2) {
+        this._showModule.onUnityAdsShowFailure(str, unityAdsShowError, str2);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowConsent(String str) {
+        this._showModule.onUnityAdsShowConsent(str);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowStart(String str) {
+        this._showModule.onUnityAdsShowStart(str);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowClick(String str) {
+        this._showModule.onUnityAdsShowClick(str);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowComplete(String str, UnityAds.UnityAdsShowCompletionState unityAdsShowCompletionState) {
+        this._showModule.onUnityAdsShowComplete(str, unityAdsShowCompletionState);
+    }
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewBridgeSharedObjectStore
+    public IShowOperation get(String str) {
+        return (IShowOperation) this._showModule.get(str);
+    }
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewBridgeSharedObjectStore
+    public void set(IShowOperation iShowOperation) {
+        this._showModule.set(iShowOperation);
+    }
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewBridgeSharedObjectStore
+    public void remove(String str) {
+        this._showModule.remove(str);
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/show/ShowModuleDecoratorTimeout.java

@@ -0,0 +1,89 @@
+package com.unity3d.services.ads.operation.show;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.core.configuration.ExperimentsReader;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.request.metrics.AdOperationError;
+import com.unity3d.services.core.request.metrics.AdOperationMetric;
+import com.unity3d.services.core.timer.BaseTimer;
+import com.unity3d.services.core.timer.ITimerListener;
+import com.unity3d.services.core.webview.bridge.IWebViewBridgeInvoker;
+import java.util.concurrent.Executors;
+
+/* loaded from: classes4.dex */
+public class ShowModuleDecoratorTimeout extends ShowModuleDecorator {
+    private static final String errorMsgTimeout = "[UnityAds] Timeout while trying to show ";
+    private final ExperimentsReader _experimentsReader;
+
+    public ShowModuleDecoratorTimeout(IShowModule iShowModule, ExperimentsReader experimentsReader) {
+        super(iShowModule);
+        this._experimentsReader = experimentsReader;
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.unity3d.services.ads.operation.show.ShowModuleDecorator, com.unity3d.services.ads.operation.IAdModule
+    public void executeAdOperation(IWebViewBridgeInvoker iWebViewBridgeInvoker, ShowOperationState showOperationState) {
+        getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdShowStart());
+        showOperationState.start();
+        if (!this._experimentsReader.getCurrentlyActiveExperiments().isNativeShowTimeoutDisabled()) {
+            startShowTimeout(showOperationState);
+        }
+        super.executeAdOperation(iWebViewBridgeInvoker, showOperationState);
+    }
+
+    private void startShowTimeout(final ShowOperationState showOperationState) {
+        if (showOperationState == null) {
+            return;
+        }
+        BaseTimer baseTimer = new BaseTimer(Integer.valueOf(showOperationState.configuration.getShowTimeout()), new ITimerListener() { // from class: com.unity3d.services.ads.operation.show.ShowModuleDecoratorTimeout.1
+            @Override // com.unity3d.services.core.timer.ITimerListener
+            public void onTimerFinished() {
+                ShowModuleDecoratorTimeout.this.onOperationTimeout(showOperationState, UnityAds.UnityAdsShowError.TIMEOUT, "[UnityAds] Timeout while trying to show " + showOperationState.placementId);
+            }
+        });
+        showOperationState.timeoutTimer = baseTimer;
+        baseTimer.start(Executors.newSingleThreadScheduledExecutor());
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.ShowModuleDecorator, com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowConsent(String str) {
+        releaseOperationTimeoutLock(str);
+        super.onUnityAdsShowConsent(str);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.ShowModuleDecorator, com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowFailure(String str, UnityAds.UnityAdsShowError unityAdsShowError, String str2) {
+        releaseOperationTimeoutLock(str);
+        super.onUnityAdsShowFailure(str, unityAdsShowError, str2);
+    }
+
+    @Override // com.unity3d.services.ads.operation.show.ShowModuleDecorator, com.unity3d.services.ads.operation.show.IShowModule
+    public void onUnityAdsShowStart(String str) {
+        releaseOperationTimeoutLock(str);
+        super.onUnityAdsShowStart(str);
+    }
+
+    private void releaseOperationTimeoutLock(String str) {
+        ShowOperationState showOperationState;
+        BaseTimer baseTimer;
+        IShowOperation iShowOperation = get(str);
+        if (iShowOperation == null || (showOperationState = iShowOperation.getShowOperationState()) == null || (baseTimer = showOperationState.timeoutTimer) == null) {
+            return;
+        }
+        baseTimer.kill();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onOperationTimeout(final ShowOperationState showOperationState, final UnityAds.UnityAdsShowError unityAdsShowError, final String str) {
+        if (showOperationState != null) {
+            getMetricSender().sendMetricWithInitState(AdOperationMetric.newAdShowFailure(AdOperationError.timeout, Long.valueOf(showOperationState.duration())));
+            remove(showOperationState.id);
+            Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowModuleDecoratorTimeout$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ShowOperationState.this.onUnityAdsShowFailure(unityAdsShowError, str);
+                }
+            });
+        }
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/show/ShowOperation.java

@@ -0,0 +1,87 @@
+package com.unity3d.services.ads.operation.show;
+
+import com.unity3d.ads.UnityAds;
+import com.unity3d.services.ads.operation.AdOperation;
+import com.unity3d.services.core.misc.Utilities;
+import com.unity3d.services.core.webview.bridge.invocation.IWebViewBridgeInvocation;
+
+/* loaded from: classes4.dex */
+public class ShowOperation extends AdOperation implements IShowOperation {
+    private ShowOperationState showOperationState;
+
+    @Override // com.unity3d.services.ads.operation.show.IShowOperation
+    public ShowOperationState getShowOperationState() {
+        return this.showOperationState;
+    }
+
+    public ShowOperation(ShowOperationState showOperationState, IWebViewBridgeInvocation iWebViewBridgeInvocation) {
+        super(iWebViewBridgeInvocation, "show");
+        this.showOperationState = showOperationState;
+    }
+
+    @Override // com.unity3d.ads.IUnityAdsShowListener
+    public void onUnityAdsShowFailure(String str, final UnityAds.UnityAdsShowError unityAdsShowError, final String str2) {
+        ShowOperationState showOperationState = this.showOperationState;
+        if (showOperationState == null || showOperationState.listener == null) {
+            return;
+        }
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowOperation.1
+            @Override // java.lang.Runnable
+            public void run() {
+                if (ShowOperation.this.showOperationState != null) {
+                    ShowOperation.this.showOperationState.onUnityAdsShowFailure(unityAdsShowError, str2);
+                }
+            }
+        });
+    }
+
+    @Override // com.unity3d.ads.IUnityAdsShowListener
+    public void onUnityAdsShowStart(final String str) {
+        if (this.showOperationState == null) {
+            return;
+        }
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowOperation.2
+            @Override // java.lang.Runnable
+            public void run() {
+                if (ShowOperation.this.showOperationState != null) {
+                    ShowOperation.this.showOperationState.onUnityAdsShowStart(str);
+                }
+            }
+        });
+    }
+
+    @Override // com.unity3d.ads.IUnityAdsShowListener
+    public void onUnityAdsShowClick(String str) {
+        if (this.showOperationState == null) {
+            return;
+        }
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowOperation.3
+            @Override // java.lang.Runnable
+            public void run() {
+                if (ShowOperation.this.showOperationState != null) {
+                    ShowOperation.this.showOperationState.onUnityAdsShowClick();
+                }
+            }
+        });
+    }
+
+    @Override // com.unity3d.ads.IUnityAdsShowListener
+    public void onUnityAdsShowComplete(String str, final UnityAds.UnityAdsShowCompletionState unityAdsShowCompletionState) {
+        if (this.showOperationState == null) {
+            return;
+        }
+        Utilities.runOnUiThread(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowOperation.4
+            @Override // java.lang.Runnable
+            public void run() {
+                if (ShowOperation.this.showOperationState != null) {
+                    ShowOperation.this.showOperationState.onUnityAdsShowComplete(unityAdsShowCompletionState);
+                }
+            }
+        });
+    }
+
+    @Override // com.unity3d.services.core.webview.bridge.IWebViewSharedObject
+    public String getId() {
+        return this.showOperationState.id;
+    }
+}

decompiled/sources/com/unity3d/services/ads/operation/show/ShowOperationState.java

@@ -0,0 +1,88 @@
+package com.unity3d.services.ads.operation.show;
+
+import android.app.Activity;
+import com.unity3d.ads.IUnityAdsShowListener;
+import com.unity3d.ads.UnityAds;
+import com.unity3d.ads.UnityAdsShowOptions;
+import com.unity3d.services.ads.operation.OperationState;
+import com.unity3d.services.core.configuration.Configuration;
+import com.unity3d.services.core.misc.Utilities;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes4.dex */
+public class ShowOperationState extends OperationState {
+    public WeakReference<Activity> activity;
+    public IUnityAdsShowListener listener;
+    public UnityAdsShowOptions showOptions;
+
+    public ShowOperationState(String str, IUnityAdsShowListener iUnityAdsShowListener, Activity activity, UnityAdsShowOptions unityAdsShowOptions, Configuration configuration) {
+        super(str, configuration);
+        this.listener = iUnityAdsShowListener;
+        this.activity = new WeakReference<>(activity);
+        this.showOptions = unityAdsShowOptions;
+    }
+
+    public void onUnityAdsShowFailure(final UnityAds.UnityAdsShowError unityAdsShowError, final String str) {
+        if (this.listener != null) {
+            Utilities.wrapCustomerListener(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowOperationState$$ExternalSyntheticLambda3
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ShowOperationState.this.lambda$onUnityAdsShowFailure$0(unityAdsShowError, str);
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$onUnityAdsShowFailure$0(UnityAds.UnityAdsShowError unityAdsShowError, String str) {
+        this.listener.onUnityAdsShowFailure(this.placementId, unityAdsShowError, str);
+    }
+
+    public void onUnityAdsShowClick() {
+        if (this.listener != null) {
+            Utilities.wrapCustomerListener(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowOperationState$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ShowOperationState.this.lambda$onUnityAdsShowClick$1();
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$onUnityAdsShowClick$1() {
+        this.listener.onUnityAdsShowClick(this.placementId);
+    }
+
+    public void onUnityAdsShowStart(final String str) {
+        if (this.listener != null) {
+            Utilities.wrapCustomerListener(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowOperationState$$ExternalSyntheticLambda2
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ShowOperationState.this.lambda$onUnityAdsShowStart$2(str);
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$onUnityAdsShowStart$2(String str) {
+        this.listener.onUnityAdsShowStart(str);
+    }
+
+    public void onUnityAdsShowComplete(final UnityAds.UnityAdsShowCompletionState unityAdsShowCompletionState) {
+        if (this.listener != null) {
+            Utilities.wrapCustomerListener(new Runnable() { // from class: com.unity3d.services.ads.operation.show.ShowOperationState$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    ShowOperationState.this.lambda$onUnityAdsShowComplete$3(unityAdsShowCompletionState);
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$onUnityAdsShowComplete$3(UnityAds.UnityAdsShowCompletionState unityAdsShowCompletionState) {
+        this.listener.onUnityAdsShowComplete(this.placementId, unityAdsShowCompletionState);
+    }
+}

decompiled/sources/com/unity3d/services/ads/token/AsyncTokenStorage.java

@@ -0,0 +1,13 @@
+package com.unity3d.services.ads.token;
+
+import com.unity3d.services.ads.gmascar.managers.IBiddingManager;
+import com.unity3d.services.core.configuration.Configuration;
+
+/* loaded from: classes4.dex */
+public interface AsyncTokenStorage {
+    void getToken(IBiddingManager iBiddingManager);
+
+    void onTokenAvailable();
+
+    void setConfiguration(Configuration configuration);
+}

decompiled/sources/com/unity3d/services/ads/token/INativeTokenGenerator.java

@@ -0,0 +1,6 @@
+package com.unity3d.services.ads.token;
+
+/* loaded from: classes4.dex */
+public interface INativeTokenGenerator {
+    void generateToken(INativeTokenGeneratorListener iNativeTokenGeneratorListener);
+}

decompiled/sources/com/unity3d/services/ads/token/INativeTokenGeneratorListener.java

@@ -0,0 +1,6 @@
+package com.unity3d.services.ads.token;
+
+/* loaded from: classes4.dex */
+public interface INativeTokenGeneratorListener {
+    void onReady(String str);
+}

decompiled/sources/com/unity3d/services/ads/token/InMemoryAsyncTokenStorage.java

@@ -0,0 +1,241 @@
+package com.unity3d.services.ads.token;
+
+import android.os.Handler;
+import com.unity3d.services.ads.gmascar.GMA;
+import com.unity3d.services.ads.gmascar.managers.IBiddingManager;
+import com.unity3d.services.ads.gmascar.utils.ScarConstants;
+import com.unity3d.services.core.configuration.Configuration;
+import com.unity3d.services.core.configuration.ConfigurationReader;
+import com.unity3d.services.core.configuration.PrivacyConfigStorage;
+import com.unity3d.services.core.device.TokenType;
+import com.unity3d.services.core.device.reader.GameSessionIdReader;
+import com.unity3d.services.core.device.reader.builder.DeviceInfoReaderBuilderWithExtras;
+import com.unity3d.services.core.log.DeviceLog;
+import com.unity3d.services.core.properties.InitializationStatusReader;
+import com.unity3d.services.core.properties.SdkProperties;
+import com.unity3d.services.core.request.metrics.SDKMetricsSender;
+import com.unity3d.services.core.request.metrics.TSIMetric;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/* loaded from: classes4.dex */
+public class InMemoryAsyncTokenStorage implements AsyncTokenStorage {
+    private DeviceInfoReaderBuilderWithExtras _deviceInfoReaderBuilderWithExtras;
+    private final Handler _handler;
+    private INativeTokenGenerator _nativeTokenGenerator;
+    private final SDKMetricsSender _sdkMetrics;
+    private TokenStorage _tokenStorage;
+    private final List<TokenListenerState> _tokenListeners = new LinkedList();
+    private boolean _tokenAvailable = false;
+    private boolean _configurationWasSet = false;
+    private Configuration _configuration = new Configuration();
+    private final InitializationStatusReader _initStatusReader = new InitializationStatusReader();
+
+    private boolean isValidConfig(Configuration configuration) {
+        return configuration != null;
+    }
+
+    public class TokenListenerState {
+        public IBiddingManager biddingManager;
+        public boolean invoked;
+        public Runnable runnable;
+        public TokenType tokenType;
+
+        public TokenListenerState() {
+        }
+    }
+
+    public InMemoryAsyncTokenStorage(INativeTokenGenerator iNativeTokenGenerator, Handler handler, SDKMetricsSender sDKMetricsSender, TokenStorage tokenStorage) {
+        this._handler = handler;
+        this._nativeTokenGenerator = iNativeTokenGenerator;
+        this._sdkMetrics = sDKMetricsSender;
+        this._tokenStorage = tokenStorage;
+    }
+
+    @Override // com.unity3d.services.ads.token.AsyncTokenStorage
+    public synchronized void setConfiguration(Configuration configuration) {
+        try {
+            this._configuration = configuration;
+            boolean isValidConfig = isValidConfig(configuration);
+            this._configurationWasSet = isValidConfig;
+            if (isValidConfig) {
+                if (this._nativeTokenGenerator == null) {
+                    this._deviceInfoReaderBuilderWithExtras = new DeviceInfoReaderBuilderWithExtras(new ConfigurationReader(), PrivacyConfigStorage.getInstance(), GameSessionIdReader.getInstance());
+                    ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
+                    this._nativeTokenGenerator = new NativeTokenGenerator(newSingleThreadExecutor, this._deviceInfoReaderBuilderWithExtras);
+                    if (configuration.getExperiments().shouldNativeTokenAwaitPrivacy()) {
+                        this._nativeTokenGenerator = new NativeTokenGeneratorWithPrivacyAwait(newSingleThreadExecutor, this._nativeTokenGenerator, configuration.getPrivacyRequestWaitTimeout());
+                    }
+                }
+                Iterator it = new ArrayList(this._tokenListeners).iterator();
+                while (it.hasNext()) {
+                    handleTokenInvocation((TokenListenerState) it.next());
+                }
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    @Override // com.unity3d.services.ads.token.AsyncTokenStorage
+    public synchronized void onTokenAvailable() {
+        this._tokenAvailable = true;
+        if (this._configurationWasSet) {
+            notifyListenersTokenReady();
+        }
+    }
+
+    @Override // com.unity3d.services.ads.token.AsyncTokenStorage
+    public synchronized void getToken(IBiddingManager iBiddingManager) {
+        if (SdkProperties.getCurrentInitializationState() == SdkProperties.InitializationState.INITIALIZED_FAILED) {
+            iBiddingManager.onUnityAdsTokenReady(null);
+            sendTokenMetrics(null, TokenType.TOKEN_REMOTE);
+        } else if (SdkProperties.getCurrentInitializationState() == SdkProperties.InitializationState.NOT_INITIALIZED) {
+            iBiddingManager.onUnityAdsTokenReady(null);
+            sendTokenMetrics(null, TokenType.TOKEN_REMOTE);
+        } else {
+            TokenListenerState addTimeoutHandler = addTimeoutHandler(iBiddingManager);
+            if (this._configurationWasSet) {
+                handleTokenInvocation(addTimeoutHandler);
+            }
+        }
+    }
+
+    private synchronized TokenListenerState addTimeoutHandler(IBiddingManager iBiddingManager) {
+        final TokenListenerState tokenListenerState;
+        tokenListenerState = new TokenListenerState();
+        tokenListenerState.biddingManager = iBiddingManager;
+        tokenListenerState.tokenType = TokenType.TOKEN_REMOTE;
+        tokenListenerState.runnable = new Runnable() { // from class: com.unity3d.services.ads.token.InMemoryAsyncTokenStorage.1
+            @Override // java.lang.Runnable
+            public void run() {
+                InMemoryAsyncTokenStorage.this.notifyTokenReady(tokenListenerState, null);
+            }
+        };
+        this._tokenListeners.add(tokenListenerState);
+        this._handler.postDelayed(tokenListenerState.runnable, this._configuration.getTokenTimeout());
+        return tokenListenerState;
+    }
+
+    private synchronized void notifyListenersTokenReady() {
+        String token;
+        while (!this._tokenListeners.isEmpty() && (token = this._tokenStorage.getToken()) != null) {
+            notifyTokenReady(this._tokenListeners.get(0), token);
+        }
+    }
+
+    private void handleTokenInvocation(final TokenListenerState tokenListenerState) {
+        if (tokenListenerState.invoked) {
+            return;
+        }
+        tokenListenerState.invoked = true;
+        if (!this._tokenAvailable) {
+            tokenListenerState.tokenType = TokenType.TOKEN_NATIVE;
+            if (GMA.getInstance().hasSCARBiddingSupport() && this._deviceInfoReaderBuilderWithExtras != null) {
+                HashMap hashMap = new HashMap();
+                hashMap.put(ScarConstants.TOKEN_ID_KEY, tokenListenerState.biddingManager.getTokenIdentifier());
+                this._deviceInfoReaderBuilderWithExtras.setExtras(hashMap);
+            }
+            this._nativeTokenGenerator.generateToken(new INativeTokenGeneratorListener() { // from class: com.unity3d.services.ads.token.InMemoryAsyncTokenStorage.2
+                @Override // com.unity3d.services.ads.token.INativeTokenGeneratorListener
+                public void onReady(final String str) {
+                    InMemoryAsyncTokenStorage.this._handler.post(new Runnable() { // from class: com.unity3d.services.ads.token.InMemoryAsyncTokenStorage.2.1
+                        @Override // java.lang.Runnable
+                        public void run() {
+                            AnonymousClass2 anonymousClass2 = AnonymousClass2.this;
+                            InMemoryAsyncTokenStorage.this.notifyTokenReady(tokenListenerState, str);
+                        }
+                    });
+                }
+            });
+            return;
+        }
+        tokenListenerState.tokenType = TokenType.TOKEN_REMOTE;
+        String token = this._tokenStorage.getToken();
+        if (token == null || token.isEmpty()) {
+            return;
+        }
+        notifyTokenReady(tokenListenerState, token);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public synchronized void notifyTokenReady(TokenListenerState tokenListenerState, String str) {
+        try {
+            if (this._tokenListeners.remove(tokenListenerState)) {
+                tokenListenerState.biddingManager.onUnityAdsTokenReady(tokenListenerState.tokenType == TokenType.TOKEN_REMOTE ? tokenListenerState.biddingManager.getFormattedToken(str) : str);
+                try {
+                    this._handler.removeCallbacks(tokenListenerState.runnable);
+                } catch (Exception e) {
+                    DeviceLog.exception("Failed to remove callback from a handler", e);
+                }
+            }
+            sendTokenMetrics(str, tokenListenerState.tokenType);
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    /* renamed from: com.unity3d.services.ads.token.InMemoryAsyncTokenStorage$3, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass3 {
+        static final /* synthetic */ int[] $SwitchMap$com$unity3d$services$core$device$TokenType;
+
+        static {
+            int[] iArr = new int[TokenType.values().length];
+            $SwitchMap$com$unity3d$services$core$device$TokenType = iArr;
+            try {
+                iArr[TokenType.TOKEN_NATIVE.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$com$unity3d$services$core$device$TokenType[TokenType.TOKEN_REMOTE.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+        }
+    }
+
+    private void sendTokenMetrics(String str, TokenType tokenType) {
+        int i = AnonymousClass3.$SwitchMap$com$unity3d$services$core$device$TokenType[tokenType.ordinal()];
+        if (i == 1) {
+            sendNativeTokenMetrics(str);
+        } else if (i == 2) {
+            sendRemoteTokenMetrics(str);
+        } else {
+            DeviceLog.error("Unknown token type passed to sendTokenMetrics");
+        }
+    }
+
+    private void sendNativeTokenMetrics(String str) {
+        SDKMetricsSender sDKMetricsSender = this._sdkMetrics;
+        if (sDKMetricsSender == null) {
+            return;
+        }
+        if (str == null) {
+            sDKMetricsSender.sendMetric(TSIMetric.newNativeGeneratedTokenNull(getMetricTags()));
+        } else {
+            sDKMetricsSender.sendMetric(TSIMetric.newNativeGeneratedTokenAvailable(getMetricTags()));
+        }
+    }
+
+    private void sendRemoteTokenMetrics(String str) {
+        if (this._sdkMetrics == null) {
+            return;
+        }
+        if (str == null || str.isEmpty()) {
+            this._sdkMetrics.sendMetric(TSIMetric.newAsyncTokenNull(getMetricTags()));
+        } else {
+            this._sdkMetrics.sendMetric(TSIMetric.newAsyncTokenAvailable(getMetricTags()));
+        }
+    }
+
+    private Map<String, String> getMetricTags() {
+        HashMap hashMap = new HashMap();
+        hashMap.put("state", this._initStatusReader.getInitializationStateString(SdkProperties.getCurrentInitializationState()));
+        return hashMap;
+    }
+}

decompiled/sources/com/unity3d/services/ads/token/InMemoryTokenStorage.java

@@ -0,0 +1,150 @@
+package com.unity3d.services.ads.token;
+
+import com.unity3d.services.core.configuration.ConfigurationReader;
+import com.unity3d.services.core.configuration.InitializeEventsMetricSender;
+import com.unity3d.services.core.configuration.PrivacyConfigStorage;
+import com.unity3d.services.core.device.reader.GameSessionIdReader;
+import com.unity3d.services.core.device.reader.builder.DeviceInfoReaderBuilder;
+import com.unity3d.services.core.di.IServiceComponent;
+import com.unity3d.services.core.di.IServiceProvider;
+import com.unity3d.services.core.webview.WebViewApp;
+import com.unity3d.services.core.webview.WebViewEventCategory;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import kotlin.Lazy;
+import kotlin.LazyKt__LazyJVMKt;
+import kotlin.LazyThreadSafetyMode;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Reflection;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlinx.coroutines.flow.MutableStateFlow;
+import kotlinx.coroutines.flow.StateFlowKt;
+import org.json.JSONArray;
+import org.json.JSONException;
+
+@SourceDebugExtension({"SMAP\nInMemoryTokenStorage.kt\nKotlin\n*S Kotlin\n*F\n+ 1 InMemoryTokenStorage.kt\ncom/unity3d/services/ads/token/InMemoryTokenStorage\n+ 2 IServiceComponent.kt\ncom/unity3d/services/core/di/IServiceComponentKt\n+ 3 StateFlow.kt\nkotlinx/coroutines/flow/StateFlowKt\n*L\n1#1,101:1\n29#2,5:102\n230#3,5:107\n214#3,5:112\n230#3,5:117\n*S KotlinDebug\n*F\n+ 1 InMemoryTokenStorage.kt\ncom/unity3d/services/ads/token/InMemoryTokenStorage\n*L\n27#1:102,5\n53#1:107,5\n67#1:112,5\n91#1:117,5\n*E\n"})
+/* loaded from: classes4.dex */
+public final class InMemoryTokenStorage implements TokenStorage, IServiceComponent {
+    private final Lazy asyncTokenStorage$delegate;
+    private final ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
+    private final MutableStateFlow accessCounter = StateFlowKt.MutableStateFlow(-1);
+    private final MutableStateFlow initToken = StateFlowKt.MutableStateFlow(null);
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+    public InMemoryTokenStorage() {
+        Lazy lazy;
+        final String str = "";
+        lazy = LazyKt__LazyJVMKt.lazy(LazyThreadSafetyMode.NONE, new Function0() { // from class: com.unity3d.services.ads.token.InMemoryTokenStorage$special$$inlined$inject$default$1
+            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+            {
+                super(0);
+            }
+
+            /* JADX WARN: Type inference failed for: r0v3, types: [com.unity3d.services.ads.token.AsyncTokenStorage, java.lang.Object] */
+            @Override // kotlin.jvm.functions.Function0
+            public final AsyncTokenStorage invoke() {
+                IServiceComponent iServiceComponent = IServiceComponent.this;
+                return iServiceComponent.getServiceProvider().getRegistry().getService(str, Reflection.getOrCreateKotlinClass(AsyncTokenStorage.class));
+            }
+        });
+        this.asyncTokenStorage$delegate = lazy;
+    }
+
+    @Override // com.unity3d.services.core.di.IServiceComponent
+    public IServiceProvider getServiceProvider() {
+        return IServiceComponent.DefaultImpls.getServiceProvider(this);
+    }
+
+    private final AsyncTokenStorage getAsyncTokenStorage() {
+        return (AsyncTokenStorage) this.asyncTokenStorage$delegate.getValue();
+    }
+
+    @Override // com.unity3d.services.ads.token.TokenStorage
+    public void createTokens(JSONArray tokens) throws JSONException {
+        Intrinsics.checkNotNullParameter(tokens, "tokens");
+        deleteTokens();
+        appendTokens(tokens);
+    }
+
+    @Override // com.unity3d.services.ads.token.TokenStorage
+    public void appendTokens(JSONArray tokens) throws JSONException {
+        Intrinsics.checkNotNullParameter(tokens, "tokens");
+        this.accessCounter.compareAndSet(-1, 0);
+        int length = tokens.length();
+        for (int i = 0; i < length; i++) {
+            this.queue.add(tokens.getString(i));
+        }
+        if (length > 0) {
+            triggerTokenAvailable(false);
+            getAsyncTokenStorage().onTokenAvailable();
+        }
+    }
+
+    @Override // com.unity3d.services.ads.token.TokenStorage
+    public void deleteTokens() {
+        Object value;
+        this.queue.clear();
+        MutableStateFlow mutableStateFlow = this.accessCounter;
+        do {
+            value = mutableStateFlow.getValue();
+            ((Number) value).intValue();
+        } while (!mutableStateFlow.compareAndSet(value, -1));
+    }
+
+    @Override // com.unity3d.services.ads.token.TokenStorage
+    public String getToken() {
+        Object value;
+        Number number;
+        if (((Number) this.accessCounter.getValue()).intValue() == -1) {
+            return (String) this.initToken.getValue();
+        }
+        if (this.queue.isEmpty()) {
+            WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.TOKEN, TokenEvent.QUEUE_EMPTY, new Object[0]);
+            return null;
+        }
+        MutableStateFlow mutableStateFlow = this.accessCounter;
+        do {
+            value = mutableStateFlow.getValue();
+            number = (Number) value;
+        } while (!mutableStateFlow.compareAndSet(value, Integer.valueOf(number.intValue() + 1)));
+        WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.TOKEN, TokenEvent.TOKEN_ACCESS, Integer.valueOf(number.intValue()));
+        return this.queue.poll();
+    }
+
+    @Override // com.unity3d.services.ads.token.TokenStorage
+    public Unit getNativeGeneratedToken() {
+        new NativeTokenGenerator(this.executorService, new DeviceInfoReaderBuilder(new ConfigurationReader(), PrivacyConfigStorage.getInstance(), GameSessionIdReader.getInstance()), null).generateToken(new INativeTokenGeneratorListener() { // from class: com.unity3d.services.ads.token.InMemoryTokenStorage$$ExternalSyntheticLambda0
+            @Override // com.unity3d.services.ads.token.INativeTokenGeneratorListener
+            public final void onReady(String str) {
+                InMemoryTokenStorage._get_nativeGeneratedToken_$lambda$2(str);
+            }
+        });
+        return Unit.INSTANCE;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static final void _get_nativeGeneratedToken_$lambda$2(String str) {
+        WebViewApp.getCurrentApp().sendEvent(WebViewEventCategory.TOKEN, TokenEvent.TOKEN_NATIVE_DATA, str);
+    }
+
+    private final void triggerTokenAvailable(boolean z) {
+        InitializeEventsMetricSender.getInstance().sdkTokenDidBecomeAvailableWithConfig(z);
+    }
+
+    @Override // com.unity3d.services.ads.token.TokenStorage
+    public void setInitToken(String str) {
+        Object value;
+        if (str == null) {
+            return;
+        }
+        MutableStateFlow mutableStateFlow = this.initToken;
+        do {
+            value = mutableStateFlow.getValue();
+        } while (!mutableStateFlow.compareAndSet(value, str));
+        triggerTokenAvailable(true);
+        getAsyncTokenStorage().onTokenAvailable();
+    }
+}