package com.discord.stores;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.SharedPreferences;
import android.os.Build;
import android.os.Handler;
import android.os.PowerManager;
import c.a.q.i0;
import c.q.a.k.a;
import co.discord.media_engine.RtcRegion;
import co.discord.media_engine.VideoInputDeviceDescription;
import co.discord.media_engine.VideoInputDeviceFacing;
import com.airbnb.lottie.parser.AnimatableValueParser;
import com.discord.app.AppLog;
import com.discord.models.domain.ModelPayload;
import com.discord.models.domain.ModelRtcLatencyRegion;
import com.discord.rtcconnection.KrispOveruseDetector;
import com.discord.rtcconnection.LowMemoryDetector;
import com.discord.rtcconnection.mediaengine.MediaEngine;
import com.discord.rtcconnection.mediaengine.MediaEngineConnection;
import com.discord.stores.StoreMediaSettings;
import com.discord.utilities.collections.ListenerCollection;
import com.discord.utilities.collections.ListenerCollectionSubject;
import com.discord.utilities.lifecycle.ApplicationProvider;
import com.discord.utilities.persister.Persister;
import com.discord.utilities.rx.ObservableExtensionsKt;
import com.discord.utilities.rx.ObservableExtensionsKt$filterNull$1;
import com.discord.utilities.rx.ObservableExtensionsKt$filterNull$2;
import com.discord.utilities.systemlog.SystemLogUtils;
import com.hammerandchisel.libdiscord.Discord;
import d0.l;
import d0.t.j;
import d0.t.k;
import d0.t.o;
import d0.w.g.b;
import d0.w.g.c;
import d0.w.h.a.g;
import d0.z.d.m;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import kotlin.Unit;
import kotlin.coroutines.Continuation;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlinx.coroutines.CoroutineDispatcher;
import rx.Observable;
import rx.Subscription;
import rx.subjects.BehaviorSubject;
import rx.subjects.PublishSubject;
import rx.subjects.SerializedSubject;
import s.a.a.n;
import s.a.j0;
import s.a.w0;
/* compiled from: StoreMediaEngine.kt */
public final class StoreMediaEngine extends Store {
    public static final Companion Companion = new Companion(null);
    private static final MediaEngine.OpenSLESConfig DEFAULT_OPENSLES_CONFIG = MediaEngine.OpenSLESConfig.DEFAULT;
    private static final String DEFAULT_VIDEO_DEVICE_GUID = "";
    private static final MediaEngine.LocalVoiceStatus LOCAL_VOICE_STATUS_DEFAULT = new MediaEngine.LocalVoiceStatus(-100.0f, false);
    private final Dispatcher dispatcher;
    private boolean hasNativeEngineEverInitialized;
    private Persister<Boolean> hasNativeEngineEverInitializedCache;
    private final SerializedSubject<Boolean, Boolean> isNativeEngineInitializedSubject;
    private final ListenerCollectionSubject<Listener> listenerSubject;
    private final ListenerCollection<Listener> listeners;
    private final Observable<MediaEngine.LocalVoiceStatus> localVoiceStatus;
    private final SerializedSubject<MediaEngine.LocalVoiceStatus, MediaEngine.LocalVoiceStatus> localVoiceStatusSubject;
    private MediaEngine mediaEngine;
    private Subscription mediaEngineSettingsSubscription;
    private final StoreMediaSettings mediaSettingsStore;
    private final PublishSubject<KrispOveruseDetector.Status> onKrispStatusSubject;
    private final SerializedSubject<MediaEngine.OpenSLESConfig, MediaEngine.OpenSLESConfig> openSLESConfigSubject;
    private String preferredVideoInputDeviceGUID = "";
    private final Persister<String> preferredVideoInputDeviceGuidCache = new Persister<>("PREFERRED_VIDEO_INPUT_DEVICE_GUID", this.preferredVideoInputDeviceGUID);
    private Long previousVoiceChannelId;
    private final SerializedSubject<Boolean, Boolean> pttActiveSubject;
    private VideoInputDeviceDescription selectedVideoInputDevice;
    private final BehaviorSubject<VideoInputDeviceDescription> selectedVideoInputDeviceSubject = BehaviorSubject.l0(this.selectedVideoInputDevice);
    private final StoreStream storeStream;
    private long userId;
    private VideoInputDeviceDescription[] videoInputDevices;
    private final BehaviorSubject<List<VideoInputDeviceDescription>> videoInputDevicesSubject;

    /* compiled from: StoreMediaEngine.kt */
    public static final class Companion {
        private Companion() {
        }

        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }
    }

    /* compiled from: StoreMediaEngine.kt */
    public static abstract class DefaultListener implements Listener {
        @Override // com.discord.stores.StoreMediaEngine.Listener
        public void onConnected() {
        }

        @Override // com.discord.stores.StoreMediaEngine.Listener
        public void onConnecting() {
        }
    }

    /* compiled from: StoreMediaEngine.kt */
    public final class EngineListener implements MediaEngine.b {
        private long debugPrintableId = -1;
        private final LowMemoryDetector lowMemoryDetector = new LowMemoryDetector();

        public EngineListener() {
        }

        private final Context getContext() {
            return ApplicationProvider.INSTANCE.get();
        }

        @Override // com.discord.rtcconnection.mediaengine.MediaEngine.b
        public void onConnected() {
            StoreMediaEngine.access$getListenerSubject$p(StoreMediaEngine.this).notify(StoreMediaEngine$EngineListener$onConnected$1.INSTANCE);
        }

        @Override // com.discord.rtcconnection.mediaengine.MediaEngine.b
        public void onConnecting() {
            StoreMediaEngine.access$getListenerSubject$p(StoreMediaEngine.this).notify(StoreMediaEngine$EngineListener$onConnecting$1.INSTANCE);
        }

        public void onDestroy() {
            getContext().unregisterComponentCallbacks(this.lowMemoryDetector);
            if (Build.VERSION.SDK_INT >= 29) {
                i0 i0Var = i0.m;
                synchronized (i0Var) {
                    if (i0.j) {
                        AnimatableValueParser.D1("ThermalDetector", "unregister");
                        Object systemService = ApplicationProvider.INSTANCE.get().getSystemService("power");
                        Objects.requireNonNull(systemService, "null cannot be cast to non-null type android.os.PowerManager");
                        ((PowerManager) systemService).removeThermalStatusListener(i0Var);
                        i0.j = false;
                        i0.k = false;
                        if (i0.l) {
                            ((Handler) i0.i.getValue()).removeCallbacks(i0Var);
                            i0.l = false;
                        }
                    }
                }
                SystemLogUtils.INSTANCE.getDebugPrintables$app_productionBetaRelease().remove(this.debugPrintableId);
                this.debugPrintableId = -1;
            }
        }

        @Override // com.discord.rtcconnection.mediaengine.MediaEngine.b
        public void onNativeEngineInitialized() {
            getContext().registerComponentCallbacks(this.lowMemoryDetector);
            if (Build.VERSION.SDK_INT >= 29) {
                i0 i0Var = i0.m;
                synchronized (i0Var) {
                    if (!i0.j) {
                        AnimatableValueParser.D1("ThermalDetector", "register");
                        Object systemService = ApplicationProvider.INSTANCE.get().getSystemService("power");
                        Objects.requireNonNull(systemService, "null cannot be cast to non-null type android.os.PowerManager");
                        ((PowerManager) systemService).addThermalStatusListener(i0Var);
                        i0.j = true;
                    }
                }
                this.debugPrintableId = SystemLogUtils.INSTANCE.getDebugPrintables$app_productionBetaRelease().add(i0Var, "ThermalDetector");
            }
            StoreMediaEngine.access$handleNativeEngineInitialized(StoreMediaEngine.this);
        }

        @Override // com.discord.rtcconnection.mediaengine.MediaEngine.b
        public void onNewConnection(MediaEngineConnection mediaEngineConnection) {
            m.checkNotNullParameter(mediaEngineConnection, "connection");
            StoreMediaEngine.access$handleNewConnection(StoreMediaEngine.this, mediaEngineConnection);
        }
    }

    /* compiled from: StoreMediaEngine.kt */
    public interface Listener {
        void onConnected();

        void onConnecting();
    }

    public final /* synthetic */ class WhenMappings {
        public static final /* synthetic */ int[] $EnumSwitchMapping$0;
        public static final /* synthetic */ int[] $EnumSwitchMapping$1;

        static {
            KrispOveruseDetector.Status.values();
            int[] iArr = new int[3];
            $EnumSwitchMapping$0 = iArr;
            iArr[KrispOveruseDetector.Status.FAILED.ordinal()] = 1;
            iArr[KrispOveruseDetector.Status.CPU_OVERUSE.ordinal()] = 2;
            iArr[KrispOveruseDetector.Status.VAD_CPU_OVERUSE.ordinal()] = 3;
            MediaEngineConnection.Type.values();
            int[] iArr2 = new int[2];
            $EnumSwitchMapping$1 = iArr2;
            iArr2[MediaEngineConnection.Type.DEFAULT.ordinal()] = 1;
            iArr2[MediaEngineConnection.Type.STREAM.ordinal()] = 2;
        }
    }

    public StoreMediaEngine(StoreMediaSettings storeMediaSettings, StoreStream storeStream, Dispatcher dispatcher) {
        m.checkNotNullParameter(storeMediaSettings, "mediaSettingsStore");
        m.checkNotNullParameter(storeStream, "storeStream");
        m.checkNotNullParameter(dispatcher, "dispatcher");
        this.mediaSettingsStore = storeMediaSettings;
        this.storeStream = storeStream;
        this.dispatcher = dispatcher;
        ListenerCollectionSubject<Listener> listenerCollectionSubject = new ListenerCollectionSubject<>();
        this.listenerSubject = listenerCollectionSubject;
        this.listeners = listenerCollectionSubject;
        SerializedSubject<MediaEngine.LocalVoiceStatus, MediaEngine.LocalVoiceStatus> serializedSubject = new SerializedSubject<>(BehaviorSubject.l0(LOCAL_VOICE_STATUS_DEFAULT));
        this.localVoiceStatusSubject = serializedSubject;
        Boolean bool = Boolean.FALSE;
        this.pttActiveSubject = new SerializedSubject<>(BehaviorSubject.l0(bool));
        VideoInputDeviceDescription[] videoInputDeviceDescriptionArr = new VideoInputDeviceDescription[0];
        this.videoInputDevices = videoInputDeviceDescriptionArr;
        this.videoInputDevicesSubject = BehaviorSubject.l0(j.asList(videoInputDeviceDescriptionArr));
        this.openSLESConfigSubject = new SerializedSubject<>(BehaviorSubject.k0());
        this.isNativeEngineInitializedSubject = new SerializedSubject<>(BehaviorSubject.l0(bool));
        this.userId = -1;
        this.hasNativeEngineEverInitializedCache = new Persister<>("CACHE_KEY_NATIVE_ENGINE_EVER_INITIALIZED", Boolean.valueOf(this.hasNativeEngineEverInitialized));
        this.onKrispStatusSubject = PublishSubject.k0();
        Observable<MediaEngine.LocalVoiceStatus> Q = ObservableExtensionsKt.computationLatest(serializedSubject).r().u(new StoreMediaEngine$sam$rx_functions_Action0$0(new StoreMediaEngine$localVoiceStatus$1(this))).v(new StoreMediaEngine$sam$rx_functions_Action0$0(new StoreMediaEngine$localVoiceStatus$2(this))).Q();
        m.checkNotNullExpressionValue(Q, "localVoiceStatusSubject\n…ening)\n          .share()");
        this.localVoiceStatus = Q;
    }

    public static final /* synthetic */ void access$disableLocalVoiceStatusListening(StoreMediaEngine storeMediaEngine) {
        storeMediaEngine.disableLocalVoiceStatusListening();
    }

    public static final /* synthetic */ void access$enableLocalVoiceStatusListening(StoreMediaEngine storeMediaEngine) {
        storeMediaEngine.enableLocalVoiceStatusListening();
    }

    public static final /* synthetic */ Dispatcher access$getDispatcher$p(StoreMediaEngine storeMediaEngine) {
        return storeMediaEngine.dispatcher;
    }

    public static final /* synthetic */ ListenerCollectionSubject access$getListenerSubject$p(StoreMediaEngine storeMediaEngine) {
        return storeMediaEngine.listenerSubject;
    }

    public static final /* synthetic */ MediaEngine access$getMediaEngine$p(StoreMediaEngine storeMediaEngine) {
        MediaEngine mediaEngine = storeMediaEngine.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        return mediaEngine;
    }

    public static final /* synthetic */ Subscription access$getMediaEngineSettingsSubscription$p(StoreMediaEngine storeMediaEngine) {
        return storeMediaEngine.mediaEngineSettingsSubscription;
    }

    public static final /* synthetic */ StoreMediaSettings access$getMediaSettingsStore$p(StoreMediaEngine storeMediaEngine) {
        return storeMediaEngine.mediaSettingsStore;
    }

    public static final /* synthetic */ PublishSubject access$getOnKrispStatusSubject$p(StoreMediaEngine storeMediaEngine) {
        return storeMediaEngine.onKrispStatusSubject;
    }

    public static final /* synthetic */ VideoInputDeviceDescription access$getSelectedVideoInputDevice$p(StoreMediaEngine storeMediaEngine) {
        return storeMediaEngine.selectedVideoInputDevice;
    }

    public static final /* synthetic */ void access$getVideoInputDevicesNative(StoreMediaEngine storeMediaEngine, Function1 function1) {
        storeMediaEngine.getVideoInputDevicesNative(function1);
    }

    public static final /* synthetic */ void access$handleNativeEngineInitialized(StoreMediaEngine storeMediaEngine) {
        storeMediaEngine.handleNativeEngineInitialized();
    }

    public static final /* synthetic */ void access$handleNewConnection(StoreMediaEngine storeMediaEngine, MediaEngineConnection mediaEngineConnection) {
        storeMediaEngine.handleNewConnection(mediaEngineConnection);
    }

    public static final /* synthetic */ void access$handleVideoInputDevices(StoreMediaEngine storeMediaEngine, VideoInputDeviceDescription[] videoInputDeviceDescriptionArr, String str, Function1 function1) {
        storeMediaEngine.handleVideoInputDevices(videoInputDeviceDescriptionArr, str, function1);
    }

    public static final /* synthetic */ void access$handleVoiceConfigChanged(StoreMediaEngine storeMediaEngine, StoreMediaSettings.VoiceConfiguration voiceConfiguration) {
        storeMediaEngine.handleVoiceConfigChanged(voiceConfiguration);
    }

    public static final /* synthetic */ String access$pickDefaultDeviceGUID(StoreMediaEngine storeMediaEngine, VideoInputDeviceDescription[] videoInputDeviceDescriptionArr) {
        return storeMediaEngine.pickDefaultDeviceGUID(videoInputDeviceDescriptionArr);
    }

    public static final /* synthetic */ void access$restartLocalMicrophone(StoreMediaEngine storeMediaEngine) {
        storeMediaEngine.restartLocalMicrophone();
    }

    public static final /* synthetic */ void access$setMediaEngine$p(StoreMediaEngine storeMediaEngine, MediaEngine mediaEngine) {
        storeMediaEngine.mediaEngine = mediaEngine;
    }

    public static final /* synthetic */ void access$setMediaEngineSettingsSubscription$p(StoreMediaEngine storeMediaEngine, Subscription subscription) {
        storeMediaEngine.mediaEngineSettingsSubscription = subscription;
    }

    public static final /* synthetic */ void access$setSelectedVideoInputDevice$p(StoreMediaEngine storeMediaEngine, VideoInputDeviceDescription videoInputDeviceDescription) {
        storeMediaEngine.selectedVideoInputDevice = videoInputDeviceDescription;
    }

    private final synchronized void disableLocalVoiceStatusListening() {
        MediaEngine mediaEngine = this.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        mediaEngine.l(null);
    }

    private final synchronized void enableLocalVoiceStatusListening() {
        MediaEngine mediaEngine = this.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        mediaEngine.l(new StoreMediaEngine$enableLocalVoiceStatusListening$1(this.localVoiceStatusSubject));
    }

    private final synchronized void getVideoInputDevicesNative(Function1<? super VideoInputDeviceDescription[], Unit> function1) {
        MediaEngine mediaEngine = this.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        mediaEngine.j(new StoreMediaEngine$getVideoInputDevicesNative$1(function1));
    }

    private final synchronized void handleNativeEngineInitialized() {
        this.hasNativeEngineEverInitialized = true;
        Persister<Boolean> persister = this.hasNativeEngineEverInitializedCache;
        Boolean bool = Boolean.TRUE;
        persister.set(bool, true);
        this.isNativeEngineInitializedSubject.j.onNext(bool);
    }

    private final synchronized void handleNewConnection(MediaEngineConnection mediaEngineConnection) {
        setupMediaEngineSettingsSubscription();
        mediaEngineConnection.l(new StoreMediaEngine$handleNewConnection$1(this));
        getVideoInputDevicesNative(new StoreMediaEngine$handleNewConnection$2(this));
    }

    private final synchronized void handleVideoInputDevices(VideoInputDeviceDescription[] videoInputDeviceDescriptionArr, String str, Function1<? super String, Unit> function1) {
        String str2;
        int length = videoInputDeviceDescriptionArr.length;
        int i = 0;
        while (true) {
            if (i >= length) {
                i = -1;
                break;
            } else if (m.areEqual(videoInputDeviceDescriptionArr[i].getGuid(), str)) {
                break;
            } else {
                i++;
            }
        }
        boolean z2 = i >= 0;
        MediaEngine mediaEngine = this.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        mediaEngine.f(-1);
        MediaEngine mediaEngine2 = this.mediaEngine;
        if (mediaEngine2 == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        mediaEngine2.f(i);
        MediaEngine mediaEngine3 = this.mediaEngine;
        if (mediaEngine3 == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        for (MediaEngineConnection mediaEngineConnection : mediaEngine3.getConnections()) {
            if (mediaEngineConnection.getType().ordinal() == 0) {
                mediaEngineConnection.j(z2);
            }
        }
        if (function1 != null) {
            if (!z2) {
                str = null;
            }
            function1.invoke(str);
        }
        updateSelectedVideoInputDevice(z2 ? videoInputDeviceDescriptionArr[i] : null);
        this.videoInputDevices = videoInputDeviceDescriptionArr;
        this.videoInputDevicesSubject.onNext(j.asList(videoInputDeviceDescriptionArr));
        VideoInputDeviceDescription videoInputDeviceDescription = this.selectedVideoInputDevice;
        if (videoInputDeviceDescription != null) {
            if (videoInputDeviceDescription == null || (str2 = videoInputDeviceDescription.getGuid()) == null) {
                str2 = "";
            }
            this.preferredVideoInputDeviceGUID = str2;
            String str3 = (String) Persister.set$default(this.preferredVideoInputDeviceGuidCache, str2, false, 2, null);
        }
    }

    /* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.stores.StoreMediaEngine */
    /* JADX WARN: Multi-variable type inference failed */
    public static /* synthetic */ void handleVideoInputDevices$default(StoreMediaEngine storeMediaEngine, VideoInputDeviceDescription[] videoInputDeviceDescriptionArr, String str, Function1 function1, int i, Object obj) {
        if ((i & 4) != 0) {
            function1 = null;
        }
        storeMediaEngine.handleVideoInputDevices(videoInputDeviceDescriptionArr, str, function1);
    }

    @StoreThread
    private final synchronized void handleVoiceConfigChanged(StoreMediaSettings.VoiceConfiguration voiceConfiguration) {
        if (voiceConfiguration != null) {
            MediaEngine mediaEngine = this.mediaEngine;
            if (mediaEngine == null) {
                m.throwUninitializedPropertyAccessException("mediaEngine");
            }
            mediaEngine.d(voiceConfiguration.toMediaEngineVoiceConfig());
        }
    }

    private final String pickDefaultDeviceGUID(VideoInputDeviceDescription[] videoInputDeviceDescriptionArr) {
        boolean z2;
        VideoInputDeviceDescription videoInputDeviceDescription;
        int length = videoInputDeviceDescriptionArr.length;
        int i = 0;
        while (true) {
            if (i >= length) {
                z2 = false;
                break;
            } else if (m.areEqual(videoInputDeviceDescriptionArr[i].getGuid(), this.preferredVideoInputDeviceGUID)) {
                z2 = true;
                break;
            } else {
                i++;
            }
        }
        if (z2) {
            return this.preferredVideoInputDeviceGUID;
        }
        int length2 = videoInputDeviceDescriptionArr.length;
        int i2 = 0;
        while (true) {
            if (i2 >= length2) {
                videoInputDeviceDescription = null;
                break;
            }
            videoInputDeviceDescription = videoInputDeviceDescriptionArr[i2];
            if (videoInputDeviceDescription.getFacing() == VideoInputDeviceFacing.Front) {
                break;
            }
            i2++;
        }
        if (videoInputDeviceDescription == null) {
            videoInputDeviceDescription = (VideoInputDeviceDescription) k.firstOrNull(videoInputDeviceDescriptionArr);
        }
        if (videoInputDeviceDescription != null) {
            return videoInputDeviceDescription.getGuid();
        }
        return null;
    }

    private final synchronized void restartLocalMicrophone() {
        enableLocalVoiceStatusListening();
        disableLocalVoiceStatusListening();
    }

    /* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.stores.StoreMediaEngine */
    /* JADX WARN: Multi-variable type inference failed */
    public static /* synthetic */ void selectDefaultVideoDevice$default(StoreMediaEngine storeMediaEngine, Function1 function1, int i, Object obj) {
        if ((i & 1) != 0) {
            function1 = null;
        }
        storeMediaEngine.selectDefaultVideoDevice(function1);
    }

    private final synchronized void setupMediaEngineSettingsSubscription() {
        Subscription subscription = this.mediaEngineSettingsSubscription;
        if (subscription != null) {
            subscription.unsubscribe();
        }
        Observable<StoreMediaSettings.VoiceConfiguration> voiceConfig = this.mediaSettingsStore.getVoiceConfig();
        Class<?> cls = getClass();
        StoreMediaEngine$setupMediaEngineSettingsSubscription$1 storeMediaEngine$setupMediaEngineSettingsSubscription$1 = new StoreMediaEngine$setupMediaEngineSettingsSubscription$1(this);
        ObservableExtensionsKt.appSubscribe$default(voiceConfig, cls, (Context) null, new StoreMediaEngine$setupMediaEngineSettingsSubscription$3(this), StoreMediaEngine$setupMediaEngineSettingsSubscription$2.INSTANCE, (Function0) null, (Function0) null, storeMediaEngine$setupMediaEngineSettingsSubscription$1, 50, (Object) null);
    }

    private final synchronized void updateSelectedVideoInputDevice(VideoInputDeviceDescription videoInputDeviceDescription) {
        this.selectedVideoInputDevice = videoInputDeviceDescription;
        this.selectedVideoInputDeviceSubject.onNext(videoInputDeviceDescription);
        this.storeStream.handleVideoInputDeviceSelected(videoInputDeviceDescription);
    }

    public final synchronized void cycleVideoInputDevice() {
        int indexOf = k.indexOf(this.videoInputDevices, this.selectedVideoInputDevice);
        if (indexOf >= 0) {
            selectVideoInputDevice(this.videoInputDevices[indexOf == k.getLastIndex(this.videoInputDevices) ? 0 : indexOf + 1].getGuid());
        }
    }

    /* JADX WARNING: Removed duplicated region for block: B:12:0x0035  */
    /* JADX WARNING: Removed duplicated region for block: B:8:0x0023  */
    public final Object getDefaultVideoDeviceGUID(Continuation<? super String> continuation) {
        StoreMediaEngine$getDefaultVideoDeviceGUID$1 storeMediaEngine$getDefaultVideoDeviceGUID$1;
        int i;
        StoreMediaEngine storeMediaEngine;
        if (continuation instanceof StoreMediaEngine$getDefaultVideoDeviceGUID$1) {
            storeMediaEngine$getDefaultVideoDeviceGUID$1 = (StoreMediaEngine$getDefaultVideoDeviceGUID$1) continuation;
            int i2 = storeMediaEngine$getDefaultVideoDeviceGUID$1.label;
            if ((i2 & Integer.MIN_VALUE) != 0) {
                storeMediaEngine$getDefaultVideoDeviceGUID$1.label = i2 - Integer.MIN_VALUE;
                Object obj = storeMediaEngine$getDefaultVideoDeviceGUID$1.result;
                Object coroutine_suspended = c.getCOROUTINE_SUSPENDED();
                i = storeMediaEngine$getDefaultVideoDeviceGUID$1.label;
                if (i != 0) {
                    l.throwOnFailure(obj);
                    storeMediaEngine$getDefaultVideoDeviceGUID$1.L$0 = this;
                    storeMediaEngine$getDefaultVideoDeviceGUID$1.label = 1;
                    obj = getVideoInputDevicesNativeAsync(storeMediaEngine$getDefaultVideoDeviceGUID$1);
                    if (obj == coroutine_suspended) {
                        return coroutine_suspended;
                    }
                    storeMediaEngine = this;
                } else if (i == 1) {
                    storeMediaEngine = (StoreMediaEngine) storeMediaEngine$getDefaultVideoDeviceGUID$1.L$0;
                    l.throwOnFailure(obj);
                } else {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                return storeMediaEngine.pickDefaultDeviceGUID((VideoInputDeviceDescription[]) obj);
            }
        }
        storeMediaEngine$getDefaultVideoDeviceGUID$1 = new StoreMediaEngine$getDefaultVideoDeviceGUID$1(this, continuation);
        Object obj = storeMediaEngine$getDefaultVideoDeviceGUID$1.result;
        Object coroutine_suspended = c.getCOROUTINE_SUSPENDED();
        i = storeMediaEngine$getDefaultVideoDeviceGUID$1.label;
        if (i != 0) {
        }
        return storeMediaEngine.pickDefaultDeviceGUID((VideoInputDeviceDescription[]) obj);
    }

    public final Observable<Boolean> getIsNativeEngineInitialized() {
        return this.isNativeEngineInitializedSubject;
    }

    public final ListenerCollection<Listener> getListeners() {
        return this.listeners;
    }

    public final Observable<MediaEngine.LocalVoiceStatus> getLocalVoiceStatus() {
        return this.localVoiceStatus;
    }

    public final MediaEngine getMediaEngine() {
        MediaEngine mediaEngine = this.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        return mediaEngine;
    }

    public final Observable<MediaEngine.OpenSLESConfig> getOpenSLESConfig() {
        return this.openSLESConfigSubject;
    }

    public final synchronized void getRankedRtcRegions(List<ModelRtcLatencyRegion> list, Function1<? super List<String>, Unit> function1) {
        m.checkNotNullParameter(list, "regionsWithIps");
        m.checkNotNullParameter(function1, "callback");
        ArrayList arrayList = new ArrayList(o.collectionSizeOrDefault(list, 10));
        for (ModelRtcLatencyRegion modelRtcLatencyRegion : list) {
            String region = modelRtcLatencyRegion.getRegion();
            Object[] array = modelRtcLatencyRegion.getIps().toArray(new String[0]);
            if (array != null) {
                arrayList.add(new RtcRegion(region, (String[]) array));
            } else {
                throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
            }
        }
        Object[] array2 = arrayList.toArray(new RtcRegion[0]);
        if (array2 != null) {
            RtcRegion[] rtcRegionArr = (RtcRegion[]) array2;
            MediaEngine mediaEngine = this.mediaEngine;
            if (mediaEngine == null) {
                m.throwUninitializedPropertyAccessException("mediaEngine");
            }
            mediaEngine.b(rtcRegionArr, new StoreMediaEngine$getRankedRtcRegions$1(function1));
        } else {
            throw new NullPointerException("null cannot be cast to non-null type kotlin.Array<T>");
        }
    }

    public final Observable<VideoInputDeviceDescription> getSelectedVideoInputDevice() {
        Observable<VideoInputDeviceDescription> r = this.selectedVideoInputDeviceSubject.r();
        m.checkNotNullExpressionValue(r, "selectedVideoInputDevice…  .distinctUntilChanged()");
        return r;
    }

    public final VideoInputDeviceDescription getSelectedVideoInputDeviceBlocking() {
        return this.selectedVideoInputDevice;
    }

    public final Observable<List<VideoInputDeviceDescription>> getVideoInputDevices() {
        Observable<List<VideoInputDeviceDescription>> r = this.videoInputDevicesSubject.r();
        m.checkNotNullExpressionValue(r, "videoInputDevicesSubject…  .distinctUntilChanged()");
        return r;
    }

    public final Object getVideoInputDevicesNativeAsync(Continuation<? super VideoInputDeviceDescription[]> continuation) {
        s.a.k kVar = new s.a.k(b.intercepted(continuation), 1);
        kVar.A();
        access$getVideoInputDevicesNative(this, new StoreMediaEngine$getVideoInputDevicesNativeAsync$2$1(kVar));
        Object u = kVar.u();
        if (u == c.getCOROUTINE_SUSPENDED()) {
            g.probeCoroutineSuspended(continuation);
        }
        return u;
    }

    public final synchronized Discord getVoiceEngineNative() {
        MediaEngine mediaEngine;
        mediaEngine = this.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        return mediaEngine.i();
    }

    public final synchronized void handleConnectionOpen(ModelPayload modelPayload) {
        m.checkNotNullParameter(modelPayload, "payload");
        this.userId = modelPayload.getMe().i();
    }

    public final void handleMicrophonePermissionGranted() {
        Observable<Boolean> Z = this.isNativeEngineInitializedSubject.Z(1);
        m.checkNotNullExpressionValue(Z, "isNativeEngineInitializedSubject\n        .take(1)");
        ObservableExtensionsKt.appSubscribe$default(Z, StoreMediaEngine.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreMediaEngine$handleMicrophonePermissionGranted$1(this), 62, (Object) null);
    }

    /* JADX WARNING: Code restructure failed: missing block: B:8:0x0010, code lost:
        if (r0.longValue() != 0) goto L_0x0012;
     */
    public final synchronized void handleVoiceChannelSelected(long j) {
        Long l = this.previousVoiceChannelId;
        if (l != null) {
            if (l == null) {
            }
            if (j == 0) {
                getVideoInputDevicesNative(new StoreMediaEngine$handleVoiceChannelSelected$1(this));
            }
        }
        this.previousVoiceChannelId = Long.valueOf(j);
    }

    public final synchronized boolean hasNativeEngineEverInitialized() {
        return this.hasNativeEngineEverInitialized;
    }

    @Override // com.discord.stores.Store
    public void init(Context context) {
        m.checkNotNullParameter(context, "context");
        super.init(context);
        this.preferredVideoInputDeviceGUID = this.preferredVideoInputDeviceGuidCache.get();
        this.hasNativeEngineEverInitialized = this.hasNativeEngineEverInitializedCache.get().booleanValue();
        SharedPreferences prefsSessionDurable = getPrefsSessionDurable();
        MediaEngine.OpenSLESConfig openSLESConfig = DEFAULT_OPENSLES_CONFIG;
        String string = prefsSessionDurable.getString("OPEN_SLES", openSLESConfig.name());
        if (string == null) {
            string = openSLESConfig.name();
        }
        m.checkNotNullExpressionValue(string, "prefsSessionDurable\n    …AULT_OPENSLES_CONFIG.name");
        MediaEngine.OpenSLESConfig valueOf = MediaEngine.OpenSLESConfig.valueOf(string);
        this.openSLESConfigSubject.j.onNext(valueOf);
        EngineListener engineListener = new EngineListener();
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        m.checkNotNullExpressionValue(newSingleThreadExecutor, "Executors.newSingleThreadExecutor()");
        AppLog appLog = AppLog.g;
        m.checkNotNullParameter(context, "context");
        m.checkNotNullParameter(engineListener, "listener");
        m.checkNotNullParameter(newSingleThreadExecutor, "singleThreadExecutorService");
        m.checkNotNullParameter(valueOf, "openSLESConfig");
        m.checkNotNullParameter(appLog, "logger");
        this.mediaEngine = new c.a.q.m0.c.k(context, engineListener, new c.a.q.c(newSingleThreadExecutor, false), valueOf, appLog, null, null, 96);
        Observable<R> F = this.storeStream.getExperiments$app_productionBetaRelease().observeUserExperiment("2021-05_opensl_default_enable_android", true).x(ObservableExtensionsKt$filterNull$1.INSTANCE).F(ObservableExtensionsKt$filterNull$2.INSTANCE);
        m.checkNotNullExpressionValue(F, "filter { it != null }.map { it!! }");
        Observable Z = F.Z(1);
        m.checkNotNullExpressionValue(Z, "storeStream.experiments.…erNull()\n        .take(1)");
        ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.computationLatest(Z), StoreMediaEngine.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreMediaEngine$init$1(this), 62, (Object) null);
    }

    public final Observable<KrispOveruseDetector.Status> onKrispStatusEvent() {
        PublishSubject<KrispOveruseDetector.Status> publishSubject = this.onKrispStatusSubject;
        m.checkNotNullExpressionValue(publishSubject, "onKrispStatusSubject");
        return publishSubject;
    }

    public final void selectDefaultVideoDevice(Function1<? super String, Unit> function1) {
        w0 w0Var = w0.i;
        CoroutineDispatcher coroutineDispatcher = j0.a;
        a.G(w0Var, n.b.H(), null, new StoreMediaEngine$selectDefaultVideoDevice$1(this, function1, null), 2, null);
    }

    /* JADX WARNING: Removed duplicated region for block: B:12:0x0035  */
    /* JADX WARNING: Removed duplicated region for block: B:8:0x0023  */
    public final Object selectDefaultVideoDeviceAsync(Continuation<? super String> continuation) {
        StoreMediaEngine$selectDefaultVideoDeviceAsync$1 storeMediaEngine$selectDefaultVideoDeviceAsync$1;
        int i;
        StoreMediaEngine storeMediaEngine;
        if (continuation instanceof StoreMediaEngine$selectDefaultVideoDeviceAsync$1) {
            storeMediaEngine$selectDefaultVideoDeviceAsync$1 = (StoreMediaEngine$selectDefaultVideoDeviceAsync$1) continuation;
            int i2 = storeMediaEngine$selectDefaultVideoDeviceAsync$1.label;
            if ((i2 & Integer.MIN_VALUE) != 0) {
                storeMediaEngine$selectDefaultVideoDeviceAsync$1.label = i2 - Integer.MIN_VALUE;
                Object obj = storeMediaEngine$selectDefaultVideoDeviceAsync$1.result;
                Object coroutine_suspended = c.getCOROUTINE_SUSPENDED();
                i = storeMediaEngine$selectDefaultVideoDeviceAsync$1.label;
                if (i != 0) {
                    l.throwOnFailure(obj);
                    storeMediaEngine$selectDefaultVideoDeviceAsync$1.L$0 = this;
                    storeMediaEngine$selectDefaultVideoDeviceAsync$1.label = 1;
                    obj = getVideoInputDevicesNativeAsync(storeMediaEngine$selectDefaultVideoDeviceAsync$1);
                    if (obj == coroutine_suspended) {
                        return coroutine_suspended;
                    }
                    storeMediaEngine = this;
                } else if (i == 1) {
                    storeMediaEngine = (StoreMediaEngine) storeMediaEngine$selectDefaultVideoDeviceAsync$1.L$0;
                    l.throwOnFailure(obj);
                } else {
                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
                }
                VideoInputDeviceDescription[] videoInputDeviceDescriptionArr = (VideoInputDeviceDescription[]) obj;
                String pickDefaultDeviceGUID = storeMediaEngine.pickDefaultDeviceGUID(videoInputDeviceDescriptionArr);
                handleVideoInputDevices$default(storeMediaEngine, videoInputDeviceDescriptionArr, pickDefaultDeviceGUID, null, 4, null);
                return pickDefaultDeviceGUID;
            }
        }
        storeMediaEngine$selectDefaultVideoDeviceAsync$1 = new StoreMediaEngine$selectDefaultVideoDeviceAsync$1(this, continuation);
        Object obj = storeMediaEngine$selectDefaultVideoDeviceAsync$1.result;
        Object coroutine_suspended = c.getCOROUTINE_SUSPENDED();
        i = storeMediaEngine$selectDefaultVideoDeviceAsync$1.label;
        if (i != 0) {
        }
        VideoInputDeviceDescription[] videoInputDeviceDescriptionArr = (VideoInputDeviceDescription[]) obj;
        String pickDefaultDeviceGUID = storeMediaEngine.pickDefaultDeviceGUID(videoInputDeviceDescriptionArr);
        handleVideoInputDevices$default(storeMediaEngine, videoInputDeviceDescriptionArr, pickDefaultDeviceGUID, null, 4, null);
        return pickDefaultDeviceGUID;
    }

    public final void selectVideoInputDevice(String str) {
        getVideoInputDevicesNative(new StoreMediaEngine$selectVideoInputDevice$1(this, str));
    }

    public final synchronized void setAudioInputEnabled(boolean z2) {
        MediaEngine mediaEngine = this.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        mediaEngine.k(z2);
    }

    @SuppressLint({"ApplySharedPref"})
    public final synchronized void setOpenSLESConfig(MediaEngine.OpenSLESConfig openSLESConfig) {
        m.checkNotNullParameter(openSLESConfig, "openSLESConfig");
        this.openSLESConfigSubject.j.onNext(openSLESConfig);
        getPrefsSessionDurable().edit().putString("OPEN_SLES", openSLESConfig.name()).commit();
    }

    public final synchronized void setPttActive(boolean z2) {
        MediaEngine mediaEngine = this.mediaEngine;
        if (mediaEngine == null) {
            m.throwUninitializedPropertyAccessException("mediaEngine");
        }
        for (MediaEngineConnection mediaEngineConnection : mediaEngine.getConnections()) {
            mediaEngineConnection.q(z2);
        }
        SerializedSubject<Boolean, Boolean> serializedSubject = this.pttActiveSubject;
        serializedSubject.j.onNext(Boolean.valueOf(z2));
    }
}