507 lines
24 KiB
Java
507 lines
24 KiB
Java
package com.discord.stores;
|
|
|
|
import android.content.Context;
|
|
import com.discord.models.domain.ModelPayload;
|
|
import com.discord.models.experiments.domain.Experiment;
|
|
import com.discord.models.experiments.domain.ExperimentHash;
|
|
import com.discord.models.experiments.dto.GuildExperimentDto;
|
|
import com.discord.models.experiments.dto.UserExperimentDto;
|
|
import com.discord.stores.updates.ObservationDeck;
|
|
import com.discord.stores.updates.ObservationDeckProvider;
|
|
import com.discord.utilities.analytics.AnalyticsTracker;
|
|
import com.discord.utilities.experiments.ExperimentRegistry;
|
|
import com.discord.utilities.experiments.ExperimentUtils;
|
|
import com.discord.utilities.experiments.RegisteredExperiment;
|
|
import com.discord.utilities.persister.Persister;
|
|
import com.discord.utilities.rest.RestAPI;
|
|
import com.discord.utilities.rx.ObservableExtensionsKt;
|
|
import com.discord.utilities.time.Clock;
|
|
import com.discord.widgets.chat.input.sticker.StickerPickerFeatureFlag;
|
|
import com.google.gson.Gson;
|
|
import d0.t.h0;
|
|
import d0.z.d.m;
|
|
import java.util.AbstractMap;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.concurrent.TimeUnit;
|
|
import kotlin.jvm.functions.Function0;
|
|
import kotlin.jvm.functions.Function1;
|
|
import kotlin.jvm.internal.DefaultConstructorMarker;
|
|
import rx.Observable;
|
|
/* compiled from: StoreExperiments.kt */
|
|
public final class StoreExperiments extends StoreV2 {
|
|
public static final Companion Companion = new Companion(null);
|
|
private static final long DISCORD_TESTERS_GUILD_ID = 197038439483310086L;
|
|
private static final String EXPERIMENT_OVERRIDES_CACHE_KEY = "EXPERIMENT_OVERRIDES_CACHE_KEY";
|
|
private static final String EXPERIMENT_TRACKED_EXPOSURE_TIMESTAMPS_CACHE_KEY = "EXPERIMENT_TRIGGER_TIMESTAMPS_CACHE_KEY";
|
|
private static final StoreExperiments$Companion$ExperimentOverridesUpdateSource$1 ExperimentOverridesUpdateSource = new StoreExperiments$Companion$ExperimentOverridesUpdateSource$1();
|
|
private static final String GUILD_EXPERIMENTS_CACHE_KEY = "GUILD_EXPERIMENTS_CACHE_KEY";
|
|
private static final StoreExperiments$Companion$InitializedUpdateSource$1 InitializedUpdateSource = new StoreExperiments$Companion$InitializedUpdateSource$1();
|
|
private static final String UNINITIALIZED = "UNINITIALIZED";
|
|
private static final String USER_EXPERIMENTS_CACHE_KEY = "USER_EXPERIMENTS_CACHE_KEY";
|
|
private String authToken;
|
|
private final Clock clock;
|
|
private final Dispatcher dispatcher;
|
|
private final HashMap<String, Integer> experimentOverrides;
|
|
private final Persister<Map<String, Integer>> experimentOverridesCache;
|
|
private Map<String, Integer> experimentOverridesSnapshot;
|
|
private final HashMap<String, Long> experimentTrackedExposureTimestamps;
|
|
private String fingerprint;
|
|
private final HashMap<Long, GuildExperimentDto> guildExperiments;
|
|
private final Persister<List<GuildExperimentDto>> guildExperimentsCache;
|
|
private Map<Long, GuildExperimentDto> guildExperimentsSnapshot;
|
|
private boolean initialized;
|
|
private final HashMap<String, Experiment> memoizedGuildExperiments;
|
|
private final ObservationDeck observationDeck;
|
|
private final StoreAuthentication storeAuthentication;
|
|
private final StoreGuildMemberCounts storeGuildMemberCounts;
|
|
private final StoreGuilds storeGuilds;
|
|
private final StoreUser storeUser;
|
|
private final HashMap<Long, UserExperimentDto> userExperiments;
|
|
private final Persister<Map<Long, UserExperimentDto>> userExperimentsCache;
|
|
private Map<Long, UserExperimentDto> userExperimentsSnapshot;
|
|
|
|
/* compiled from: StoreExperiments.kt */
|
|
public static final class Companion {
|
|
private Companion() {
|
|
}
|
|
|
|
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
|
|
this();
|
|
}
|
|
}
|
|
|
|
public StoreExperiments(Clock clock, Dispatcher dispatcher, StoreUser storeUser, StoreGuilds storeGuilds, StoreAuthentication storeAuthentication, StoreGuildMemberCounts storeGuildMemberCounts, ObservationDeck observationDeck) {
|
|
m.checkNotNullParameter(clock, "clock");
|
|
m.checkNotNullParameter(dispatcher, "dispatcher");
|
|
m.checkNotNullParameter(storeUser, "storeUser");
|
|
m.checkNotNullParameter(storeGuilds, "storeGuilds");
|
|
m.checkNotNullParameter(storeAuthentication, "storeAuthentication");
|
|
m.checkNotNullParameter(storeGuildMemberCounts, "storeGuildMemberCounts");
|
|
m.checkNotNullParameter(observationDeck, "observationDeck");
|
|
this.clock = clock;
|
|
this.dispatcher = dispatcher;
|
|
this.storeUser = storeUser;
|
|
this.storeGuilds = storeGuilds;
|
|
this.storeAuthentication = storeAuthentication;
|
|
this.storeGuildMemberCounts = storeGuildMemberCounts;
|
|
this.observationDeck = observationDeck;
|
|
this.authToken = "UNINITIALIZED";
|
|
this.fingerprint = "UNINITIALIZED";
|
|
this.userExperimentsSnapshot = h0.emptyMap();
|
|
this.guildExperimentsSnapshot = h0.emptyMap();
|
|
this.experimentOverridesSnapshot = h0.emptyMap();
|
|
this.userExperiments = new HashMap<>();
|
|
this.guildExperiments = new HashMap<>();
|
|
this.experimentOverrides = new HashMap<>();
|
|
this.memoizedGuildExperiments = new HashMap<>();
|
|
this.experimentTrackedExposureTimestamps = new HashMap<>();
|
|
this.userExperimentsCache = new Persister<>("USER_EXPERIMENTS_CACHE_KEY", new HashMap());
|
|
this.guildExperimentsCache = new Persister<>("GUILD_EXPERIMENTS_CACHE_KEY", new ArrayList());
|
|
this.experimentOverridesCache = new Persister<>("EXPERIMENT_OVERRIDES_CACHE_KEY", new HashMap());
|
|
}
|
|
|
|
/* JADX INFO: this call moved to the top of the method (can break code semantics) */
|
|
public /* synthetic */ StoreExperiments(Clock clock, Dispatcher dispatcher, StoreUser storeUser, StoreGuilds storeGuilds, StoreAuthentication storeAuthentication, StoreGuildMemberCounts storeGuildMemberCounts, ObservationDeck observationDeck, int i, DefaultConstructorMarker defaultConstructorMarker) {
|
|
this(clock, dispatcher, storeUser, storeGuilds, storeAuthentication, storeGuildMemberCounts, (i & 64) != 0 ? ObservationDeckProvider.get() : observationDeck);
|
|
}
|
|
|
|
public static final /* synthetic */ Dispatcher access$getDispatcher$p(StoreExperiments storeExperiments) {
|
|
return storeExperiments.dispatcher;
|
|
}
|
|
|
|
public static final /* synthetic */ HashMap access$getExperimentOverrides$p(StoreExperiments storeExperiments) {
|
|
return storeExperiments.experimentOverrides;
|
|
}
|
|
|
|
public static final /* synthetic */ boolean access$getInitialized$p(StoreExperiments storeExperiments) {
|
|
return storeExperiments.initialized;
|
|
}
|
|
|
|
public static final /* synthetic */ StoreAuthentication access$getStoreAuthentication$p(StoreExperiments storeExperiments) {
|
|
return storeExperiments.storeAuthentication;
|
|
}
|
|
|
|
public static final /* synthetic */ StoreGuilds access$getStoreGuilds$p(StoreExperiments storeExperiments) {
|
|
return storeExperiments.storeGuilds;
|
|
}
|
|
|
|
public static final /* synthetic */ StoreUser access$getStoreUser$p(StoreExperiments storeExperiments) {
|
|
return storeExperiments.storeUser;
|
|
}
|
|
|
|
public static final /* synthetic */ void access$handleClearOverride(StoreExperiments storeExperiments, String str) {
|
|
storeExperiments.handleClearOverride(str);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$handleLoadedUserExperiments(StoreExperiments storeExperiments, Map map, boolean z2) {
|
|
storeExperiments.handleLoadedUserExperiments(map, z2);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$handleSetOverride(StoreExperiments storeExperiments, String str, int i) {
|
|
storeExperiments.handleSetOverride(str, i);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$setInitialized(StoreExperiments storeExperiments) {
|
|
storeExperiments.setInitialized();
|
|
}
|
|
|
|
public static final /* synthetic */ void access$setInitialized$p(StoreExperiments storeExperiments, boolean z2) {
|
|
storeExperiments.initialized = z2;
|
|
}
|
|
|
|
public static final /* synthetic */ void access$trackExposureToGuildExperiment(StoreExperiments storeExperiments, String str, long j, int i, int i2) {
|
|
storeExperiments.trackExposureToGuildExperiment(str, j, i, i2);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$trackExposureToUserExperiment(StoreExperiments storeExperiments, String str, int i, int i2, int i3) {
|
|
storeExperiments.trackExposureToUserExperiment(str, i, i2, i3);
|
|
}
|
|
|
|
private final void cacheExperimentTrackedExposureTimestamps() {
|
|
getPrefs().edit().putString("EXPERIMENT_TRIGGER_TIMESTAMPS_CACHE_KEY", new Gson().m(this.experimentTrackedExposureTimestamps)).apply();
|
|
}
|
|
|
|
private final void cacheGuildExperiments() {
|
|
boolean z2;
|
|
Collection<GuildExperimentDto> values = this.guildExperiments.values();
|
|
m.checkNotNullExpressionValue(values, "guildExperiments.values");
|
|
ArrayList arrayList = new ArrayList();
|
|
Iterator<T> it = values.iterator();
|
|
while (true) {
|
|
boolean z3 = true;
|
|
if (it.hasNext()) {
|
|
Object next = it.next();
|
|
GuildExperimentDto guildExperimentDto = (GuildExperimentDto) next;
|
|
Collection<RegisteredExperiment> values2 = ExperimentRegistry.INSTANCE.getRegisteredExperiments().values();
|
|
m.checkNotNullExpressionValue(values2, "ExperimentRegistry.registeredExperiments.values");
|
|
if (!(values2 instanceof Collection) || !values2.isEmpty()) {
|
|
Iterator<T> it2 = values2.iterator();
|
|
while (true) {
|
|
if (!it2.hasNext()) {
|
|
break;
|
|
}
|
|
if (ExperimentHash.INSTANCE.from(((RegisteredExperiment) it2.next()).getName()) == guildExperimentDto.getExperimentIdHash()) {
|
|
z2 = true;
|
|
continue;
|
|
} else {
|
|
z2 = false;
|
|
continue;
|
|
}
|
|
if (z2) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
z3 = false;
|
|
if (z3) {
|
|
arrayList.add(next);
|
|
}
|
|
} else {
|
|
this.guildExperimentsCache.set(arrayList, true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:20:0x0067 A[SYNTHETIC] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:23:0x000f A[SYNTHETIC] */
|
|
private final void cacheUserExperiments() {
|
|
boolean z2;
|
|
HashMap<Long, UserExperimentDto> hashMap = this.userExperiments;
|
|
LinkedHashMap linkedHashMap = new LinkedHashMap();
|
|
Iterator<Map.Entry<Long, UserExperimentDto>> it = hashMap.entrySet().iterator();
|
|
while (true) {
|
|
boolean z3 = true;
|
|
if (it.hasNext()) {
|
|
Map.Entry<Long, UserExperimentDto> next = it.next();
|
|
Collection<RegisteredExperiment> values = ExperimentRegistry.INSTANCE.getRegisteredExperiments().values();
|
|
m.checkNotNullExpressionValue(values, "ExperimentRegistry.registeredExperiments.values");
|
|
if (!(values instanceof Collection) || !values.isEmpty()) {
|
|
Iterator<T> it2 = values.iterator();
|
|
while (true) {
|
|
if (!it2.hasNext()) {
|
|
break;
|
|
}
|
|
if (ExperimentHash.INSTANCE.from(((RegisteredExperiment) it2.next()).getName()) == next.getValue().getNameHash()) {
|
|
z2 = true;
|
|
continue;
|
|
} else {
|
|
z2 = false;
|
|
continue;
|
|
}
|
|
if (z2) {
|
|
break;
|
|
}
|
|
}
|
|
if (!z3) {
|
|
linkedHashMap.put(next.getKey(), next.getValue());
|
|
}
|
|
}
|
|
z3 = false;
|
|
if (!z3) {
|
|
}
|
|
} else {
|
|
this.userExperimentsCache.set(linkedHashMap, true);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private final void didTrackExposureToExperiment(String str) {
|
|
this.experimentTrackedExposureTimestamps.put(str, Long.valueOf(this.clock.currentTimeMillis()));
|
|
cacheExperimentTrackedExposureTimestamps();
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleClearOverride(String str) {
|
|
this.experimentOverrides.remove(str);
|
|
markChanged(ExperimentOverridesUpdateSource);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleLoadedGuildExperiments(Collection<GuildExperimentDto> collection, boolean z2) {
|
|
this.guildExperiments.clear();
|
|
this.memoizedGuildExperiments.clear();
|
|
AbstractMap abstractMap = this.guildExperiments;
|
|
for (Object obj : collection) {
|
|
abstractMap.put(Long.valueOf(((GuildExperimentDto) obj).getExperimentIdHash()), obj);
|
|
}
|
|
if (z2) {
|
|
cacheGuildExperiments();
|
|
}
|
|
markChanged();
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleLoadedUserExperiments(Map<Long, UserExperimentDto> map, boolean z2) {
|
|
this.userExperiments.clear();
|
|
this.userExperiments.putAll(map);
|
|
if (z2) {
|
|
cacheUserExperiments();
|
|
}
|
|
markChanged();
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleSetOverride(String str, int i) {
|
|
this.experimentOverrides.put(str, Integer.valueOf(i));
|
|
markChanged(ExperimentOverridesUpdateSource);
|
|
}
|
|
|
|
private final Map<String, Long> loadCachedExperimentTrackedExposureTimestamps() {
|
|
String string = getPrefs().getString("EXPERIMENT_TRIGGER_TIMESTAMPS_CACHE_KEY", null);
|
|
if (string == null) {
|
|
return h0.emptyMap();
|
|
}
|
|
Object g = new Gson().g(string, new StoreExperiments$loadCachedExperimentTrackedExposureTimestamps$typeToken$1().getType());
|
|
m.checkNotNullExpressionValue(g, "Gson().fromJson(json, typeToken)");
|
|
return (Map) g;
|
|
}
|
|
|
|
private final synchronized void memoizeGuildExperiment(String str, long j, Experiment experiment) {
|
|
this.memoizedGuildExperiments.put(str + ':' + j, experiment);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void reset() {
|
|
if (this.authToken == null) {
|
|
this.userExperiments.clear();
|
|
this.guildExperiments.clear();
|
|
this.userExperimentsCache.set(new HashMap(), true);
|
|
this.guildExperimentsCache.set(new ArrayList(), true);
|
|
this.initialized = false;
|
|
markChanged();
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
private final void setInitialized() {
|
|
this.initialized = true;
|
|
markChanged(InitializedUpdateSource);
|
|
}
|
|
|
|
private final synchronized void trackExposureToGuildExperiment(String str, long j, int i, int i2) {
|
|
String str2 = str + ':' + j;
|
|
if (!wasExperimentExposureTrackedRecently(str2, this.clock.currentTimeMillis())) {
|
|
AnalyticsTracker.guildExperimentTriggered(str, i2, i, j);
|
|
didTrackExposureToExperiment(str2);
|
|
}
|
|
}
|
|
|
|
private final synchronized void trackExposureToUserExperiment(String str, int i, int i2, int i3) {
|
|
if (!wasExperimentExposureTrackedRecently(str, this.clock.currentTimeMillis())) {
|
|
AnalyticsTracker.userExperimentTriggered(str, i3, i2, i);
|
|
didTrackExposureToExperiment(str);
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
private final void tryInitializeExperiments() {
|
|
if (!this.initialized && !m.areEqual(this.authToken, "UNINITIALIZED") && !m.areEqual(this.fingerprint, "UNINITIALIZED")) {
|
|
this.initialized = true;
|
|
if (this.authToken != null) {
|
|
setInitialized();
|
|
return;
|
|
}
|
|
Observable c02 = ObservableExtensionsKt.restSubscribeOn$default(RestAPI.Companion.getApi().getExperiments(), false, 1, null).c0(2000, TimeUnit.MILLISECONDS);
|
|
m.checkNotNullExpressionValue(c02, "RestAPI\n .api\n …0, TimeUnit.MILLISECONDS)");
|
|
ObservableExtensionsKt.appSubscribe$default(c02, StoreExperiments.class, (Context) null, (Function1) null, new StoreExperiments$tryInitializeExperiments$2(this), (Function0) null, (Function0) null, new StoreExperiments$tryInitializeExperiments$1(this), 54, (Object) null);
|
|
}
|
|
}
|
|
|
|
private final boolean wasExperimentExposureTrackedRecently(String str, long j) {
|
|
Long l = this.experimentTrackedExposureTimestamps.get(str);
|
|
if (l == null) {
|
|
l = Long.MIN_VALUE;
|
|
}
|
|
m.checkNotNullExpressionValue(l, "experimentTrackedExposur…y] ?: Timestamp.MIN_VALUE");
|
|
return j - 604800000 < l.longValue();
|
|
}
|
|
|
|
public final void clearOverride(String str) {
|
|
m.checkNotNullParameter(str, "experimentName");
|
|
this.dispatcher.schedule(new StoreExperiments$clearOverride$1(this, str));
|
|
}
|
|
|
|
public final Observable<Boolean> getExperimentalAlpha() {
|
|
return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this.storeUser, this.storeGuilds}, false, null, null, new StoreExperiments$getExperimentalAlpha$1(this), 14, null);
|
|
}
|
|
|
|
public final Experiment getGuildExperiment(String str, long j, boolean z2) {
|
|
m.checkNotNullParameter(str, "experimentName");
|
|
long from = ExperimentHash.INSTANCE.from(str);
|
|
Integer num = this.experimentOverridesSnapshot.get(str);
|
|
GuildExperimentDto guildExperimentDto = this.guildExperimentsSnapshot.get(Long.valueOf(from));
|
|
if (num != null) {
|
|
return new Experiment(guildExperimentDto != null ? guildExperimentDto.getRevision() : 0, num.intValue(), 0, true, StoreExperiments$getGuildExperiment$1.INSTANCE);
|
|
}
|
|
Experiment memoizedGuildExperiment$app_productionBetaRelease = getMemoizedGuildExperiment$app_productionBetaRelease(j + ':' + str, j);
|
|
if (memoizedGuildExperiment$app_productionBetaRelease != null) {
|
|
return memoizedGuildExperiment$app_productionBetaRelease;
|
|
}
|
|
if (guildExperimentDto == null) {
|
|
return null;
|
|
}
|
|
int computeGuildExperimentBucket = ExperimentUtils.INSTANCE.computeGuildExperimentBucket(str, j, this.storeGuildMemberCounts.getApproximateMemberCount(j), this.storeGuilds.getGuild(j), guildExperimentDto);
|
|
int revision = guildExperimentDto.getRevision();
|
|
Experiment experiment = new Experiment(revision, computeGuildExperimentBucket, 0, false, new StoreExperiments$getGuildExperiment$experiment$1(this, str, j, computeGuildExperimentBucket, revision));
|
|
if (z2) {
|
|
experiment.getTrackExposure().mo1invoke();
|
|
}
|
|
memoizeGuildExperiment(str, j, experiment);
|
|
return experiment;
|
|
}
|
|
|
|
public final synchronized Experiment getMemoizedGuildExperiment$app_productionBetaRelease(String str, long j) {
|
|
m.checkNotNullParameter(str, "experimentName");
|
|
return this.memoizedGuildExperiments.get(str + ':' + j);
|
|
}
|
|
|
|
public final Experiment getUserExperiment(String str, boolean z2) {
|
|
m.checkNotNullParameter(str, "name");
|
|
long from = ExperimentHash.INSTANCE.from(str);
|
|
Integer num = this.experimentOverridesSnapshot.get(str);
|
|
UserExperimentDto userExperimentDto = this.userExperimentsSnapshot.get(Long.valueOf(from));
|
|
if (num != null) {
|
|
return new Experiment(userExperimentDto != null ? userExperimentDto.getRevision() : 0, num.intValue(), userExperimentDto != null ? userExperimentDto.getPopulation() : 0, true, StoreExperiments$getUserExperiment$1.INSTANCE);
|
|
} else if (userExperimentDto == null) {
|
|
return null;
|
|
} else {
|
|
int bucket = userExperimentDto.getBucket();
|
|
int population = userExperimentDto.getPopulation();
|
|
int revision = userExperimentDto.getRevision();
|
|
Experiment experiment = new Experiment(revision, bucket, population, false, new StoreExperiments$getUserExperiment$experiment$1(this, str, bucket, population, revision));
|
|
if (z2) {
|
|
experiment.getTrackExposure().mo1invoke();
|
|
}
|
|
return experiment;
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleAuthToken(String str) {
|
|
this.authToken = str;
|
|
reset();
|
|
tryInitializeExperiments();
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleConnectionOpen(ModelPayload modelPayload) {
|
|
m.checkNotNullParameter(modelPayload, "payload");
|
|
Map<Long, UserExperimentDto> experiments = modelPayload.getExperiments();
|
|
m.checkNotNullExpressionValue(experiments, "payload.experiments");
|
|
handleLoadedUserExperiments(experiments, true);
|
|
List<GuildExperimentDto> guildExperiments = modelPayload.getGuildExperiments();
|
|
if (guildExperiments != null) {
|
|
m.checkNotNullExpressionValue(guildExperiments, "it");
|
|
handleLoadedGuildExperiments(guildExperiments, true);
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleFingerprint(String str) {
|
|
this.fingerprint = str;
|
|
tryInitializeExperiments();
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handlePreLogout() {
|
|
StickerPickerFeatureFlag.Companion.getINSTANCE().clearCachedExperiment();
|
|
}
|
|
|
|
@Override // com.discord.stores.Store
|
|
@StoreThread
|
|
public void init(Context context) {
|
|
m.checkNotNullParameter(context, "context");
|
|
super.init(context);
|
|
this.experimentTrackedExposureTimestamps.putAll(loadCachedExperimentTrackedExposureTimestamps());
|
|
this.experimentOverrides.putAll(this.experimentOverridesCache.get());
|
|
handleLoadedUserExperiments(this.userExperimentsCache.get(), false);
|
|
handleLoadedGuildExperiments(this.guildExperimentsCache.get(), false);
|
|
markChanged(this, ExperimentOverridesUpdateSource);
|
|
}
|
|
|
|
public final Observable<Boolean> isInitialized() {
|
|
return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{InitializedUpdateSource}, false, null, null, new StoreExperiments$isInitialized$1(this), 14, null);
|
|
}
|
|
|
|
public final Observable<Experiment> observeGuildExperiment(String str, long j, boolean z2) {
|
|
m.checkNotNullParameter(str, "experimentName");
|
|
return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreExperiments$observeGuildExperiment$1(this, str, j, z2), 14, null);
|
|
}
|
|
|
|
public final Observable<Map<String, Integer>> observeOverrides() {
|
|
return ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{ExperimentOverridesUpdateSource}, false, null, null, new StoreExperiments$observeOverrides$1(this), 14, null);
|
|
}
|
|
|
|
public final Observable<Experiment> observeUserExperiment(String str, boolean z2) {
|
|
m.checkNotNullParameter(str, "name");
|
|
Observable<Experiment> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreExperiments$observeUserExperiment$1(this, str, z2), 14, null).r();
|
|
m.checkNotNullExpressionValue(r, "observationDeck.connectR… .distinctUntilChanged()");
|
|
return r;
|
|
}
|
|
|
|
public final void setOverride(String str, int i) {
|
|
m.checkNotNullParameter(str, "experimentName");
|
|
this.dispatcher.schedule(new StoreExperiments$setOverride$1(this, i, str));
|
|
}
|
|
|
|
@Override // com.discord.stores.StoreV2
|
|
@StoreThread
|
|
public void snapshotData() {
|
|
super.snapshotData();
|
|
this.userExperimentsSnapshot = new HashMap(this.userExperiments);
|
|
this.guildExperimentsSnapshot = new HashMap(this.guildExperiments);
|
|
if (getUpdateSources().contains(ExperimentOverridesUpdateSource)) {
|
|
this.experimentOverridesSnapshot = new HashMap(this.experimentOverrides);
|
|
this.experimentOverridesCache.set(this.experimentOverrides, true);
|
|
}
|
|
}
|
|
}
|