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/vungle/ads/internal/ui/AdActivity.java

@@ -0,0 +1,472 @@
+package com.vungle.ads.internal.ui;
+
+import android.R;
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.view.MotionEvent;
+import android.widget.FrameLayout;
+import androidx.annotation.VisibleForTesting;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
+import androidx.core.view.WindowInsetsCompat;
+import androidx.core.view.WindowInsetsControllerCompat;
+import com.google.android.gms.drive.DriveFile;
+import com.vungle.ads.AdCantPlayWithoutWebView;
+import com.vungle.ads.AdConfig;
+import com.vungle.ads.AdNotLoadedCantPlay;
+import com.vungle.ads.ConcurrentPlaybackUnsupported;
+import com.vungle.ads.ServiceLocator;
+import com.vungle.ads.internal.ConfigManager;
+import com.vungle.ads.internal.executor.Executors;
+import com.vungle.ads.internal.executor.VungleThreadPoolExecutor;
+import com.vungle.ads.internal.model.AdPayload;
+import com.vungle.ads.internal.model.BidPayload;
+import com.vungle.ads.internal.model.Placement;
+import com.vungle.ads.internal.model.UnclosedAd;
+import com.vungle.ads.internal.omsdk.OMTracker;
+import com.vungle.ads.internal.platform.Platform;
+import com.vungle.ads.internal.presenter.AdEventListener;
+import com.vungle.ads.internal.presenter.MRAIDPresenter;
+import com.vungle.ads.internal.presenter.PresenterDelegate;
+import com.vungle.ads.internal.signals.SignalManager;
+import com.vungle.ads.internal.ui.view.MRAIDAdWidget;
+import com.vungle.ads.internal.util.Logger;
+import com.vungle.ads.internal.util.RingerModeReceiver;
+import kotlin.Lazy;
+import kotlin.LazyKt__LazyJVMKt;
+import kotlin.LazyThreadSafetyMode;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public abstract class AdActivity extends Activity {
+    public static final Companion Companion = new Companion(null);
+    public static final String REQUEST_KEY_EVENT_ID_EXTRA = "request_eventId";
+    public static final String REQUEST_KEY_EXTRA = "request";
+    private static final String TAG = "AdActivity";
+    private static AdPayload advertisement;
+    private static BidPayload bidPayload;
+    private static AdEventListener eventListener;
+    private static PresenterDelegate presenterDelegate;
+    private MRAIDAdWidget mraidAdWidget;
+    private MRAIDPresenter mraidPresenter;
+    private String placementRefId = "";
+    private final RingerModeReceiver ringerModeReceiver = new RingerModeReceiver();
+    private UnclosedAd unclosedAd;
+
+    @VisibleForTesting
+    public static /* synthetic */ void getMraidAdWidget$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getMraidPresenter$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getPlacementRefId$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting(otherwise = 4)
+    public boolean canRotate$vungle_ads_release() {
+        return false;
+    }
+
+    public final MRAIDAdWidget getMraidAdWidget$vungle_ads_release() {
+        return this.mraidAdWidget;
+    }
+
+    public final MRAIDPresenter getMraidPresenter$vungle_ads_release() {
+        return this.mraidPresenter;
+    }
+
+    public final String getPlacementRefId$vungle_ads_release() {
+        return this.placementRefId;
+    }
+
+    public final void setMraidAdWidget$vungle_ads_release(MRAIDAdWidget mRAIDAdWidget) {
+        this.mraidAdWidget = mRAIDAdWidget;
+    }
+
+    public final void setMraidPresenter$vungle_ads_release(MRAIDPresenter mRAIDPresenter) {
+        this.mraidPresenter = mRAIDPresenter;
+    }
+
+    public final void setPlacementRefId$vungle_ads_release(String str) {
+        Intrinsics.checkNotNullParameter(str, "<set-?>");
+        this.placementRefId = str;
+    }
+
+    @Override // android.app.Activity
+    public void onCreate(Bundle bundle) {
+        final Lazy lazy;
+        Lazy lazy2;
+        Lazy lazy3;
+        Lazy lazy4;
+        String watermark$vungle_ads_release;
+        super.onCreate(bundle);
+        requestWindowFeature(1);
+        getWindow().setFlags(16777216, 16777216);
+        Companion companion = Companion;
+        Intent intent = getIntent();
+        Intrinsics.checkNotNullExpressionValue(intent, "intent");
+        String valueOf = String.valueOf(companion.getPlacement(intent));
+        this.placementRefId = valueOf;
+        AdPayload adPayload = advertisement;
+        ConfigManager configManager = ConfigManager.INSTANCE;
+        Placement placement = configManager.getPlacement(valueOf);
+        if (placement == null || adPayload == null) {
+            AdEventListener adEventListener = eventListener;
+            if (adEventListener != null) {
+                adEventListener.onError(new AdNotLoadedCantPlay(), this.placementRefId);
+            }
+            finish();
+            return;
+        }
+        getWindow().getDecorView().setBackgroundColor(ViewCompat.MEASURED_STATE_MASK);
+        try {
+            MRAIDAdWidget mRAIDAdWidget = new MRAIDAdWidget(this);
+            ServiceLocator.Companion companion2 = ServiceLocator.Companion;
+            LazyThreadSafetyMode lazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED;
+            lazy = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.ui.AdActivity$onCreate$$inlined$inject$1
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                {
+                    super(0);
+                }
+
+                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.signals.SignalManager, java.lang.Object] */
+                @Override // kotlin.jvm.functions.Function0
+                public final SignalManager invoke() {
+                    return ServiceLocator.Companion.getInstance(this).getService(SignalManager.class);
+                }
+            });
+            Intent intent2 = getIntent();
+            Intrinsics.checkNotNullExpressionValue(intent2, "intent");
+            String eventId = companion.getEventId(intent2);
+            UnclosedAd unclosedAd = eventId != null ? new UnclosedAd(eventId, (String) null, 2, (DefaultConstructorMarker) null) : null;
+            this.unclosedAd = unclosedAd;
+            if (unclosedAd != null) {
+                m3977onCreate$lambda2(lazy).recordUnclosedAd(unclosedAd);
+            }
+            mRAIDAdWidget.setCloseDelegate(new MRAIDAdWidget.CloseDelegate() { // from class: com.vungle.ads.internal.ui.AdActivity$onCreate$5$1
+                @Override // com.vungle.ads.internal.ui.view.MRAIDAdWidget.CloseDelegate
+                public void close() {
+                    UnclosedAd unclosedAd2;
+                    SignalManager m3977onCreate$lambda2;
+                    unclosedAd2 = AdActivity.this.unclosedAd;
+                    if (unclosedAd2 != null) {
+                        m3977onCreate$lambda2 = AdActivity.m3977onCreate$lambda2(lazy);
+                        m3977onCreate$lambda2.removeUnclosedAd(unclosedAd2);
+                    }
+                    AdActivity.this.finish();
+                }
+            });
+            mRAIDAdWidget.setOnViewTouchListener(new MRAIDAdWidget.OnViewTouchListener() { // from class: com.vungle.ads.internal.ui.AdActivity$onCreate$5$2
+                @Override // com.vungle.ads.internal.ui.view.MRAIDAdWidget.OnViewTouchListener
+                public boolean onTouch(MotionEvent motionEvent) {
+                    MRAIDPresenter mraidPresenter$vungle_ads_release = AdActivity.this.getMraidPresenter$vungle_ads_release();
+                    if (mraidPresenter$vungle_ads_release == null) {
+                        return false;
+                    }
+                    mraidPresenter$vungle_ads_release.onViewTouched(motionEvent);
+                    return false;
+                }
+            });
+            mRAIDAdWidget.setOrientationDelegate(new MRAIDAdWidget.OrientationDelegate() { // from class: com.vungle.ads.internal.ui.AdActivity$onCreate$5$3
+                @Override // com.vungle.ads.internal.ui.view.MRAIDAdWidget.OrientationDelegate
+                public void setOrientation(int i) {
+                    AdActivity.this.setRequestedOrientation(i);
+                }
+            });
+            lazy2 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.ui.AdActivity$onCreate$$inlined$inject$2
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                {
+                    super(0);
+                }
+
+                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.executor.Executors, java.lang.Object] */
+                @Override // kotlin.jvm.functions.Function0
+                public final Executors invoke() {
+                    return ServiceLocator.Companion.getInstance(this).getService(Executors.class);
+                }
+            });
+            lazy3 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.ui.AdActivity$onCreate$$inlined$inject$3
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                {
+                    super(0);
+                }
+
+                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.platform.Platform, java.lang.Object] */
+                @Override // kotlin.jvm.functions.Function0
+                public final Platform invoke() {
+                    return ServiceLocator.Companion.getInstance(this).getService(Platform.class);
+                }
+            });
+            VungleWebClient vungleWebClient = new VungleWebClient(adPayload, placement, m3978onCreate$lambda6(lazy2).getOffloadExecutor(), m3977onCreate$lambda2(lazy), m3979onCreate$lambda7(lazy3));
+            lazy4 = LazyKt__LazyJVMKt.lazy(lazyThreadSafetyMode, new Function0() { // from class: com.vungle.ads.internal.ui.AdActivity$onCreate$$inlined$inject$4
+                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+                {
+                    super(0);
+                }
+
+                /* JADX WARN: Type inference failed for: r0v2, types: [com.vungle.ads.internal.omsdk.OMTracker$Factory, java.lang.Object] */
+                @Override // kotlin.jvm.functions.Function0
+                public final OMTracker.Factory invoke() {
+                    return ServiceLocator.Companion.getInstance(this).getService(OMTracker.Factory.class);
+                }
+            });
+            OMTracker make = m3980onCreate$lambda8(lazy4).make(configManager.omEnabled() && adPayload.omEnabled());
+            VungleThreadPoolExecutor jobExecutor = m3978onCreate$lambda6(lazy2).getJobExecutor();
+            vungleWebClient.setWebViewObserver(make);
+            this.ringerModeReceiver.setWebClient(vungleWebClient);
+            MRAIDPresenter mRAIDPresenter = new MRAIDPresenter(mRAIDAdWidget, adPayload, placement, vungleWebClient, jobExecutor, make, bidPayload, m3979onCreate$lambda7(lazy3));
+            mRAIDPresenter.setEventListener(eventListener);
+            mRAIDPresenter.setPresenterDelegate$vungle_ads_release(presenterDelegate);
+            mRAIDPresenter.prepare();
+            setContentView(mRAIDAdWidget, mRAIDAdWidget.getLayoutParams());
+            AdConfig adConfig = adPayload.getAdConfig();
+            if (adConfig != null && (watermark$vungle_ads_release = adConfig.getWatermark$vungle_ads_release()) != null) {
+                WatermarkView watermarkView = new WatermarkView(this, watermark$vungle_ads_release);
+                ((FrameLayout) getWindow().getDecorView().findViewById(R.id.content)).addView(watermarkView);
+                watermarkView.bringToFront();
+            }
+            this.mraidAdWidget = mRAIDAdWidget;
+            this.mraidPresenter = mRAIDPresenter;
+        } catch (InstantiationException unused) {
+            AdEventListener adEventListener2 = eventListener;
+            if (adEventListener2 != null) {
+                AdCantPlayWithoutWebView adCantPlayWithoutWebView = new AdCantPlayWithoutWebView();
+                adCantPlayWithoutWebView.setPlacementId$vungle_ads_release(this.placementRefId);
+                AdPayload adPayload2 = advertisement;
+                adCantPlayWithoutWebView.setEventId$vungle_ads_release(adPayload2 != null ? adPayload2.eventId() : null);
+                AdPayload adPayload3 = advertisement;
+                adCantPlayWithoutWebView.setCreativeId$vungle_ads_release(adPayload3 != null ? adPayload3.getCreativeId() : null);
+                adEventListener2.onError(adCantPlayWithoutWebView.logError$vungle_ads_release(), this.placementRefId);
+            }
+            finish();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: onCreate$lambda-2, reason: not valid java name */
+    public static final SignalManager m3977onCreate$lambda2(Lazy lazy) {
+        return (SignalManager) lazy.getValue();
+    }
+
+    /* renamed from: onCreate$lambda-6, reason: not valid java name */
+    private static final Executors m3978onCreate$lambda6(Lazy lazy) {
+        return (Executors) lazy.getValue();
+    }
+
+    /* renamed from: onCreate$lambda-7, reason: not valid java name */
+    private static final Platform m3979onCreate$lambda7(Lazy lazy) {
+        return (Platform) lazy.getValue();
+    }
+
+    /* renamed from: onCreate$lambda-8, reason: not valid java name */
+    private static final OMTracker.Factory m3980onCreate$lambda8(Lazy lazy) {
+        return (OMTracker.Factory) lazy.getValue();
+    }
+
+    @Override // android.app.Activity
+    public void onNewIntent(Intent intent) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        super.onNewIntent(intent);
+        Companion companion = Companion;
+        Intent intent2 = getIntent();
+        Intrinsics.checkNotNullExpressionValue(intent2, "getIntent()");
+        String placement = companion.getPlacement(intent2);
+        String placement2 = companion.getPlacement(intent);
+        Intent intent3 = getIntent();
+        Intrinsics.checkNotNullExpressionValue(intent3, "getIntent()");
+        String eventId = companion.getEventId(intent3);
+        String eventId2 = companion.getEventId(intent);
+        if ((placement == null || placement2 == null || Intrinsics.areEqual(placement, placement2)) && (eventId == null || eventId2 == null || Intrinsics.areEqual(eventId, eventId2))) {
+            return;
+        }
+        Logger.Companion.d(TAG, "Tried to play another placement " + placement2 + " while playing " + placement);
+        onConcurrentPlaybackError(placement2);
+    }
+
+    private final void onConcurrentPlaybackError(String str) {
+        ConcurrentPlaybackUnsupported concurrentPlaybackUnsupported = new ConcurrentPlaybackUnsupported();
+        AdEventListener adEventListener = eventListener;
+        if (adEventListener != null) {
+            adEventListener.onError(concurrentPlaybackUnsupported, str);
+        }
+        concurrentPlaybackUnsupported.setPlacementId(this.placementRefId);
+        AdPayload adPayload = advertisement;
+        concurrentPlaybackUnsupported.setCreativeId(adPayload != null ? adPayload.getCreativeId() : null);
+        AdPayload adPayload2 = advertisement;
+        concurrentPlaybackUnsupported.setEventId(adPayload2 != null ? adPayload2.eventId() : null);
+        concurrentPlaybackUnsupported.logErrorNoReturnValue$vungle_ads_release();
+        Logger.Companion.e(TAG, "onConcurrentPlaybackError: " + concurrentPlaybackUnsupported.getLocalizedMessage());
+    }
+
+    @Override // android.app.Activity
+    public void onResume() {
+        super.onResume();
+        hideSystemUi();
+        registerReceiver(this.ringerModeReceiver, new IntentFilter("android.media.RINGER_MODE_CHANGED"));
+        Logger.Companion.d(TAG, "registerReceiver(): " + this.ringerModeReceiver.hashCode());
+        MRAIDPresenter mRAIDPresenter = this.mraidPresenter;
+        if (mRAIDPresenter != null) {
+            mRAIDPresenter.start();
+        }
+    }
+
+    @Override // android.app.Activity
+    public void onPause() {
+        super.onPause();
+        unregisterReceiver(this.ringerModeReceiver);
+        Logger.Companion.d(TAG, "unregisterReceiver(): " + this.ringerModeReceiver.hashCode());
+        MRAIDPresenter mRAIDPresenter = this.mraidPresenter;
+        if (mRAIDPresenter != null) {
+            mRAIDPresenter.stop();
+        }
+    }
+
+    @Override // android.app.Activity, android.content.ComponentCallbacks
+    public void onConfigurationChanged(Configuration newConfig) {
+        Intrinsics.checkNotNullParameter(newConfig, "newConfig");
+        try {
+            super.onConfigurationChanged(newConfig);
+            int i = newConfig.orientation;
+            if (i == 2) {
+                Logger.Companion.d(TAG, "landscape");
+            } else if (i == 1) {
+                Logger.Companion.d(TAG, "portrait");
+            }
+            MRAIDPresenter mRAIDPresenter = this.mraidPresenter;
+            if (mRAIDPresenter != null) {
+                mRAIDPresenter.onViewConfigurationChanged();
+            }
+        } catch (Exception e) {
+            Logger.Companion.e(TAG, "onConfigurationChanged: " + e.getLocalizedMessage());
+        }
+    }
+
+    @Override // android.app.Activity
+    public void onBackPressed() {
+        MRAIDPresenter mRAIDPresenter = this.mraidPresenter;
+        if (mRAIDPresenter != null) {
+            mRAIDPresenter.handleExit();
+        }
+    }
+
+    @Override // android.app.Activity
+    public void setRequestedOrientation(int i) {
+        if (canRotate$vungle_ads_release()) {
+            super.setRequestedOrientation(i);
+        }
+    }
+
+    @Override // android.app.Activity
+    public void onDestroy() {
+        MRAIDPresenter mRAIDPresenter = this.mraidPresenter;
+        if (mRAIDPresenter != null) {
+            mRAIDPresenter.detach((isChangingConfigurations() ? 1 : 0) | 2);
+        }
+        super.onDestroy();
+    }
+
+    private final void hideSystemUi() {
+        WindowInsetsControllerCompat insetsController = WindowCompat.getInsetsController(getWindow(), getWindow().getDecorView());
+        Intrinsics.checkNotNullExpressionValue(insetsController, "getInsetsController(window, window.decorView)");
+        insetsController.setSystemBarsBehavior(2);
+        insetsController.hide(WindowInsetsCompat.Type.systemBars());
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        @VisibleForTesting
+        public static /* synthetic */ void getREQUEST_KEY_EVENT_ID_EXTRA$vungle_ads_release$annotations() {
+        }
+
+        @VisibleForTesting
+        public static /* synthetic */ void getREQUEST_KEY_EXTRA$vungle_ads_release$annotations() {
+        }
+
+        private Companion() {
+        }
+
+        @VisibleForTesting
+        public final AdEventListener getEventListener$vungle_ads_release() {
+            return AdActivity.eventListener;
+        }
+
+        public final void setEventListener$vungle_ads_release(AdEventListener adEventListener) {
+            AdActivity.eventListener = adEventListener;
+        }
+
+        public final PresenterDelegate getPresenterDelegate$vungle_ads_release() {
+            return AdActivity.presenterDelegate;
+        }
+
+        public final void setPresenterDelegate$vungle_ads_release(PresenterDelegate presenterDelegate) {
+            AdActivity.presenterDelegate = presenterDelegate;
+        }
+
+        public final AdPayload getAdvertisement$vungle_ads_release() {
+            return AdActivity.advertisement;
+        }
+
+        public final void setAdvertisement$vungle_ads_release(AdPayload adPayload) {
+            AdActivity.advertisement = adPayload;
+        }
+
+        public final BidPayload getBidPayload$vungle_ads_release() {
+            return AdActivity.bidPayload;
+        }
+
+        public final void setBidPayload$vungle_ads_release(BidPayload bidPayload) {
+            AdActivity.bidPayload = bidPayload;
+        }
+
+        public final Intent createIntent(Context context, String placement, String str) {
+            Intrinsics.checkNotNullParameter(placement, "placement");
+            Intent intent = new Intent(context, (Class<?>) VungleActivity.class);
+            if (!(context instanceof Activity)) {
+                intent.addFlags(DriveFile.MODE_READ_ONLY);
+            }
+            Bundle bundle = new Bundle();
+            bundle.putString("request", placement);
+            bundle.putString(AdActivity.REQUEST_KEY_EVENT_ID_EXTRA, str);
+            intent.putExtras(bundle);
+            return intent;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final String getPlacement(Intent intent) {
+            try {
+                Bundle extras = intent.getExtras();
+                if (extras != null) {
+                    return extras.getString("request");
+                }
+                return null;
+            } catch (Exception unused) {
+                return null;
+            }
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final String getEventId(Intent intent) {
+            try {
+                Bundle extras = intent.getExtras();
+                if (extras != null) {
+                    return extras.getString(AdActivity.REQUEST_KEY_EVENT_ID_EXTRA);
+                }
+                return null;
+            } catch (Exception unused) {
+                return null;
+            }
+        }
+    }
+}

decompiled/sources/com/vungle/ads/internal/ui/PresenterAdOpenCallback.java

@@ -0,0 +1,6 @@
+package com.vungle.ads.internal.ui;
+
+/* loaded from: classes4.dex */
+public interface PresenterAdOpenCallback {
+    void onDeeplinkClick(boolean z);
+}

decompiled/sources/com/vungle/ads/internal/ui/PresenterAppLeftCallback.java

@@ -0,0 +1,24 @@
+package com.vungle.ads.internal.ui;
+
+import com.vungle.ads.internal.presenter.AdEventListener;
+import com.vungle.ads.internal.presenter.MRAIDPresenter;
+import com.vungle.ads.internal.util.ActivityManager;
+
+/* loaded from: classes4.dex */
+public final class PresenterAppLeftCallback implements ActivityManager.LeftApplicationCallback {
+    private final AdEventListener bus;
+    private final String placementRefId;
+
+    public PresenterAppLeftCallback(AdEventListener adEventListener, String str) {
+        this.bus = adEventListener;
+        this.placementRefId = str;
+    }
+
+    @Override // com.vungle.ads.internal.util.ActivityManager.LeftApplicationCallback
+    public void onLeftApplication() {
+        AdEventListener adEventListener = this.bus;
+        if (adEventListener != null) {
+            adEventListener.onNext(MRAIDPresenter.OPEN, "adLeftApplication", this.placementRefId);
+        }
+    }
+}

decompiled/sources/com/vungle/ads/internal/ui/VungleActivity.java

@@ -0,0 +1,12 @@
+package com.vungle.ads.internal.ui;
+
+import androidx.annotation.VisibleForTesting;
+
+/* loaded from: classes4.dex */
+public final class VungleActivity extends AdActivity {
+    @Override // com.vungle.ads.internal.ui.AdActivity
+    @VisibleForTesting(otherwise = 4)
+    public boolean canRotate$vungle_ads_release() {
+        return true;
+    }
+}

decompiled/sources/com/vungle/ads/internal/ui/VungleWebClient$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,10 @@
+package com.vungle.ads.internal.ui;
+
+import android.webkit.WebViewRenderProcessClient;
+
+/* loaded from: classes4.dex */
+public abstract /* synthetic */ class VungleWebClient$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ WebViewRenderProcessClient m(Object obj) {
+        return (WebViewRenderProcessClient) obj;
+    }
+}

decompiled/sources/com/vungle/ads/internal/ui/VungleWebClient.java

@@ -0,0 +1,508 @@
+package com.vungle.ads.internal.ui;
+
+import android.os.Build;
+import android.os.Handler;
+import android.webkit.RenderProcessGoneDetail;
+import android.webkit.WebResourceError;
+import android.webkit.WebResourceRequest;
+import android.webkit.WebResourceResponse;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.webkit.WebViewRenderProcess;
+import android.webkit.WebViewRenderProcessClient;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.VisibleForTesting;
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import com.glu.plugins.gluanalytics.AnalyticsData;
+import com.ironsource.ad;
+import com.ironsource.v8;
+import com.mbridge.msdk.newreward.player.view.hybrid.util.MRAIDCommunicatorUtil;
+import com.vungle.ads.AnalyticsClient;
+import com.vungle.ads.BuildConfig;
+import com.vungle.ads.internal.ConfigManager;
+import com.vungle.ads.internal.model.AdPayload;
+import com.vungle.ads.internal.model.Placement;
+import com.vungle.ads.internal.omsdk.WebViewObserver;
+import com.vungle.ads.internal.platform.Platform;
+import com.vungle.ads.internal.signals.SignalManager;
+import com.vungle.ads.internal.ui.view.WebViewAPI;
+import com.vungle.ads.internal.util.Logger;
+import java.util.concurrent.ExecutorService;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.serialization.json.JsonElement;
+import kotlinx.serialization.json.JsonElementBuildersKt;
+import kotlinx.serialization.json.JsonObject;
+import kotlinx.serialization.json.JsonObjectBuilder;
+
+/* loaded from: classes4.dex */
+public final class VungleWebClient extends WebViewClient implements WebViewAPI {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = "VungleWebClient";
+    private final AdPayload advertisement;
+    private boolean collectConsent;
+    private WebViewAPI.WebClientErrorHandler errorHandler;
+    private String gdprAccept;
+    private String gdprBody;
+    private String gdprDeny;
+    private String gdprTitle;
+    private Boolean isViewable;
+    private WebView loadedWebView;
+    private WebViewAPI.MraidDelegate mraidDelegate;
+    private final ExecutorService offloadExecutor;
+    private final Placement placement;
+    private final Platform platform;
+    private boolean ready;
+    private final SignalManager signalManager;
+    private WebViewObserver webViewObserver;
+
+    @VisibleForTesting
+    public static /* synthetic */ void getCollectConsent$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getErrorHandler$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getGdprAccept$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getGdprBody$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getGdprDeny$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getGdprTitle$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getLoadedWebView$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getMraidDelegate$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getReady$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getWebViewObserver$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void isViewable$vungle_ads_release$annotations() {
+    }
+
+    public final boolean getCollectConsent$vungle_ads_release() {
+        return this.collectConsent;
+    }
+
+    public final WebViewAPI.WebClientErrorHandler getErrorHandler$vungle_ads_release() {
+        return this.errorHandler;
+    }
+
+    public final String getGdprAccept$vungle_ads_release() {
+        return this.gdprAccept;
+    }
+
+    public final String getGdprBody$vungle_ads_release() {
+        return this.gdprBody;
+    }
+
+    public final String getGdprDeny$vungle_ads_release() {
+        return this.gdprDeny;
+    }
+
+    public final String getGdprTitle$vungle_ads_release() {
+        return this.gdprTitle;
+    }
+
+    public final WebView getLoadedWebView$vungle_ads_release() {
+        return this.loadedWebView;
+    }
+
+    public final WebViewAPI.MraidDelegate getMraidDelegate$vungle_ads_release() {
+        return this.mraidDelegate;
+    }
+
+    public final boolean getReady$vungle_ads_release() {
+        return this.ready;
+    }
+
+    public final WebViewObserver getWebViewObserver$vungle_ads_release() {
+        return this.webViewObserver;
+    }
+
+    public final Boolean isViewable$vungle_ads_release() {
+        return this.isViewable;
+    }
+
+    public final void setCollectConsent$vungle_ads_release(boolean z) {
+        this.collectConsent = z;
+    }
+
+    @Override // com.vungle.ads.internal.ui.view.WebViewAPI
+    public void setConsentStatus(boolean z, String str, String str2, String str3, String str4) {
+        this.collectConsent = z;
+        this.gdprTitle = str;
+        this.gdprBody = str2;
+        this.gdprAccept = str3;
+        this.gdprDeny = str4;
+    }
+
+    @Override // com.vungle.ads.internal.ui.view.WebViewAPI
+    public void setErrorHandler(WebViewAPI.WebClientErrorHandler errorHandler) {
+        Intrinsics.checkNotNullParameter(errorHandler, "errorHandler");
+        this.errorHandler = errorHandler;
+    }
+
+    public final void setErrorHandler$vungle_ads_release(WebViewAPI.WebClientErrorHandler webClientErrorHandler) {
+        this.errorHandler = webClientErrorHandler;
+    }
+
+    public final void setGdprAccept$vungle_ads_release(String str) {
+        this.gdprAccept = str;
+    }
+
+    public final void setGdprBody$vungle_ads_release(String str) {
+        this.gdprBody = str;
+    }
+
+    public final void setGdprDeny$vungle_ads_release(String str) {
+        this.gdprDeny = str;
+    }
+
+    public final void setGdprTitle$vungle_ads_release(String str) {
+        this.gdprTitle = str;
+    }
+
+    public final void setLoadedWebView$vungle_ads_release(WebView webView) {
+        this.loadedWebView = webView;
+    }
+
+    @Override // com.vungle.ads.internal.ui.view.WebViewAPI
+    public void setMraidDelegate(WebViewAPI.MraidDelegate mraidDelegate) {
+        this.mraidDelegate = mraidDelegate;
+    }
+
+    public final void setMraidDelegate$vungle_ads_release(WebViewAPI.MraidDelegate mraidDelegate) {
+        this.mraidDelegate = mraidDelegate;
+    }
+
+    public final void setReady$vungle_ads_release(boolean z) {
+        this.ready = z;
+    }
+
+    public final void setViewable$vungle_ads_release(Boolean bool) {
+        this.isViewable = bool;
+    }
+
+    @Override // com.vungle.ads.internal.ui.view.WebViewAPI
+    public void setWebViewObserver(WebViewObserver webViewObserver) {
+        this.webViewObserver = webViewObserver;
+    }
+
+    public final void setWebViewObserver$vungle_ads_release(WebViewObserver webViewObserver) {
+        this.webViewObserver = webViewObserver;
+    }
+
+    public /* synthetic */ VungleWebClient(AdPayload adPayload, Placement placement, ExecutorService executorService, SignalManager signalManager, Platform platform, int i, DefaultConstructorMarker defaultConstructorMarker) {
+        this(adPayload, placement, executorService, (i & 8) != 0 ? null : signalManager, (i & 16) != 0 ? null : platform);
+    }
+
+    public VungleWebClient(AdPayload advertisement, Placement placement, ExecutorService offloadExecutor, SignalManager signalManager, Platform platform) {
+        Intrinsics.checkNotNullParameter(advertisement, "advertisement");
+        Intrinsics.checkNotNullParameter(placement, "placement");
+        Intrinsics.checkNotNullParameter(offloadExecutor, "offloadExecutor");
+        this.advertisement = advertisement;
+        this.placement = placement;
+        this.offloadExecutor = offloadExecutor;
+        this.signalManager = signalManager;
+        this.platform = platform;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:32:0x00c8, code lost:
+    
+        if (r4 != false) goto L35;
+     */
+    @Override // android.webkit.WebViewClient
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public boolean shouldOverrideUrlLoading(final android.webkit.WebView r11, java.lang.String r12) {
+        /*
+            Method dump skipped, instructions count: 255
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.vungle.ads.internal.ui.VungleWebClient.shouldOverrideUrlLoading(android.webkit.WebView, java.lang.String):boolean");
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: shouldOverrideUrlLoading$lambda-4$lambda-3$lambda-2, reason: not valid java name */
+    public static final void m3982shouldOverrideUrlLoading$lambda4$lambda3$lambda2(WebViewAPI.MraidDelegate it, String command, JsonObject args, Handler handler, final VungleWebClient this$0, final WebView webView) {
+        Intrinsics.checkNotNullParameter(it, "$it");
+        Intrinsics.checkNotNullParameter(command, "$command");
+        Intrinsics.checkNotNullParameter(args, "$args");
+        Intrinsics.checkNotNullParameter(handler, "$handler");
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        if (it.processCommand(command, args)) {
+            handler.post(new Runnable() { // from class: com.vungle.ads.internal.ui.VungleWebClient$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    VungleWebClient.m3983shouldOverrideUrlLoading$lambda4$lambda3$lambda2$lambda1(VungleWebClient.this, webView);
+                }
+            });
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: shouldOverrideUrlLoading$lambda-4$lambda-3$lambda-2$lambda-1, reason: not valid java name */
+    public static final void m3983shouldOverrideUrlLoading$lambda4$lambda3$lambda2$lambda1(VungleWebClient this$0, WebView webView) {
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        this$0.runJavascriptOnWebView(webView, "window.vungle.mraidBridge.notifyCommandComplete()");
+    }
+
+    @Override // android.webkit.WebViewClient
+    public void onPageFinished(WebView webView, String str) {
+        super.onPageFinished(webView, str);
+        if (webView == null) {
+            return;
+        }
+        this.loadedWebView = webView;
+        webView.setVisibility(0);
+        notifyPropertiesChange(true);
+        if (Build.VERSION.SDK_INT >= 29) {
+            webView.setWebViewRenderProcessClient(VungleWebClient$$ExternalSyntheticApiModelOutline0.m(new VungleWebViewRenderProcessClient(this.errorHandler)));
+        }
+        WebViewObserver webViewObserver = this.webViewObserver;
+        if (webViewObserver != null) {
+            webViewObserver.onPageFinished(webView);
+        }
+    }
+
+    public final void notifyDiskAvailableSize(long j) {
+        WebView webView = this.loadedWebView;
+        if (webView != null) {
+            runJavascriptOnWebView(webView, "window.vungle.mraidBridgeExt.notifyAvailableDiskSpace(" + j + ')');
+        }
+    }
+
+    @Override // com.vungle.ads.internal.ui.view.WebViewAPI
+    public void setAdVisibility(boolean z) {
+        this.isViewable = Boolean.valueOf(z);
+        notifyPropertiesChange(false);
+    }
+
+    @Override // android.webkit.WebViewClient
+    public void onReceivedError(WebView webView, int i, String description, String failingUrl) {
+        Intrinsics.checkNotNullParameter(description, "description");
+        Intrinsics.checkNotNullParameter(failingUrl, "failingUrl");
+        super.onReceivedError(webView, i, description, failingUrl);
+    }
+
+    @Override // android.webkit.WebViewClient
+    public void onReceivedHttpError(WebView webView, WebResourceRequest webResourceRequest, WebResourceResponse webResourceResponse) {
+        super.onReceivedHttpError(webView, webResourceRequest, webResourceResponse);
+        String valueOf = String.valueOf(webResourceResponse != null ? Integer.valueOf(webResourceResponse.getStatusCode()) : null);
+        String valueOf2 = String.valueOf(webResourceRequest != null ? webResourceRequest.getUrl() : null);
+        boolean z = false;
+        boolean z2 = webResourceRequest != null && webResourceRequest.isForMainFrame();
+        Logger.Companion.e(TAG, "Http Error desc " + valueOf + ' ' + z2 + " for URL " + valueOf2);
+        if (isCriticalAsset(valueOf2) && z2) {
+            z = true;
+        }
+        handleWebViewError(valueOf, valueOf2, z);
+    }
+
+    @Override // android.webkit.WebViewClient
+    public void onReceivedError(WebView webView, WebResourceRequest webResourceRequest, WebResourceError webResourceError) {
+        super.onReceivedError(webView, webResourceRequest, webResourceError);
+        String valueOf = String.valueOf(webResourceError != null ? webResourceError.getDescription() : null);
+        String valueOf2 = String.valueOf(webResourceRequest != null ? webResourceRequest.getUrl() : null);
+        boolean z = false;
+        boolean z2 = webResourceRequest != null && webResourceRequest.isForMainFrame();
+        Logger.Companion.e(TAG, "Error desc " + valueOf + ' ' + z2 + " for URL " + valueOf2);
+        if (isCriticalAsset(valueOf2) && z2) {
+            z = true;
+        }
+        handleWebViewError(valueOf, valueOf2, z);
+    }
+
+    @Override // android.webkit.WebViewClient
+    public boolean onRenderProcessGone(WebView webView, RenderProcessGoneDetail renderProcessGoneDetail) {
+        this.loadedWebView = null;
+        Logger.Companion companion = Logger.Companion;
+        StringBuilder sb = new StringBuilder();
+        sb.append("onRenderProcessGone url: ");
+        sb.append(webView != null ? webView.getUrl() : null);
+        sb.append(", did crash: ");
+        sb.append(renderProcessGoneDetail != null ? Boolean.valueOf(renderProcessGoneDetail.didCrash()) : null);
+        companion.w(TAG, sb.toString());
+        WebViewAPI.WebClientErrorHandler webClientErrorHandler = this.errorHandler;
+        if (webClientErrorHandler != null) {
+            return webClientErrorHandler.onWebRenderingProcessGone(webView, renderProcessGoneDetail != null ? Boolean.valueOf(renderProcessGoneDetail.didCrash()) : null);
+        }
+        return super.onRenderProcessGone(webView, renderProcessGoneDetail);
+    }
+
+    private final void handleWebViewError(String str, String str2, boolean z) {
+        String str3 = str2 + ' ' + str;
+        WebViewAPI.WebClientErrorHandler webClientErrorHandler = this.errorHandler;
+        if (webClientErrorHandler != null) {
+            webClientErrorHandler.onReceivedError(str3, z);
+        }
+    }
+
+    private final boolean isCriticalAsset(String str) {
+        if (str.length() > 0) {
+            return this.advertisement.isCriticalAsset(str);
+        }
+        return false;
+    }
+
+    private final void runJavascriptOnWebView(WebView webView, String str) {
+        if (webView != null) {
+            try {
+                if (!webView.isAttachedToWindow()) {
+                    return;
+                }
+            } catch (Throwable th) {
+                AnalyticsClient.INSTANCE.logError$vungle_ads_release(313, "Evaluate js failed " + th.getLocalizedMessage(), this.placement.getReferenceId(), this.advertisement.getCreativeId(), this.advertisement.eventId());
+                return;
+            }
+        }
+        Logger.Companion.w(TAG, "mraid Injecting JS " + str);
+        if (webView != null) {
+            webView.evaluateJavascript(str, null);
+        }
+    }
+
+    @RequiresApi(29)
+    public static final class VungleWebViewRenderProcessClient extends WebViewRenderProcessClient {
+        private WebViewAPI.WebClientErrorHandler errorHandler;
+
+        public final WebViewAPI.WebClientErrorHandler getErrorHandler() {
+            return this.errorHandler;
+        }
+
+        public void onRenderProcessResponsive(WebView webView, WebViewRenderProcess webViewRenderProcess) {
+            Intrinsics.checkNotNullParameter(webView, "webView");
+        }
+
+        public final void setErrorHandler(WebViewAPI.WebClientErrorHandler webClientErrorHandler) {
+            this.errorHandler = webClientErrorHandler;
+        }
+
+        public VungleWebViewRenderProcessClient(WebViewAPI.WebClientErrorHandler webClientErrorHandler) {
+            this.errorHandler = webClientErrorHandler;
+        }
+
+        public void onRenderProcessUnresponsive(WebView webView, WebViewRenderProcess webViewRenderProcess) {
+            Intrinsics.checkNotNullParameter(webView, "webView");
+            Logger.Companion companion = Logger.Companion;
+            StringBuilder sb = new StringBuilder();
+            sb.append("onRenderProcessUnresponsive(Title = ");
+            sb.append(webView.getTitle());
+            sb.append(", URL = ");
+            sb.append(webView.getOriginalUrl());
+            sb.append(", (webViewRenderProcess != null) = ");
+            sb.append(webViewRenderProcess != null);
+            companion.w(VungleWebClient.TAG, sb.toString());
+            WebViewAPI.WebClientErrorHandler webClientErrorHandler = this.errorHandler;
+            if (webClientErrorHandler != null) {
+                webClientErrorHandler.onRenderProcessUnresponsive(webView, webViewRenderProcess);
+            }
+        }
+    }
+
+    @Override // com.vungle.ads.internal.ui.view.WebViewAPI
+    public void notifyPropertiesChange(boolean z) {
+        WebView webView = this.loadedWebView;
+        if (webView != null) {
+            JsonObjectBuilder jsonObjectBuilder = new JsonObjectBuilder();
+            JsonObjectBuilder jsonObjectBuilder2 = new JsonObjectBuilder();
+            JsonElementBuildersKt.put(jsonObjectBuilder2, "width", Integer.valueOf(webView.getWidth()));
+            JsonElementBuildersKt.put(jsonObjectBuilder2, "height", Integer.valueOf(webView.getHeight()));
+            JsonElement build = jsonObjectBuilder2.build();
+            JsonObjectBuilder jsonObjectBuilder3 = new JsonObjectBuilder();
+            JsonElementBuildersKt.put(jsonObjectBuilder3, "x", 0);
+            JsonElementBuildersKt.put(jsonObjectBuilder3, "y", 0);
+            JsonElementBuildersKt.put(jsonObjectBuilder3, "width", Integer.valueOf(webView.getWidth()));
+            JsonElementBuildersKt.put(jsonObjectBuilder3, "height", Integer.valueOf(webView.getHeight()));
+            JsonElement build2 = jsonObjectBuilder3.build();
+            JsonObjectBuilder jsonObjectBuilder4 = new JsonObjectBuilder();
+            Boolean bool = Boolean.FALSE;
+            JsonElementBuildersKt.put(jsonObjectBuilder4, "sms", bool);
+            JsonElementBuildersKt.put(jsonObjectBuilder4, "tel", bool);
+            JsonElementBuildersKt.put(jsonObjectBuilder4, "calendar", bool);
+            JsonElementBuildersKt.put(jsonObjectBuilder4, "storePicture", bool);
+            JsonElementBuildersKt.put(jsonObjectBuilder4, "inlineVideo", bool);
+            JsonElement build3 = jsonObjectBuilder4.build();
+            JsonElement jsonElement = build;
+            jsonObjectBuilder.put(SDKConstants.PARAM_CONTEXT_MAX_SIZE, jsonElement);
+            jsonObjectBuilder.put("screenSize", jsonElement);
+            JsonElement jsonElement2 = build2;
+            jsonObjectBuilder.put("defaultPosition", jsonElement2);
+            jsonObjectBuilder.put("currentPosition", jsonElement2);
+            jsonObjectBuilder.put("supports", build3);
+            JsonElementBuildersKt.put(jsonObjectBuilder, MRAIDCommunicatorUtil.KEY_PLACEMENTTYPE, this.advertisement.templateType());
+            Boolean bool2 = this.isViewable;
+            if (bool2 != null) {
+                JsonElementBuildersKt.put(jsonObjectBuilder, v8.h.o, Boolean.valueOf(bool2.booleanValue()));
+            }
+            JsonElementBuildersKt.put(jsonObjectBuilder, ad.y, "android");
+            JsonElementBuildersKt.put(jsonObjectBuilder, AnalyticsData.S_OS_VERSION, String.valueOf(Build.VERSION.SDK_INT));
+            JsonElementBuildersKt.put(jsonObjectBuilder, "incentivized", Boolean.valueOf(this.placement.isRewardedVideo()));
+            JsonElementBuildersKt.put(jsonObjectBuilder, "version", "1.0");
+            Platform platform = this.platform;
+            if (platform != null) {
+                JsonElementBuildersKt.put(jsonObjectBuilder, "isSilent", Boolean.valueOf(platform.isSilentModeEnabled()));
+            }
+            if (this.collectConsent) {
+                JsonElementBuildersKt.put(jsonObjectBuilder, "consentRequired", Boolean.TRUE);
+                JsonElementBuildersKt.put(jsonObjectBuilder, "consentTitleText", this.gdprTitle);
+                JsonElementBuildersKt.put(jsonObjectBuilder, "consentBodyText", this.gdprBody);
+                JsonElementBuildersKt.put(jsonObjectBuilder, "consentAcceptButtonText", this.gdprAccept);
+                JsonElementBuildersKt.put(jsonObjectBuilder, "consentDenyButtonText", this.gdprDeny);
+            } else {
+                JsonElementBuildersKt.put(jsonObjectBuilder, "consentRequired", bool);
+            }
+            if (!ConfigManager.INSTANCE.signalsDisabled()) {
+                SignalManager signalManager = this.signalManager;
+                String uuid = signalManager != null ? signalManager.getUuid() : null;
+                if (uuid != null && uuid.length() != 0) {
+                    SignalManager signalManager2 = this.signalManager;
+                    JsonElementBuildersKt.put(jsonObjectBuilder, "sessionId", signalManager2 != null ? signalManager2.getUuid() : null);
+                }
+            }
+            JsonElementBuildersKt.put(jsonObjectBuilder, "sdkVersion", BuildConfig.VERSION_NAME);
+            runJavascriptOnWebView(webView, "window.vungle.mraidBridge.notifyPropertiesChange(" + jsonObjectBuilder.build() + ',' + z + ')');
+        }
+    }
+
+    public final void notifySilentModeChange(boolean z) {
+        WebView webView = this.loadedWebView;
+        if (webView != null) {
+            JsonObjectBuilder jsonObjectBuilder = new JsonObjectBuilder();
+            JsonElementBuildersKt.put(jsonObjectBuilder, "isSilent", Boolean.valueOf(z));
+            runJavascriptOnWebView(webView, "window.vungle.mraidBridge.notifyPropertiesChange(" + jsonObjectBuilder.build() + ')');
+        }
+    }
+}

decompiled/sources/com/vungle/ads/internal/ui/WatermarkView.java

@@ -0,0 +1,28 @@
+package com.vungle.ads.internal.ui;
+
+import android.content.Context;
+import android.graphics.BitmapFactory;
+import android.graphics.Shader;
+import android.graphics.drawable.BitmapDrawable;
+import android.util.Base64;
+import android.widget.ImageView;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public class WatermarkView extends ImageView {
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public WatermarkView(Context context, String watermark) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        Intrinsics.checkNotNullParameter(watermark, "watermark");
+        byte[] overlayBytes = Base64.decode(watermark, 0);
+        Intrinsics.checkNotNullExpressionValue(overlayBytes, "overlayBytes");
+        BitmapDrawable bitmapDrawable = new BitmapDrawable(context.getResources(), BitmapFactory.decodeByteArray(overlayBytes, 0, overlayBytes.length));
+        Shader.TileMode tileMode = Shader.TileMode.REPEAT;
+        bitmapDrawable.setTileModeXY(tileMode, tileMode);
+        bitmapDrawable.setTargetDensity(context.getResources().getDisplayMetrics());
+        setBackground(bitmapDrawable);
+        setClickable(false);
+        setFocusable(false);
+    }
+}

decompiled/sources/com/vungle/ads/internal/ui/view/MRAIDAdWidget.java

@@ -0,0 +1,288 @@
+package com.vungle.ads.internal.ui.view;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Build;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.RelativeLayout;
+import androidx.annotation.VisibleForTesting;
+import com.vungle.ads.internal.util.HandlerScheduler;
+import com.vungle.ads.internal.util.Logger;
+import com.vungle.ads.internal.util.ViewUtility;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public final class MRAIDAdWidget extends RelativeLayout {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = "MRAIDAdWidget";
+    private CloseDelegate closeDelegate;
+    private OnViewTouchListener onViewTouchListener;
+    private OrientationDelegate orientationDelegate;
+    private final WebView webView;
+
+    public interface CloseDelegate {
+        void close();
+    }
+
+    public interface OnViewTouchListener {
+        boolean onTouch(MotionEvent motionEvent);
+    }
+
+    public interface OrientationDelegate {
+        void setOrientation(int i);
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getCloseDelegate$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getOnViewTouchListener$vungle_ads_release$annotations() {
+    }
+
+    @VisibleForTesting
+    public static /* synthetic */ void getOrientationDelegate$vungle_ads_release$annotations() {
+    }
+
+    public final CloseDelegate getCloseDelegate$vungle_ads_release() {
+        return this.closeDelegate;
+    }
+
+    public final OnViewTouchListener getOnViewTouchListener$vungle_ads_release() {
+        return this.onViewTouchListener;
+    }
+
+    public final OrientationDelegate getOrientationDelegate$vungle_ads_release() {
+        return this.orientationDelegate;
+    }
+
+    public final void setCloseDelegate(CloseDelegate closeDelegate) {
+        Intrinsics.checkNotNullParameter(closeDelegate, "closeDelegate");
+        this.closeDelegate = closeDelegate;
+    }
+
+    public final void setCloseDelegate$vungle_ads_release(CloseDelegate closeDelegate) {
+        this.closeDelegate = closeDelegate;
+    }
+
+    public final void setOnViewTouchListener(OnViewTouchListener onViewTouchListener) {
+        this.onViewTouchListener = onViewTouchListener;
+    }
+
+    public final void setOnViewTouchListener$vungle_ads_release(OnViewTouchListener onViewTouchListener) {
+        this.onViewTouchListener = onViewTouchListener;
+    }
+
+    public final void setOrientationDelegate(OrientationDelegate orientationDelegate) {
+        this.orientationDelegate = orientationDelegate;
+    }
+
+    public final void setOrientationDelegate$vungle_ads_release(OrientationDelegate orientationDelegate) {
+        this.orientationDelegate = orientationDelegate;
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public MRAIDAdWidget(Context context) throws InstantiationException {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        ViewGroup.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-1, -1);
+        setLayoutParams(layoutParams);
+        WebView webView = ViewUtility.INSTANCE.getWebView(context);
+        this.webView = webView;
+        webView.setLayoutParams(layoutParams);
+        webView.setTag("VungleWebView");
+        addView(webView, layoutParams);
+        bindListeners();
+        prepare();
+    }
+
+    @SuppressLint({"ClickableViewAccessibility"})
+    private final void bindListeners() {
+        this.webView.setOnTouchListener(new View.OnTouchListener() { // from class: com.vungle.ads.internal.ui.view.MRAIDAdWidget$$ExternalSyntheticLambda0
+            @Override // android.view.View.OnTouchListener
+            public final boolean onTouch(View view, MotionEvent motionEvent) {
+                boolean m3985bindListeners$lambda0;
+                m3985bindListeners$lambda0 = MRAIDAdWidget.m3985bindListeners$lambda0(MRAIDAdWidget.this, view, motionEvent);
+                return m3985bindListeners$lambda0;
+            }
+        });
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: bindListeners$lambda-0, reason: not valid java name */
+    public static final boolean m3985bindListeners$lambda0(MRAIDAdWidget this$0, View view, MotionEvent motionEvent) {
+        Intrinsics.checkNotNullParameter(this$0, "this$0");
+        OnViewTouchListener onViewTouchListener = this$0.onViewTouchListener;
+        if (onViewTouchListener != null) {
+            return onViewTouchListener.onTouch(motionEvent);
+        }
+        return false;
+    }
+
+    private final void prepare() {
+        WebView webView = this.webView;
+        webView.setLayerType(2, null);
+        webView.setBackgroundColor(0);
+        webView.getSettings().setMediaPlaybackRequiresUserGesture(false);
+        webView.setVisibility(8);
+    }
+
+    public final void close() {
+        CloseDelegate closeDelegate = this.closeDelegate;
+        if (closeDelegate != null) {
+            closeDelegate.close();
+        }
+    }
+
+    public final void setOrientation(int i) {
+        OrientationDelegate orientationDelegate = this.orientationDelegate;
+        if (orientationDelegate != null) {
+            orientationDelegate.setOrientation(i);
+        }
+    }
+
+    public final void linkWebView(WebViewClient vngWebViewClient) {
+        Intrinsics.checkNotNullParameter(vngWebViewClient, "vngWebViewClient");
+        WebView webView = this.webView;
+        applyDefault(webView);
+        webView.setWebViewClient(vngWebViewClient);
+    }
+
+    public final void showWebsite(String url) {
+        Intrinsics.checkNotNullParameter(url, "url");
+        Logger.Companion.d(TAG, "loadUrl: " + url);
+        WebView webView = this.webView;
+        webView.setVisibility(0);
+        webView.loadUrl(url);
+    }
+
+    private final void applyDefault(WebView webView) {
+        WebSettings settings = webView.getSettings();
+        Intrinsics.checkNotNullExpressionValue(settings, "webView.settings");
+        settings.setBuiltInZoomControls(false);
+        settings.setJavaScriptEnabled(true);
+        settings.setLoadWithOverviewMode(true);
+        settings.setSaveFormData(true);
+        settings.setUseWideViewPort(false);
+        settings.setAllowFileAccess(true);
+        settings.setAllowFileAccessFromFileURLs(true);
+        settings.setAllowUniversalAccessFromFileURLs(true);
+        webView.setVisibility(4);
+        settings.setMediaPlaybackRequiresUserGesture(false);
+    }
+
+    public final void pauseWeb() {
+        this.webView.onPause();
+    }
+
+    public final void resumeWeb() {
+        this.webView.onResume();
+    }
+
+    public final String getUrl() {
+        return this.webView.getUrl();
+    }
+
+    public final void destroyWebView(long j) {
+        WebView webView = this.webView;
+        webView.setWebChromeClient(null);
+        removeAllViews();
+        if (j <= 0) {
+            new DestroyRunnable(webView).run();
+        } else {
+            new HandlerScheduler().schedule(new DestroyRunnable(webView), j);
+        }
+    }
+
+    public static final class DestroyRunnable implements Runnable {
+        private final WebView webView;
+
+        public DestroyRunnable(WebView webView) {
+            Intrinsics.checkNotNullParameter(webView, "webView");
+            this.webView = webView;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            try {
+                this.webView.stopLoading();
+                if (Build.VERSION.SDK_INT >= 29) {
+                    this.webView.setWebViewRenderProcessClient(null);
+                }
+                this.webView.loadData("", null, null);
+                this.webView.destroy();
+            } catch (Throwable unused) {
+            }
+        }
+    }
+
+    @Override // android.view.ViewGroup, android.view.View
+    public void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        ViewGroup.LayoutParams layoutParams = getLayoutParams();
+        if (layoutParams != null) {
+            layoutParams.height = -1;
+            layoutParams.width = -1;
+        }
+        ViewGroup.LayoutParams layoutParams2 = this.webView.getLayoutParams();
+        if (layoutParams2 != null) {
+            layoutParams2.height = -1;
+            layoutParams2.width = -1;
+        }
+    }
+
+    public static final class AudioContextWrapper extends ContextWrapper {
+        public AudioContextWrapper(Context context) {
+            super(context);
+        }
+
+        @Override // android.content.ContextWrapper, android.content.Context
+        public Object getSystemService(String name) {
+            Object systemService;
+            Intrinsics.checkNotNullParameter(name, "name");
+            if (Intrinsics.areEqual("audio", name)) {
+                systemService = getApplicationContext().getSystemService(name);
+            } else {
+                systemService = super.getSystemService(name);
+            }
+            Intrinsics.checkNotNullExpressionValue(systemService, "if (AUDIO_SERVICE == nam…rvice(name)\n            }");
+            return systemService;
+        }
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface AdStopReason {
+        public static final Companion Companion = Companion.$$INSTANCE;
+        public static final int IS_AD_FINISHED_BY_API = 4;
+        public static final int IS_AD_FINISHING = 2;
+        public static final int IS_CHANGING_CONFIGURATION = 1;
+
+        public static final class Companion {
+            static final /* synthetic */ Companion $$INSTANCE = new Companion();
+            public static final int IS_AD_FINISHED_BY_API = 4;
+            public static final int IS_AD_FINISHING = 2;
+            public static final int IS_CHANGING_CONFIGURATION = 1;
+
+            private Companion() {
+            }
+        }
+    }
+}

decompiled/sources/com/vungle/ads/internal/ui/view/MediaView.java

@@ -0,0 +1,103 @@
+package com.vungle.ads.internal.ui.view;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public final class MediaView extends RelativeLayout {
+    private ImageView imageView;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public MediaView(Context context) {
+        super(context);
+        Intrinsics.checkNotNullParameter(context, "context");
+        initView(context);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public MediaView(Context context, AttributeSet attributeSet) {
+        super(context, attributeSet);
+        Intrinsics.checkNotNullParameter(context, "context");
+        initView(context);
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public MediaView(Context context, AttributeSet attributeSet, int i) {
+        super(context, attributeSet, i);
+        Intrinsics.checkNotNullParameter(context, "context");
+        initView(context);
+    }
+
+    private final void initView(Context context) {
+        this.imageView = new ImageView(context);
+        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(-1, -1);
+        layoutParams.addRule(13);
+        ImageView imageView = this.imageView;
+        ImageView imageView2 = null;
+        if (imageView == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("imageView");
+            imageView = null;
+        }
+        imageView.setLayoutParams(layoutParams);
+        ImageView imageView3 = this.imageView;
+        if (imageView3 == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("imageView");
+            imageView3 = null;
+        }
+        imageView3.setAdjustViewBounds(true);
+        ImageView imageView4 = this.imageView;
+        if (imageView4 == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("imageView");
+        } else {
+            imageView2 = imageView4;
+        }
+        addView(imageView2);
+        requestLayout();
+    }
+
+    public final ImageView getMainImage$vungle_ads_release() {
+        ImageView imageView = this.imageView;
+        if (imageView != null) {
+            return imageView;
+        }
+        Intrinsics.throwUninitializedPropertyAccessException("imageView");
+        return null;
+    }
+
+    public final void destroy() {
+        ImageView imageView = this.imageView;
+        ImageView imageView2 = null;
+        if (imageView == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("imageView");
+            imageView = null;
+        }
+        imageView.setImageDrawable(null);
+        ImageView imageView3 = this.imageView;
+        if (imageView3 == null) {
+            Intrinsics.throwUninitializedPropertyAccessException("imageView");
+            imageView3 = null;
+        }
+        if (imageView3.getParent() != null) {
+            ImageView imageView4 = this.imageView;
+            if (imageView4 == null) {
+                Intrinsics.throwUninitializedPropertyAccessException("imageView");
+                imageView4 = null;
+            }
+            ViewParent parent = imageView4.getParent();
+            Intrinsics.checkNotNull(parent, "null cannot be cast to non-null type android.view.ViewGroup");
+            ViewGroup viewGroup = (ViewGroup) parent;
+            ImageView imageView5 = this.imageView;
+            if (imageView5 == null) {
+                Intrinsics.throwUninitializedPropertyAccessException("imageView");
+            } else {
+                imageView2 = imageView5;
+            }
+            viewGroup.removeView(imageView2);
+        }
+    }
+}

decompiled/sources/com/vungle/ads/internal/ui/view/WebViewAPI.java

@@ -0,0 +1,34 @@
+package com.vungle.ads.internal.ui.view;
+
+import android.webkit.WebView;
+import android.webkit.WebViewRenderProcess;
+import com.vungle.ads.internal.omsdk.WebViewObserver;
+import kotlinx.serialization.json.JsonObject;
+
+/* loaded from: classes4.dex */
+public interface WebViewAPI {
+
+    public interface MraidDelegate {
+        boolean processCommand(String str, JsonObject jsonObject);
+    }
+
+    public interface WebClientErrorHandler {
+        void onReceivedError(String str, boolean z);
+
+        void onRenderProcessUnresponsive(WebView webView, WebViewRenderProcess webViewRenderProcess);
+
+        boolean onWebRenderingProcessGone(WebView webView, Boolean bool);
+    }
+
+    void notifyPropertiesChange(boolean z);
+
+    void setAdVisibility(boolean z);
+
+    void setConsentStatus(boolean z, String str, String str2, String str3, String str4);
+
+    void setErrorHandler(WebClientErrorHandler webClientErrorHandler);
+
+    void setMraidDelegate(MraidDelegate mraidDelegate);
+
+    void setWebViewObserver(WebViewObserver webViewObserver);
+}