563 lines
24 KiB
Java
563 lines
24 KiB
Java
package com.discord.stores;
|
|
|
|
import android.content.Context;
|
|
import androidx.annotation.VisibleForTesting;
|
|
import c.d.b.a.a;
|
|
import com.airbnb.lottie.parser.AnimatableValueParser;
|
|
import com.discord.api.channel.Channel;
|
|
import com.discord.api.voice.state.VoiceState;
|
|
import com.discord.app.AudioManagerFeatureFlag;
|
|
import com.discord.rtcconnection.RtcConnection;
|
|
import com.discord.stores.updates.ObservationDeck;
|
|
import com.discord.stores.updates.ObservationDeckProvider;
|
|
import com.discord.utilities.media.AudioOutputMonitor;
|
|
import com.discord.utilities.media.AudioOutputState;
|
|
import com.discord.utilities.rx.ObservableExtensionsKt;
|
|
import d0.t.h0;
|
|
import d0.t.n0;
|
|
import d0.z.d.m;
|
|
import java.util.Collection;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import kotlin.jvm.functions.Function0;
|
|
import kotlin.jvm.functions.Function1;
|
|
import kotlin.jvm.internal.DefaultConstructorMarker;
|
|
import rx.Observable;
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public final class StoreAudioDevices extends StoreV2 {
|
|
public static final Companion Companion = new Companion(null);
|
|
private static final AudioDevicesState DEFAULT_AUDIO_DEVICES_STATE;
|
|
private static final OutputDevice.Speaker DEFAULT_OUTPUT_DEVICE;
|
|
private static final AudioOutputState DEFAULT_OUTPUT_STATE;
|
|
private AudioDevicesState audioDevicesState;
|
|
private AudioDevicesState audioDevicesStateSnapshot;
|
|
private final AudioManagerFeatureFlag audioManagerFeatureFlag;
|
|
private final AudioOutputMonitor audioOutputMonitor;
|
|
private AudioOutputState audioOutputState;
|
|
private final StoreChannels channelsStore;
|
|
private final Dispatcher dispatcher;
|
|
private final boolean enabled;
|
|
private final ObservationDeck observationDeck;
|
|
private final StoreVoiceChannelSelected selectedVoiceChannelStore;
|
|
private final VideoUseDetector videoUseDetector;
|
|
private boolean wasMeUsingVideoInChannel;
|
|
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public static final class AudioDevicesState {
|
|
private final AudioOutputState audioOutputState;
|
|
private final Set<OutputDevice> availableOutputDevices;
|
|
private final OutputDevice selectedOutputDevice;
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r4v0, resolved type: java.util.Set<? extends com.discord.stores.StoreAudioDevices$OutputDevice> */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public AudioDevicesState(AudioOutputState audioOutputState, OutputDevice outputDevice, Set<? extends OutputDevice> set) {
|
|
m.checkNotNullParameter(audioOutputState, "audioOutputState");
|
|
m.checkNotNullParameter(outputDevice, "selectedOutputDevice");
|
|
m.checkNotNullParameter(set, "availableOutputDevices");
|
|
this.audioOutputState = audioOutputState;
|
|
this.selectedOutputDevice = outputDevice;
|
|
this.availableOutputDevices = set;
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.stores.StoreAudioDevices$AudioDevicesState */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public static /* synthetic */ AudioDevicesState copy$default(AudioDevicesState audioDevicesState, AudioOutputState audioOutputState, OutputDevice outputDevice, Set set, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
audioOutputState = audioDevicesState.audioOutputState;
|
|
}
|
|
if ((i & 2) != 0) {
|
|
outputDevice = audioDevicesState.selectedOutputDevice;
|
|
}
|
|
if ((i & 4) != 0) {
|
|
set = audioDevicesState.availableOutputDevices;
|
|
}
|
|
return audioDevicesState.copy(audioOutputState, outputDevice, set);
|
|
}
|
|
|
|
public final AudioOutputState component1() {
|
|
return this.audioOutputState;
|
|
}
|
|
|
|
public final OutputDevice component2() {
|
|
return this.selectedOutputDevice;
|
|
}
|
|
|
|
public final Set<OutputDevice> component3() {
|
|
return this.availableOutputDevices;
|
|
}
|
|
|
|
public final AudioDevicesState copy(AudioOutputState audioOutputState, OutputDevice outputDevice, Set<? extends OutputDevice> set) {
|
|
m.checkNotNullParameter(audioOutputState, "audioOutputState");
|
|
m.checkNotNullParameter(outputDevice, "selectedOutputDevice");
|
|
m.checkNotNullParameter(set, "availableOutputDevices");
|
|
return new AudioDevicesState(audioOutputState, outputDevice, set);
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof AudioDevicesState)) {
|
|
return false;
|
|
}
|
|
AudioDevicesState audioDevicesState = (AudioDevicesState) obj;
|
|
return m.areEqual(this.audioOutputState, audioDevicesState.audioOutputState) && m.areEqual(this.selectedOutputDevice, audioDevicesState.selectedOutputDevice) && m.areEqual(this.availableOutputDevices, audioDevicesState.availableOutputDevices);
|
|
}
|
|
|
|
public final AudioOutputState getAudioOutputState() {
|
|
return this.audioOutputState;
|
|
}
|
|
|
|
public final Set<OutputDevice> getAvailableOutputDevices() {
|
|
return this.availableOutputDevices;
|
|
}
|
|
|
|
public final OutputDevice getSelectedOutputDevice() {
|
|
return this.selectedOutputDevice;
|
|
}
|
|
|
|
public int hashCode() {
|
|
AudioOutputState audioOutputState = this.audioOutputState;
|
|
int i = 0;
|
|
int hashCode = (audioOutputState != null ? audioOutputState.hashCode() : 0) * 31;
|
|
OutputDevice outputDevice = this.selectedOutputDevice;
|
|
int hashCode2 = (hashCode + (outputDevice != null ? outputDevice.hashCode() : 0)) * 31;
|
|
Set<OutputDevice> set = this.availableOutputDevices;
|
|
if (set != null) {
|
|
i = set.hashCode();
|
|
}
|
|
return hashCode2 + i;
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder L = a.L("AudioDevicesState(audioOutputState=");
|
|
L.append(this.audioOutputState);
|
|
L.append(", selectedOutputDevice=");
|
|
L.append(this.selectedOutputDevice);
|
|
L.append(", availableOutputDevices=");
|
|
L.append(this.availableOutputDevices);
|
|
L.append(")");
|
|
return L.toString();
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public static final class Companion {
|
|
private Companion() {
|
|
}
|
|
|
|
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
|
|
this();
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getDEFAULT_AUDIO_DEVICES_STATE$app_productionBetaRelease$annotations() {
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static /* synthetic */ void getDEFAULT_OUTPUT_STATE$app_productionBetaRelease$annotations() {
|
|
}
|
|
|
|
public final AudioDevicesState getDEFAULT_AUDIO_DEVICES_STATE$app_productionBetaRelease() {
|
|
return StoreAudioDevices.access$getDEFAULT_AUDIO_DEVICES_STATE$cp();
|
|
}
|
|
|
|
public final OutputDevice.Speaker getDEFAULT_OUTPUT_DEVICE$app_productionBetaRelease() {
|
|
return StoreAudioDevices.access$getDEFAULT_OUTPUT_DEVICE$cp();
|
|
}
|
|
|
|
public final AudioOutputState getDEFAULT_OUTPUT_STATE$app_productionBetaRelease() {
|
|
return StoreAudioDevices.access$getDEFAULT_OUTPUT_STATE$cp();
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public static abstract class OutputDevice {
|
|
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public static final class BluetoothAudio extends OutputDevice {
|
|
private final String name;
|
|
|
|
public BluetoothAudio() {
|
|
this(null, 1, null);
|
|
}
|
|
|
|
public BluetoothAudio(String str) {
|
|
super(null);
|
|
this.name = str;
|
|
}
|
|
|
|
/* JADX INFO: this call moved to the top of the method (can break code semantics) */
|
|
public /* synthetic */ BluetoothAudio(String str, int i, DefaultConstructorMarker defaultConstructorMarker) {
|
|
this((i & 1) != 0 ? null : str);
|
|
}
|
|
|
|
public static /* synthetic */ BluetoothAudio copy$default(BluetoothAudio bluetoothAudio, String str, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
str = bluetoothAudio.name;
|
|
}
|
|
return bluetoothAudio.copy(str);
|
|
}
|
|
|
|
public final String component1() {
|
|
return this.name;
|
|
}
|
|
|
|
public final BluetoothAudio copy(String str) {
|
|
return new BluetoothAudio(str);
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this != obj) {
|
|
return (obj instanceof BluetoothAudio) && m.areEqual(this.name, ((BluetoothAudio) obj).name);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public final String getName() {
|
|
return this.name;
|
|
}
|
|
|
|
public int hashCode() {
|
|
String str = this.name;
|
|
if (str != null) {
|
|
return str.hashCode();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public String toString() {
|
|
return a.D(a.L("BluetoothAudio(name="), this.name, ")");
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public static final class Earpiece extends OutputDevice {
|
|
public static final Earpiece INSTANCE = new Earpiece();
|
|
|
|
private Earpiece() {
|
|
super(null);
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public static final class Speaker extends OutputDevice {
|
|
public static final Speaker INSTANCE = new Speaker();
|
|
|
|
private Speaker() {
|
|
super(null);
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public static final class WiredAudio extends OutputDevice {
|
|
public static final WiredAudio INSTANCE = new WiredAudio();
|
|
|
|
private WiredAudio() {
|
|
super(null);
|
|
}
|
|
}
|
|
|
|
private OutputDevice() {
|
|
}
|
|
|
|
public /* synthetic */ OutputDevice(DefaultConstructorMarker defaultConstructorMarker) {
|
|
this();
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreAudioDevices.kt */
|
|
public static final class VideoUseDetector {
|
|
private final StoreChannels channelsStore;
|
|
private final StoreUser usersStore;
|
|
private final StoreVoiceStates voiceStatesStore;
|
|
|
|
public VideoUseDetector(StoreChannels storeChannels, StoreVoiceStates storeVoiceStates, StoreUser storeUser) {
|
|
m.checkNotNullParameter(storeChannels, "channelsStore");
|
|
m.checkNotNullParameter(storeVoiceStates, "voiceStatesStore");
|
|
m.checkNotNullParameter(storeUser, "usersStore");
|
|
this.channelsStore = storeChannels;
|
|
this.voiceStatesStore = storeVoiceStates;
|
|
this.usersStore = storeUser;
|
|
}
|
|
|
|
@StoreThread
|
|
private final Map<Long, VoiceState> getVoiceStatesForChannel(long j) {
|
|
Channel findChannelByIdInternal$app_productionBetaRelease = this.channelsStore.findChannelByIdInternal$app_productionBetaRelease(j);
|
|
Map<Long, VoiceState> map = this.voiceStatesStore.getInternal$app_productionBetaRelease().get(findChannelByIdInternal$app_productionBetaRelease != null ? Long.valueOf(findChannelByIdInternal$app_productionBetaRelease.f()) : null);
|
|
if (map == null) {
|
|
return h0.emptyMap();
|
|
}
|
|
LinkedHashMap linkedHashMap = new LinkedHashMap();
|
|
for (Map.Entry<Long, VoiceState> entry : map.entrySet()) {
|
|
Long a = entry.getValue().a();
|
|
if (a != null && a.longValue() == j) {
|
|
linkedHashMap.put(entry.getKey(), entry.getValue());
|
|
}
|
|
}
|
|
return linkedHashMap;
|
|
}
|
|
|
|
@StoreThread
|
|
public final boolean isAnyoneUsingVideoInChannel(long j) {
|
|
Collection<VoiceState> values = getVoiceStatesForChannel(j).values();
|
|
if ((values instanceof Collection) && values.isEmpty()) {
|
|
return false;
|
|
}
|
|
for (VoiceState voiceState : values) {
|
|
if (AnimatableValueParser.U0(voiceState)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@StoreThread
|
|
public final boolean isMeUsingVideoInChannel(long j) {
|
|
VoiceState voiceState = getVoiceStatesForChannel(j).get(Long.valueOf(this.usersStore.getMeInternal$app_productionBetaRelease().getId()));
|
|
if (voiceState != null) {
|
|
return AnimatableValueParser.U0(voiceState);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static {
|
|
OutputDevice.Speaker speaker = OutputDevice.Speaker.INSTANCE;
|
|
DEFAULT_OUTPUT_DEVICE = speaker;
|
|
AudioOutputState audioOutputState = new AudioOutputState(true, true, true, true, null);
|
|
DEFAULT_OUTPUT_STATE = audioOutputState;
|
|
DEFAULT_AUDIO_DEVICES_STATE = new AudioDevicesState(audioOutputState, speaker, n0.setOf((Object[]) new OutputDevice[]{speaker, OutputDevice.Earpiece.INSTANCE}));
|
|
}
|
|
|
|
public StoreAudioDevices(Dispatcher dispatcher, AudioOutputMonitor audioOutputMonitor, VideoUseDetector videoUseDetector, StoreVoiceChannelSelected storeVoiceChannelSelected, StoreChannels storeChannels, ObservationDeck observationDeck, AudioManagerFeatureFlag audioManagerFeatureFlag) {
|
|
m.checkNotNullParameter(dispatcher, "dispatcher");
|
|
m.checkNotNullParameter(audioOutputMonitor, "audioOutputMonitor");
|
|
m.checkNotNullParameter(videoUseDetector, "videoUseDetector");
|
|
m.checkNotNullParameter(storeVoiceChannelSelected, "selectedVoiceChannelStore");
|
|
m.checkNotNullParameter(storeChannels, "channelsStore");
|
|
m.checkNotNullParameter(observationDeck, "observationDeck");
|
|
m.checkNotNullParameter(audioManagerFeatureFlag, "audioManagerFeatureFlag");
|
|
this.dispatcher = dispatcher;
|
|
this.audioOutputMonitor = audioOutputMonitor;
|
|
this.videoUseDetector = videoUseDetector;
|
|
this.selectedVoiceChannelStore = storeVoiceChannelSelected;
|
|
this.channelsStore = storeChannels;
|
|
this.observationDeck = observationDeck;
|
|
this.audioManagerFeatureFlag = audioManagerFeatureFlag;
|
|
this.enabled = !audioManagerFeatureFlag.b();
|
|
AudioDevicesState audioDevicesState = DEFAULT_AUDIO_DEVICES_STATE;
|
|
this.audioDevicesState = audioDevicesState;
|
|
this.audioDevicesStateSnapshot = audioDevicesState;
|
|
}
|
|
|
|
/* JADX WARNING: Illegal instructions before constructor call */
|
|
public /* synthetic */ StoreAudioDevices(Dispatcher dispatcher, AudioOutputMonitor audioOutputMonitor, VideoUseDetector videoUseDetector, StoreVoiceChannelSelected storeVoiceChannelSelected, StoreChannels storeChannels, ObservationDeck observationDeck, AudioManagerFeatureFlag audioManagerFeatureFlag, int i, DefaultConstructorMarker defaultConstructorMarker) {
|
|
this(dispatcher, audioOutputMonitor, videoUseDetector, storeVoiceChannelSelected, storeChannels, r7, r8);
|
|
AudioManagerFeatureFlag audioManagerFeatureFlag2;
|
|
ObservationDeck observationDeck2 = (i & 32) != 0 ? ObservationDeckProvider.get() : observationDeck;
|
|
if ((i & 64) != 0) {
|
|
AudioManagerFeatureFlag audioManagerFeatureFlag3 = AudioManagerFeatureFlag.b;
|
|
audioManagerFeatureFlag2 = AudioManagerFeatureFlag.a();
|
|
} else {
|
|
audioManagerFeatureFlag2 = audioManagerFeatureFlag;
|
|
}
|
|
}
|
|
|
|
public static final /* synthetic */ void access$autoSelectNonSpeakerOutput(StoreAudioDevices storeAudioDevices) {
|
|
storeAudioDevices.autoSelectNonSpeakerOutput();
|
|
}
|
|
|
|
public static final /* synthetic */ AudioDevicesState access$getAudioDevicesState(StoreAudioDevices storeAudioDevices) {
|
|
return storeAudioDevices.getAudioDevicesState();
|
|
}
|
|
|
|
public static final /* synthetic */ AudioDevicesState access$getDEFAULT_AUDIO_DEVICES_STATE$cp() {
|
|
return DEFAULT_AUDIO_DEVICES_STATE;
|
|
}
|
|
|
|
public static final /* synthetic */ OutputDevice.Speaker access$getDEFAULT_OUTPUT_DEVICE$cp() {
|
|
return DEFAULT_OUTPUT_DEVICE;
|
|
}
|
|
|
|
public static final /* synthetic */ AudioOutputState access$getDEFAULT_OUTPUT_STATE$cp() {
|
|
return DEFAULT_OUTPUT_STATE;
|
|
}
|
|
|
|
public static final /* synthetic */ Dispatcher access$getDispatcher$p(StoreAudioDevices storeAudioDevices) {
|
|
return storeAudioDevices.dispatcher;
|
|
}
|
|
|
|
public static final /* synthetic */ void access$updateAudioOutputState(StoreAudioDevices storeAudioDevices, AudioOutputState audioOutputState) {
|
|
storeAudioDevices.updateAudioOutputState(audioOutputState);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$updateSelectedOutputDevice(StoreAudioDevices storeAudioDevices, OutputDevice outputDevice) {
|
|
storeAudioDevices.updateSelectedOutputDevice(outputDevice);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void autoSelectAudioOutput() {
|
|
OutputDevice outputDevice;
|
|
long selectedVoiceChannelId = this.selectedVoiceChannelStore.getSelectedVoiceChannelId();
|
|
if (this.audioDevicesState.getAudioOutputState().isExternalAudioOutputConnected()) {
|
|
autoSelectNonSpeakerOutput();
|
|
return;
|
|
}
|
|
if (this.videoUseDetector.isAnyoneUsingVideoInChannel(selectedVoiceChannelId)) {
|
|
outputDevice = OutputDevice.Speaker.INSTANCE;
|
|
} else {
|
|
Channel channel = this.channelsStore.getChannel(selectedVoiceChannelId);
|
|
outputDevice = (channel == null || !AnimatableValueParser.v1(channel)) ? OutputDevice.Earpiece.INSTANCE : OutputDevice.Speaker.INSTANCE;
|
|
}
|
|
updateSelectedOutputDevice(outputDevice);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void autoSelectNonSpeakerOutput() {
|
|
Object obj;
|
|
AudioOutputState audioOutputState = this.audioDevicesState.getAudioOutputState();
|
|
Iterator<T> it = this.audioDevicesState.getAvailableOutputDevices().iterator();
|
|
while (true) {
|
|
if (!it.hasNext()) {
|
|
obj = null;
|
|
break;
|
|
}
|
|
obj = it.next();
|
|
if (((OutputDevice) obj) instanceof OutputDevice.BluetoothAudio) {
|
|
break;
|
|
}
|
|
}
|
|
OutputDevice outputDevice = (OutputDevice) obj;
|
|
if (!audioOutputState.isBluetoothOutputConnected() || outputDevice == null) {
|
|
outputDevice = !audioOutputState.isHeadsetUnplugged() ? OutputDevice.WiredAudio.INSTANCE : OutputDevice.Earpiece.INSTANCE;
|
|
}
|
|
updateSelectedOutputDevice(outputDevice);
|
|
}
|
|
|
|
private final AudioDevicesState getAudioDevicesState() {
|
|
return this.audioDevicesStateSnapshot;
|
|
}
|
|
|
|
@StoreThread
|
|
private final void refreshAudioOutputState() {
|
|
AudioOutputState audioOutputState = this.audioOutputState;
|
|
if (audioOutputState != null) {
|
|
updateAudioOutputState(audioOutputState);
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
private final void updateAudioOutputState(AudioOutputState audioOutputState) {
|
|
this.audioOutputState = audioOutputState;
|
|
boolean isBluetoothOutputConnected = this.audioDevicesState.getAudioOutputState().isBluetoothOutputConnected();
|
|
boolean z2 = !this.audioDevicesState.getAudioOutputState().isHeadsetUnplugged();
|
|
this.audioDevicesState = AudioDevicesState.copy$default(this.audioDevicesState, audioOutputState, null, null, 6, null);
|
|
Set<? extends OutputDevice> mutableSetOf = n0.mutableSetOf(OutputDevice.Speaker.INSTANCE);
|
|
if (!audioOutputState.isHeadsetUnplugged()) {
|
|
mutableSetOf.add(OutputDevice.WiredAudio.INSTANCE);
|
|
} else {
|
|
if (!this.videoUseDetector.isMeUsingVideoInChannel(this.selectedVoiceChannelStore.getSelectedVoiceChannelId())) {
|
|
mutableSetOf.add(OutputDevice.Earpiece.INSTANCE);
|
|
}
|
|
if (audioOutputState.isBluetoothOutputConnected()) {
|
|
mutableSetOf.add(new OutputDevice.BluetoothAudio(audioOutputState.getBluetoothDeviceName()));
|
|
}
|
|
}
|
|
updateAvailableOutputDevices(mutableSetOf);
|
|
AudioOutputState audioOutputState2 = this.audioDevicesState.getAudioOutputState();
|
|
if ((!isBluetoothOutputConnected && audioOutputState2.isBluetoothOutputConnected()) || ((isBluetoothOutputConnected && !audioOutputState2.isBluetoothOutputConnected()) || ((!z2 && !audioOutputState2.isHeadsetUnplugged()) || (z2 && audioOutputState2.isHeadsetUnplugged())))) {
|
|
autoSelectAudioOutput();
|
|
}
|
|
markChanged();
|
|
}
|
|
|
|
@StoreThread
|
|
private final void updateAvailableOutputDevices(Set<? extends OutputDevice> set) {
|
|
this.audioDevicesState = AudioDevicesState.copy$default(this.audioDevicesState, null, null, set, 3, null);
|
|
markChanged();
|
|
}
|
|
|
|
@StoreThread
|
|
private final void updateSelectedOutputDevice(OutputDevice outputDevice) {
|
|
if (!m.areEqual(this.audioDevicesState.getSelectedOutputDevice(), outputDevice)) {
|
|
this.audioDevicesState = AudioDevicesState.copy$default(this.audioDevicesState, null, outputDevice, null, 5, null);
|
|
markChanged();
|
|
}
|
|
}
|
|
|
|
public final AudioDevicesState getAudioDevicesState$app_productionBetaRelease() {
|
|
return this.audioDevicesState;
|
|
}
|
|
|
|
public final boolean getEnabled() {
|
|
return this.enabled;
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleStreamRtcConnectionStateChange(RtcConnection.State state) {
|
|
m.checkNotNullParameter(state, "state");
|
|
if (this.enabled) {
|
|
if (m.areEqual(state, RtcConnection.State.f.a) && !this.audioDevicesState.getAudioOutputState().isExternalAudioOutputConnected()) {
|
|
updateSelectedOutputDevice(OutputDevice.Speaker.INSTANCE);
|
|
}
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleVoiceChannelSelected() {
|
|
if (this.enabled) {
|
|
autoSelectAudioOutput();
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleVoiceStatesUpdated() {
|
|
if (this.enabled) {
|
|
boolean isMeUsingVideoInChannel = this.videoUseDetector.isMeUsingVideoInChannel(this.selectedVoiceChannelStore.getSelectedVoiceChannelId());
|
|
if (this.wasMeUsingVideoInChannel != isMeUsingVideoInChannel) {
|
|
refreshAudioOutputState();
|
|
}
|
|
if (!this.wasMeUsingVideoInChannel && isMeUsingVideoInChannel) {
|
|
autoSelectAudioOutput();
|
|
}
|
|
this.wasMeUsingVideoInChannel = isMeUsingVideoInChannel;
|
|
}
|
|
}
|
|
|
|
public final void init() {
|
|
if (this.enabled) {
|
|
ObservableExtensionsKt.appSubscribe$default(this.audioOutputMonitor.getOutputState(), StoreAudioDevices.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreAudioDevices$init$1(this), 62, (Object) null);
|
|
}
|
|
}
|
|
|
|
public final Observable<AudioDevicesState> observeAudioDevicesState() {
|
|
Observable<AudioDevicesState> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreAudioDevices$observeAudioDevicesState$1(this), 14, null).r();
|
|
m.checkNotNullExpressionValue(r, "observationDeck.connectR… }.distinctUntilChanged()");
|
|
return r;
|
|
}
|
|
|
|
public final void selectAudioOutput(OutputDevice outputDevice) {
|
|
m.checkNotNullParameter(outputDevice, "outputDevice");
|
|
this.dispatcher.schedule(new StoreAudioDevices$selectAudioOutput$1(this, outputDevice));
|
|
}
|
|
|
|
public final void setAudioDevicesState$app_productionBetaRelease(AudioDevicesState audioDevicesState) {
|
|
m.checkNotNullParameter(audioDevicesState, "<set-?>");
|
|
this.audioDevicesState = audioDevicesState;
|
|
}
|
|
|
|
@Override // com.discord.stores.StoreV2
|
|
public void snapshotData() {
|
|
super.snapshotData();
|
|
this.audioDevicesStateSnapshot = AudioDevicesState.copy$default(this.audioDevicesState, null, null, new HashSet(this.audioDevicesState.getAvailableOutputDevices()), 3, null);
|
|
}
|
|
|
|
public final void toggleSpeakerOutput() {
|
|
this.dispatcher.schedule(new StoreAudioDevices$toggleSpeakerOutput$1(this));
|
|
}
|
|
}
|