package com.discord.stores;

import android.content.Context;
import android.media.AudioManager;
import androidx.annotation.VisibleForTesting;
import c.d.b.a.a;
import com.discord.app.AudioManagerFeatureFlag;
import com.discord.rtcconnection.RtcConnection;
import com.discord.stores.StoreAudioDevices;
import com.discord.utilities.media.AudioOutputState;
import com.discord.utilities.rx.ObservableExtensionsKt;
import d0.z.d.m;
import java.util.concurrent.TimeUnit;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.DefaultConstructorMarker;
import rx.Observable;
import rx.functions.Func2;
/* compiled from: StoreAudioManager.kt */
public final class StoreAudioManager extends Store {
    private final StoreAudioDevices audioDevices;
    private final AudioManagerFeatureFlag audioManagerFeatureFlag;
    private final boolean enabled;
    private final StoreRtcConnection rtcConnectionStore;

    /* compiled from: StoreAudioManager.kt */
    public static final class AudioManagerProvider {
        public static final AudioManagerProvider INSTANCE = new AudioManagerProvider();

        private AudioManagerProvider() {
        }

        public final AudioManager get(Context context) {
            m.checkNotNullParameter(context, "context");
            Object systemService = context.getSystemService("audio");
            if (!(systemService instanceof AudioManager)) {
                systemService = null;
            }
            return (AudioManager) systemService;
        }
    }

    /* compiled from: StoreAudioManager.kt */
    @VisibleForTesting
    public static final class MediaEngineAudioManager {
        private final AudioManager audioManager;
        private AudioManagerSettings initialAudioManagerSettings;
        private boolean isBluetoothScoStarted;

        /* compiled from: StoreAudioManager.kt */
        public static final class AudioManagerSettings {
            private final boolean settingBluetoothScoOn;
            private final int settingMode;
            private final boolean settingSpeakerPhoneOn;

            public AudioManagerSettings() {
                this(false, 0, false, 7, null);
            }

            public AudioManagerSettings(boolean z2, int i, boolean z3) {
                this.settingSpeakerPhoneOn = z2;
                this.settingMode = i;
                this.settingBluetoothScoOn = z3;
            }

            /* JADX INFO: this call moved to the top of the method (can break code semantics) */
            public /* synthetic */ AudioManagerSettings(boolean z2, int i, boolean z3, int i2, DefaultConstructorMarker defaultConstructorMarker) {
                this((i2 & 1) != 0 ? false : z2, (i2 & 2) != 0 ? 0 : i, (i2 & 4) != 0 ? false : z3);
            }

            public static /* synthetic */ AudioManagerSettings copy$default(AudioManagerSettings audioManagerSettings, boolean z2, int i, boolean z3, int i2, Object obj) {
                if ((i2 & 1) != 0) {
                    z2 = audioManagerSettings.settingSpeakerPhoneOn;
                }
                if ((i2 & 2) != 0) {
                    i = audioManagerSettings.settingMode;
                }
                if ((i2 & 4) != 0) {
                    z3 = audioManagerSettings.settingBluetoothScoOn;
                }
                return audioManagerSettings.copy(z2, i, z3);
            }

            public final boolean component1() {
                return this.settingSpeakerPhoneOn;
            }

            public final int component2() {
                return this.settingMode;
            }

            public final boolean component3() {
                return this.settingBluetoothScoOn;
            }

            public final AudioManagerSettings copy(boolean z2, int i, boolean z3) {
                return new AudioManagerSettings(z2, i, z3);
            }

            public boolean equals(Object obj) {
                if (this == obj) {
                    return true;
                }
                if (!(obj instanceof AudioManagerSettings)) {
                    return false;
                }
                AudioManagerSettings audioManagerSettings = (AudioManagerSettings) obj;
                return this.settingSpeakerPhoneOn == audioManagerSettings.settingSpeakerPhoneOn && this.settingMode == audioManagerSettings.settingMode && this.settingBluetoothScoOn == audioManagerSettings.settingBluetoothScoOn;
            }

            public final boolean getSettingBluetoothScoOn() {
                return this.settingBluetoothScoOn;
            }

            public final int getSettingMode() {
                return this.settingMode;
            }

            public final boolean getSettingSpeakerPhoneOn() {
                return this.settingSpeakerPhoneOn;
            }

            public int hashCode() {
                boolean z2 = this.settingSpeakerPhoneOn;
                int i = 1;
                if (z2) {
                    z2 = true;
                }
                int i2 = z2 ? 1 : 0;
                int i3 = z2 ? 1 : 0;
                int i4 = z2 ? 1 : 0;
                int i5 = ((i2 * 31) + this.settingMode) * 31;
                boolean z3 = this.settingBluetoothScoOn;
                if (!z3) {
                    i = z3 ? 1 : 0;
                }
                return i5 + i;
            }

            public String toString() {
                StringBuilder L = a.L("AudioManagerSettings(settingSpeakerPhoneOn=");
                L.append(this.settingSpeakerPhoneOn);
                L.append(", settingMode=");
                L.append(this.settingMode);
                L.append(", settingBluetoothScoOn=");
                return a.G(L, this.settingBluetoothScoOn, ")");
            }
        }

        /* compiled from: StoreAudioManager.kt */
        public static final class Configuration {
            private final StoreAudioDevices.AudioDevicesState audioDevicesState;
            private final RtcConnection.StateChange connectionState;

            public Configuration(RtcConnection.StateChange stateChange, StoreAudioDevices.AudioDevicesState audioDevicesState) {
                m.checkNotNullParameter(stateChange, "connectionState");
                m.checkNotNullParameter(audioDevicesState, "audioDevicesState");
                this.connectionState = stateChange;
                this.audioDevicesState = audioDevicesState;
            }

            public static /* synthetic */ Configuration copy$default(Configuration configuration, RtcConnection.StateChange stateChange, StoreAudioDevices.AudioDevicesState audioDevicesState, int i, Object obj) {
                if ((i & 1) != 0) {
                    stateChange = configuration.connectionState;
                }
                if ((i & 2) != 0) {
                    audioDevicesState = configuration.audioDevicesState;
                }
                return configuration.copy(stateChange, audioDevicesState);
            }

            public final RtcConnection.StateChange component1() {
                return this.connectionState;
            }

            public final StoreAudioDevices.AudioDevicesState component2() {
                return this.audioDevicesState;
            }

            public final Configuration copy(RtcConnection.StateChange stateChange, StoreAudioDevices.AudioDevicesState audioDevicesState) {
                m.checkNotNullParameter(stateChange, "connectionState");
                m.checkNotNullParameter(audioDevicesState, "audioDevicesState");
                return new Configuration(stateChange, audioDevicesState);
            }

            public boolean equals(Object obj) {
                if (this == obj) {
                    return true;
                }
                if (!(obj instanceof Configuration)) {
                    return false;
                }
                Configuration configuration = (Configuration) obj;
                return m.areEqual(this.connectionState, configuration.connectionState) && m.areEqual(this.audioDevicesState, configuration.audioDevicesState);
            }

            public final StoreAudioDevices.AudioDevicesState getAudioDevicesState() {
                return this.audioDevicesState;
            }

            public final RtcConnection.StateChange getConnectionState() {
                return this.connectionState;
            }

            public int hashCode() {
                RtcConnection.StateChange stateChange = this.connectionState;
                int i = 0;
                int hashCode = (stateChange != null ? stateChange.hashCode() : 0) * 31;
                StoreAudioDevices.AudioDevicesState audioDevicesState = this.audioDevicesState;
                if (audioDevicesState != null) {
                    i = audioDevicesState.hashCode();
                }
                return hashCode + i;
            }

            public String toString() {
                StringBuilder L = a.L("Configuration(connectionState=");
                L.append(this.connectionState);
                L.append(", audioDevicesState=");
                L.append(this.audioDevicesState);
                L.append(")");
                return L.toString();
            }
        }

        public MediaEngineAudioManager(AudioManager audioManager) {
            this.audioManager = audioManager;
            this.isBluetoothScoStarted = audioManager != null ? audioManager.isBluetoothScoOn() : false;
        }

        private final AudioManagerSettings extractSettings(AudioManager audioManager) {
            return new AudioManagerSettings(audioManager.isSpeakerphoneOn(), audioManager.getMode(), audioManager.isBluetoothScoOn());
        }

        private final void startBluetoothSCO(AudioManager audioManager) {
            audioManager.startBluetoothSco();
            audioManager.setBluetoothScoOn(true);
            this.isBluetoothScoStarted = true;
        }

        private final void stopBluetoothSCO(AudioManager audioManager) {
            audioManager.stopBluetoothSco();
            audioManager.setBluetoothScoOn(false);
            this.isBluetoothScoStarted = false;
        }

        private final void trySetMode(AudioManager audioManager, int i) {
            try {
                audioManager.setMode(i);
            } catch (SecurityException unused) {
            }
        }

        private final void useSettings(AudioManager audioManager, AudioManagerSettings audioManagerSettings) {
            if (audioManagerSettings.getSettingBluetoothScoOn()) {
                if (!this.isBluetoothScoStarted) {
                    startBluetoothSCO(audioManager);
                }
            } else if (this.isBluetoothScoStarted) {
                stopBluetoothSCO(audioManager);
            }
            audioManager.setSpeakerphoneOn(audioManagerSettings.getSettingSpeakerPhoneOn());
        }

        public final void configure(Configuration configuration) {
            m.checkNotNullParameter(configuration, "configuration");
            if (this.audioManager != null) {
                RtcConnection.StateChange component1 = configuration.component1();
                StoreAudioDevices.AudioDevicesState component2 = configuration.component2();
                RtcConnection.State state = component1.a;
                int i = 0;
                if (m.areEqual(state, RtcConnection.State.f.a) || m.areEqual(state, RtcConnection.State.g.a) || m.areEqual(state, RtcConnection.State.a.a) || m.areEqual(state, RtcConnection.State.b.a) || m.areEqual(state, RtcConnection.State.c.a) || ((state instanceof RtcConnection.State.d) && ((RtcConnection.State.d) state).a)) {
                    i = 3;
                }
                this.audioManager.setMode(i);
                if (i == 3) {
                    AudioOutputState audioOutputState = component2.getAudioOutputState();
                    StoreAudioDevices.OutputDevice selectedOutputDevice = component2.getSelectedOutputDevice();
                    AudioManagerSettings audioManagerSettings = this.initialAudioManagerSettings;
                    if (audioManagerSettings == null) {
                        audioManagerSettings = extractSettings(this.audioManager);
                    }
                    this.initialAudioManagerSettings = audioManagerSettings;
                    this.audioManager.setSpeakerphoneOn(selectedOutputDevice instanceof StoreAudioDevices.OutputDevice.Speaker);
                    if (this.isBluetoothScoStarted) {
                        if (!(selectedOutputDevice instanceof StoreAudioDevices.OutputDevice.BluetoothAudio) || !audioOutputState.isBluetoothOutputConnected()) {
                            stopBluetoothSCO(this.audioManager);
                        }
                    } else if ((selectedOutputDevice instanceof StoreAudioDevices.OutputDevice.BluetoothAudio) && audioOutputState.getCanBluetoothScoStart()) {
                        startBluetoothSCO(this.audioManager);
                    }
                } else {
                    AudioManagerSettings audioManagerSettings2 = this.initialAudioManagerSettings;
                    if (audioManagerSettings2 != null) {
                        useSettings(this.audioManager, audioManagerSettings2);
                    }
                    this.initialAudioManagerSettings = null;
                }
            }
        }
    }

    public StoreAudioManager(StoreAudioDevices storeAudioDevices, StoreRtcConnection storeRtcConnection, AudioManagerFeatureFlag audioManagerFeatureFlag) {
        m.checkNotNullParameter(storeAudioDevices, "audioDevices");
        m.checkNotNullParameter(storeRtcConnection, "rtcConnectionStore");
        m.checkNotNullParameter(audioManagerFeatureFlag, "audioManagerFeatureFlag");
        this.audioDevices = storeAudioDevices;
        this.rtcConnectionStore = storeRtcConnection;
        this.audioManagerFeatureFlag = audioManagerFeatureFlag;
        this.enabled = !audioManagerFeatureFlag.b();
    }

    /* JADX WARNING: Illegal instructions before constructor call */
    public /* synthetic */ StoreAudioManager(StoreAudioDevices storeAudioDevices, StoreRtcConnection storeRtcConnection, AudioManagerFeatureFlag audioManagerFeatureFlag, int i, DefaultConstructorMarker defaultConstructorMarker) {
        this(storeAudioDevices, storeRtcConnection, audioManagerFeatureFlag);
        if ((i & 4) != 0) {
            AudioManagerFeatureFlag audioManagerFeatureFlag2 = AudioManagerFeatureFlag.b;
            audioManagerFeatureFlag = AudioManagerFeatureFlag.a();
        }
    }

    public final boolean getEnabled() {
        return this.enabled;
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARNING: Unknown variable types count: 1 */
    @Override // com.discord.stores.Store
    public void init(Context context) {
        m.checkNotNullParameter(context, "context");
        if (this.enabled) {
            super.init(context);
            MediaEngineAudioManager mediaEngineAudioManager = new MediaEngineAudioManager(AudioManagerProvider.INSTANCE.get(context));
            Observable<RtcConnection.StateChange> connectionState = this.rtcConnectionStore.getConnectionState();
            Observable<StoreAudioDevices.AudioDevicesState> observeAudioDevicesState = this.audioDevices.observeAudioDevicesState();
            StoreAudioManager$init$1 storeAudioManager$init$1 = StoreAudioManager$init$1.INSTANCE;
            if (storeAudioManager$init$1 != null) {
                storeAudioManager$init$1 = new StoreAudioManager$sam$rx_functions_Func2$0(storeAudioManager$init$1);
            }
            Observable j = Observable.j(connectionState, observeAudioDevicesState, (Func2) storeAudioManager$init$1);
            m.checkNotNullExpressionValue(j, "Observable\n        .comb…::Configuration\n        )");
            Observable r = ObservableExtensionsKt.leadingEdgeThrottle(j, 500, TimeUnit.MILLISECONDS).r();
            m.checkNotNullExpressionValue(r, "Observable\n        .comb…  .distinctUntilChanged()");
            ObservableExtensionsKt.appSubscribe$default(r, StoreAudioManager.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreAudioManager$init$2(mediaEngineAudioManager), 62, (Object) null);
        }
    }
}