669 lines
28 KiB
Java
669 lines
28 KiB
Java
package com.discord.stores;
|
|
|
|
import a0.a.a.b;
|
|
import android.content.Context;
|
|
import c.d.b.a.a;
|
|
import com.airbnb.lottie.parser.AnimatableValueParser;
|
|
import com.discord.api.channel.Channel;
|
|
import com.discord.api.guild.Guild;
|
|
import com.discord.api.guildmember.GuildMember;
|
|
import com.discord.api.message.Message;
|
|
import com.discord.api.user.User;
|
|
import com.discord.api.utcdatetime.UtcDateTime;
|
|
import com.discord.models.domain.ModelPayload;
|
|
import com.discord.models.domain.ModelReadState;
|
|
import com.discord.stores.StoreThreadsActiveJoined;
|
|
import com.discord.stores.updates.ObservationDeck;
|
|
import com.discord.utilities.message.MessageUtils;
|
|
import com.discord.utilities.persister.Persister;
|
|
import com.discord.utilities.rest.RestAPI;
|
|
import com.discord.utilities.rx.ObservableExtensionsKt;
|
|
import com.discord.utilities.threads.ThreadUtils;
|
|
import d0.d0.f;
|
|
import d0.o;
|
|
import d0.t.n0;
|
|
import d0.t.o0;
|
|
import d0.z.d.m;
|
|
import j0.l.e.j;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.concurrent.TimeUnit;
|
|
import kotlin.NoWhenBranchMatchedException;
|
|
import kotlin.Pair;
|
|
import kotlin.Unit;
|
|
import kotlin.jvm.functions.Function0;
|
|
import kotlin.jvm.functions.Function1;
|
|
import kotlin.jvm.internal.DefaultConstructorMarker;
|
|
import rx.Observable;
|
|
import rx.Subscription;
|
|
/* compiled from: StoreMessageAck.kt */
|
|
public final class StoreMessageAck extends StoreV2 {
|
|
private final Map<Long, Ack> acks = new HashMap(this.acksSnapshot);
|
|
private final Persister<Map<Long, Ack>> acksPersister;
|
|
private Map<Long, Ack> acksSnapshot;
|
|
private final Dispatcher dispatcher;
|
|
private final ObservationDeck observationDeck;
|
|
private final RestAPI restAPI;
|
|
private final StoreStream stream;
|
|
private Subscription threadSyncSubscription;
|
|
|
|
/* compiled from: StoreMessageAck.kt */
|
|
public static final class Ack {
|
|
private final boolean isLockedAck;
|
|
private final long messageId;
|
|
private final boolean viewed;
|
|
|
|
public Ack(long j, boolean z2, boolean z3) {
|
|
this.messageId = j;
|
|
this.viewed = z2;
|
|
this.isLockedAck = z3;
|
|
}
|
|
|
|
/* JADX INFO: this call moved to the top of the method (can break code semantics) */
|
|
public Ack(ModelReadState modelReadState, boolean z2, boolean z3) {
|
|
this(modelReadState != null ? modelReadState.getLastMessageId() : 0, z2, z3);
|
|
}
|
|
|
|
public static /* synthetic */ Ack copy$default(Ack ack, long j, boolean z2, boolean z3, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
j = ack.messageId;
|
|
}
|
|
if ((i & 2) != 0) {
|
|
z2 = ack.viewed;
|
|
}
|
|
if ((i & 4) != 0) {
|
|
z3 = ack.isLockedAck;
|
|
}
|
|
return ack.copy(j, z2, z3);
|
|
}
|
|
|
|
public final long component1() {
|
|
return this.messageId;
|
|
}
|
|
|
|
public final boolean component2() {
|
|
return this.viewed;
|
|
}
|
|
|
|
public final boolean component3() {
|
|
return this.isLockedAck;
|
|
}
|
|
|
|
public final Ack copy(long j, boolean z2, boolean z3) {
|
|
return new Ack(j, z2, z3);
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof Ack)) {
|
|
return false;
|
|
}
|
|
Ack ack = (Ack) obj;
|
|
return this.messageId == ack.messageId && this.viewed == ack.viewed && this.isLockedAck == ack.isLockedAck;
|
|
}
|
|
|
|
public final long getMessageId() {
|
|
return this.messageId;
|
|
}
|
|
|
|
public final boolean getViewed() {
|
|
return this.viewed;
|
|
}
|
|
|
|
public int hashCode() {
|
|
int a = b.a(this.messageId) * 31;
|
|
boolean z2 = this.viewed;
|
|
int i = 1;
|
|
if (z2) {
|
|
z2 = true;
|
|
}
|
|
int i2 = z2 ? 1 : 0;
|
|
int i3 = z2 ? 1 : 0;
|
|
int i4 = z2 ? 1 : 0;
|
|
int i5 = (a + i2) * 31;
|
|
boolean z3 = this.isLockedAck;
|
|
if (!z3) {
|
|
i = z3 ? 1 : 0;
|
|
}
|
|
return i5 + i;
|
|
}
|
|
|
|
public final boolean isLockedAck() {
|
|
return this.isLockedAck;
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder L = a.L("Ack(messageId=");
|
|
L.append(this.messageId);
|
|
L.append(", viewed=");
|
|
L.append(this.viewed);
|
|
L.append(", isLockedAck=");
|
|
return a.G(L, this.isLockedAck, ")");
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreMessageAck.kt */
|
|
public static final class PendingAck {
|
|
public static final Companion Companion = new Companion(null);
|
|
private static final PendingAck EMPTY = new PendingAck(0, new Ack(0L, false, false));
|
|
private final Ack ack;
|
|
private final long channelId;
|
|
|
|
/* compiled from: StoreMessageAck.kt */
|
|
public static final class Companion {
|
|
private Companion() {
|
|
}
|
|
|
|
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
|
|
this();
|
|
}
|
|
|
|
public final PendingAck getEMPTY() {
|
|
return PendingAck.access$getEMPTY$cp();
|
|
}
|
|
}
|
|
|
|
public PendingAck(long j, Ack ack) {
|
|
m.checkNotNullParameter(ack, "ack");
|
|
this.channelId = j;
|
|
this.ack = ack;
|
|
}
|
|
|
|
public static final /* synthetic */ PendingAck access$getEMPTY$cp() {
|
|
return EMPTY;
|
|
}
|
|
|
|
public static /* synthetic */ PendingAck copy$default(PendingAck pendingAck, long j, Ack ack, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
j = pendingAck.channelId;
|
|
}
|
|
if ((i & 2) != 0) {
|
|
ack = pendingAck.ack;
|
|
}
|
|
return pendingAck.copy(j, ack);
|
|
}
|
|
|
|
public final long component1() {
|
|
return this.channelId;
|
|
}
|
|
|
|
public final Ack component2() {
|
|
return this.ack;
|
|
}
|
|
|
|
public final PendingAck copy(long j, Ack ack) {
|
|
m.checkNotNullParameter(ack, "ack");
|
|
return new PendingAck(j, ack);
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof PendingAck)) {
|
|
return false;
|
|
}
|
|
PendingAck pendingAck = (PendingAck) obj;
|
|
return this.channelId == pendingAck.channelId && m.areEqual(this.ack, pendingAck.ack);
|
|
}
|
|
|
|
public final Ack getAck() {
|
|
return this.ack;
|
|
}
|
|
|
|
public final long getChannelId() {
|
|
return this.channelId;
|
|
}
|
|
|
|
public int hashCode() {
|
|
int a = b.a(this.channelId) * 31;
|
|
Ack ack = this.ack;
|
|
return a + (ack != null ? ack.hashCode() : 0);
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder L = a.L("PendingAck(channelId=");
|
|
L.append(this.channelId);
|
|
L.append(", ack=");
|
|
L.append(this.ack);
|
|
L.append(")");
|
|
return L.toString();
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreMessageAck.kt */
|
|
public static abstract class ThreadState {
|
|
|
|
/* compiled from: StoreMessageAck.kt */
|
|
public static final class NotThread extends ThreadState {
|
|
public static final NotThread INSTANCE = new NotThread();
|
|
|
|
private NotThread() {
|
|
super(null);
|
|
}
|
|
}
|
|
|
|
/* compiled from: StoreMessageAck.kt */
|
|
public static final class Thread extends ThreadState {
|
|
private final boolean isActiveJoined;
|
|
|
|
public Thread(boolean z2) {
|
|
super(null);
|
|
this.isActiveJoined = z2;
|
|
}
|
|
|
|
public static /* synthetic */ Thread copy$default(Thread thread, boolean z2, int i, Object obj) {
|
|
if ((i & 1) != 0) {
|
|
z2 = thread.isActiveJoined;
|
|
}
|
|
return thread.copy(z2);
|
|
}
|
|
|
|
public final boolean component1() {
|
|
return this.isActiveJoined;
|
|
}
|
|
|
|
public final Thread copy(boolean z2) {
|
|
return new Thread(z2);
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
if (this != obj) {
|
|
return (obj instanceof Thread) && this.isActiveJoined == ((Thread) obj).isActiveJoined;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public int hashCode() {
|
|
boolean z2 = this.isActiveJoined;
|
|
if (z2) {
|
|
return 1;
|
|
}
|
|
return z2 ? 1 : 0;
|
|
}
|
|
|
|
public final boolean isActiveJoined() {
|
|
return this.isActiveJoined;
|
|
}
|
|
|
|
public String toString() {
|
|
return a.G(a.L("Thread(isActiveJoined="), this.isActiveJoined, ")");
|
|
}
|
|
}
|
|
|
|
private ThreadState() {
|
|
}
|
|
|
|
public /* synthetic */ ThreadState(DefaultConstructorMarker defaultConstructorMarker) {
|
|
this();
|
|
}
|
|
}
|
|
|
|
public StoreMessageAck(StoreStream storeStream, ObservationDeck observationDeck, Dispatcher dispatcher, RestAPI restAPI) {
|
|
m.checkNotNullParameter(storeStream, "stream");
|
|
m.checkNotNullParameter(observationDeck, "observationDeck");
|
|
m.checkNotNullParameter(dispatcher, "dispatcher");
|
|
m.checkNotNullParameter(restAPI, "restAPI");
|
|
this.stream = storeStream;
|
|
this.observationDeck = observationDeck;
|
|
this.dispatcher = dispatcher;
|
|
this.restAPI = restAPI;
|
|
Persister<Map<Long, Ack>> persister = new Persister<>("MOST_RECENT_ACKS_V3", new HashMap());
|
|
this.acksPersister = persister;
|
|
this.acksSnapshot = persister.get();
|
|
}
|
|
|
|
public static final /* synthetic */ Dispatcher access$getDispatcher$p(StoreMessageAck storeMessageAck) {
|
|
return storeMessageAck.dispatcher;
|
|
}
|
|
|
|
public static final /* synthetic */ RestAPI access$getRestAPI$p(StoreMessageAck storeMessageAck) {
|
|
return storeMessageAck.restAPI;
|
|
}
|
|
|
|
public static final /* synthetic */ StoreStream access$getStream$p(StoreMessageAck storeMessageAck) {
|
|
return storeMessageAck.stream;
|
|
}
|
|
|
|
public static final /* synthetic */ Subscription access$getThreadSyncSubscription$p(StoreMessageAck storeMessageAck) {
|
|
return storeMessageAck.threadSyncSubscription;
|
|
}
|
|
|
|
public static final /* synthetic */ void access$internalAck(StoreMessageAck storeMessageAck, Channel channel, boolean z2, boolean z3) {
|
|
storeMessageAck.internalAck(channel, z2, z3);
|
|
}
|
|
|
|
public static final /* synthetic */ Observable access$observeThreadState(StoreMessageAck storeMessageAck, long j) {
|
|
return storeMessageAck.observeThreadState(j);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$postPendingAck(StoreMessageAck storeMessageAck, Observable observable, int i) {
|
|
storeMessageAck.postPendingAck(observable, i);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$setThreadSyncSubscription$p(StoreMessageAck storeMessageAck, Subscription subscription) {
|
|
storeMessageAck.threadSyncSubscription = subscription;
|
|
}
|
|
|
|
public static final /* synthetic */ boolean access$shouldAck(StoreMessageAck storeMessageAck, ThreadState threadState) {
|
|
return storeMessageAck.shouldAck(threadState);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$updateAcks(StoreMessageAck storeMessageAck, long j, Ack ack) {
|
|
storeMessageAck.updateAcks(j, ack);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$updateThreadAcks(StoreMessageAck storeMessageAck, Set set, Set set2) {
|
|
storeMessageAck.updateThreadAcks(set, set2);
|
|
}
|
|
|
|
public static /* synthetic */ void ack$default(StoreMessageAck storeMessageAck, long j, boolean z2, boolean z3, int i, Object obj) {
|
|
if ((i & 4) != 0) {
|
|
z3 = false;
|
|
}
|
|
storeMessageAck.ack(j, z2, z3);
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r0v0, resolved type: com.discord.stores.StoreMessageAck */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public static /* synthetic */ void ackGuild$default(StoreMessageAck storeMessageAck, Context context, long j, Function0 function0, int i, Object obj) {
|
|
if ((i & 4) != 0) {
|
|
function0 = StoreMessageAck$ackGuild$1.INSTANCE;
|
|
}
|
|
storeMessageAck.ackGuild(context, j, function0);
|
|
}
|
|
|
|
private final Observable<PendingAck> getPendingAck(Observable<Long> observable, boolean z2, boolean z3) {
|
|
Observable<R> Y = observable.Y(new StoreMessageAck$getPendingAck$2(this, z2, new StoreMessageAck$getPendingAck$1(z3)));
|
|
m.checkNotNullExpressionValue(Y, "switchMap { channelId ->…gAck.EMPTY)\n }\n }");
|
|
return Y;
|
|
}
|
|
|
|
@StoreThread
|
|
private final ThreadState getThreadStateInternal(long j) {
|
|
return !this.stream.getChannels$app_productionBetaRelease().getThreadsByIdInternal$app_productionBetaRelease().containsKey(Long.valueOf(j)) ? ThreadState.NotThread.INSTANCE : new ThreadState.Thread(this.stream.getThreadsActiveJoined$app_productionBetaRelease().getActiveJoinedThreadsInternal$app_productionBetaRelease().containsKey(Long.valueOf(j)));
|
|
}
|
|
|
|
private final void internalAck(Channel channel, boolean z2, boolean z3) {
|
|
j jVar = new j(Long.valueOf(channel.h()));
|
|
m.checkNotNullExpressionValue(jVar, "Observable.just(channel.id)");
|
|
postPendingAck$default(this, ObservableExtensionsKt.takeSingleUntilTimeout$default(getPendingAck(jVar, z2, z3), 0, false, 1, null), 0, 1, null);
|
|
}
|
|
|
|
private final Observable<Pair<Set<Long>, Set<Long>>> observeActiveJoinedThreadIdsWithPrevious() {
|
|
Observable<Pair<Set<Long>, Set<Long>>> P = this.stream.getThreadsActiveJoined$app_productionBetaRelease().observeAllActiveJoinedThreadsById().F(StoreMessageAck$observeActiveJoinedThreadIdsWithPrevious$1.INSTANCE).r().P(new Pair(n0.emptySet(), n0.emptySet()), StoreMessageAck$observeActiveJoinedThreadIdsWithPrevious$2.INSTANCE);
|
|
m.checkNotNullExpressionValue(P, "stream\n .threadsA…oinedThreadIds)\n }");
|
|
return P;
|
|
}
|
|
|
|
private final Observable<ThreadState> observeThreadState(long j) {
|
|
Observable<ThreadState> r = this.stream.getChannels$app_productionBetaRelease().observeChannel(j).Y(new StoreMessageAck$observeThreadState$1(this, j)).r();
|
|
m.checkNotNullExpressionValue(r, "stream\n .channe… .distinctUntilChanged()");
|
|
return r;
|
|
}
|
|
|
|
private final void postPendingAck(Observable<PendingAck> observable, int i) {
|
|
StoreMessageAck$postPendingAck$1 storeMessageAck$postPendingAck$1 = new StoreMessageAck$postPendingAck$1(this, i);
|
|
Observable<PendingAck> x2 = observable.x(StoreMessageAck$postPendingAck$2.INSTANCE);
|
|
m.checkNotNullExpressionValue(x2, "filter { it != PendingAck.EMPTY }");
|
|
ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.computationLatest(x2), observable.getClass(), (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreMessageAck$postPendingAck$3(storeMessageAck$postPendingAck$1), 62, (Object) null);
|
|
}
|
|
|
|
public static /* synthetic */ void postPendingAck$default(StoreMessageAck storeMessageAck, Observable observable, int i, int i2, Object obj) {
|
|
if ((i2 & 1) != 0) {
|
|
i = 0;
|
|
}
|
|
storeMessageAck.postPendingAck(observable, i);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void pruneAcks() {
|
|
if (!(!this.stream.getGuilds$app_productionBetaRelease().getUnavailableGuildsInternal$app_productionBetaRelease().isEmpty())) {
|
|
Map<Long, Channel> channelsByIdInternal$app_productionBetaRelease = this.stream.getChannels$app_productionBetaRelease().getChannelsByIdInternal$app_productionBetaRelease();
|
|
Map<Long, StoreThreadsActiveJoined.ActiveJoinedThread> activeJoinedThreadsInternal$app_productionBetaRelease = this.stream.getThreadsActiveJoined$app_productionBetaRelease().getActiveJoinedThreadsInternal$app_productionBetaRelease();
|
|
Iterator<Long> it = this.acks.keySet().iterator();
|
|
while (it.hasNext()) {
|
|
long longValue = it.next().longValue();
|
|
if (!channelsByIdInternal$app_productionBetaRelease.containsKey(Long.valueOf(longValue)) && !activeJoinedThreadsInternal$app_productionBetaRelease.containsKey(Long.valueOf(longValue))) {
|
|
it.remove();
|
|
markChanged();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private final boolean shouldAck(ThreadState threadState) {
|
|
if (threadState instanceof ThreadState.NotThread) {
|
|
return true;
|
|
}
|
|
if (threadState instanceof ThreadState.Thread) {
|
|
return ((ThreadState.Thread) threadState).isActiveJoined();
|
|
}
|
|
throw new NoWhenBranchMatchedException();
|
|
}
|
|
|
|
@StoreThread
|
|
private final void updateAcks(long j, Ack ack) {
|
|
if (shouldAck(getThreadStateInternal(j))) {
|
|
Ack ack2 = this.acks.get(Long.valueOf(j));
|
|
if (ack2 == null || MessageUtils.compareMessages(Long.valueOf(ack2.getMessageId()), Long.valueOf(ack.getMessageId())) != 0 || (ack.isLockedAck() && !ack2.isLockedAck())) {
|
|
this.acks.put(Long.valueOf(j), ack);
|
|
markChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
private final void updateThreadAcks(Set<Long> set, Set<Long> set2) {
|
|
StoreThreadsActiveJoined.ActiveJoinedThread activeJoinedThread;
|
|
if (this.stream.getGuilds$app_productionBetaRelease().getUnavailableGuildsInternal$app_productionBetaRelease().isEmpty()) {
|
|
for (Number number : o0.minus((Set) set, (Iterable) set2)) {
|
|
long longValue = number.longValue();
|
|
if (this.acks.containsKey(Long.valueOf(longValue)) && this.acks.remove(Long.valueOf(longValue)) != null) {
|
|
markChanged();
|
|
}
|
|
}
|
|
}
|
|
Map<Long, Long> guildsJoinedAtInternal$app_productionBetaRelease = this.stream.getGuilds$app_productionBetaRelease().getGuildsJoinedAtInternal$app_productionBetaRelease();
|
|
Map<Long, StoreThreadsActiveJoined.ActiveJoinedThread> activeJoinedThreadsInternal$app_productionBetaRelease = this.stream.getThreadsActiveJoined$app_productionBetaRelease().getActiveJoinedThreadsInternal$app_productionBetaRelease();
|
|
for (Number number2 : o0.minus((Set) set2, (Iterable) set)) {
|
|
long longValue2 = number2.longValue();
|
|
if (!this.acks.containsKey(Long.valueOf(longValue2)) && (activeJoinedThread = activeJoinedThreadsInternal$app_productionBetaRelease.get(Long.valueOf(longValue2))) != null) {
|
|
this.acks.put(Long.valueOf(longValue2), new Ack((ThreadUtils.getThreadAckMessageTimestamp$default(ThreadUtils.INSTANCE, activeJoinedThread.getChannel(), guildsJoinedAtInternal$app_productionBetaRelease.get(Long.valueOf(activeJoinedThread.getChannel().f())), Long.valueOf(activeJoinedThread.getJoinTimestamp().f()), null, 4, null) - 1420070400000L) << 22, false, false));
|
|
markChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void ack(long j, boolean z2, boolean z3) {
|
|
this.dispatcher.schedule(new StoreMessageAck$ack$1(this, j, z2, z3));
|
|
}
|
|
|
|
public final void ackGuild(Context context, long j, Function0<Unit> function0) {
|
|
m.checkNotNullParameter(function0, "onSuccess");
|
|
ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn$default(this.restAPI.ackGuild(j), false, 1, null), context, "REST: ackGuild", (Function1) null, new StoreMessageAck$ackGuild$2(function0), (Function1) null, (Function0) null, (Function0) null, 116, (Object) null);
|
|
}
|
|
|
|
public final Map<Long, Ack> getAll() {
|
|
return this.acksSnapshot;
|
|
}
|
|
|
|
@StoreThread
|
|
public final Map<Long, Ack> getAllInternal() {
|
|
return this.acks;
|
|
}
|
|
|
|
public final Ack getForChannel(long j) {
|
|
return getAll().get(Long.valueOf(j));
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleChannelSelected() {
|
|
for (Map.Entry<Long, Ack> entry : this.acks.entrySet()) {
|
|
this.acks.put(Long.valueOf(entry.getKey().longValue()), Ack.copy$default(entry.getValue(), 0, false, false, 3, null));
|
|
}
|
|
markChanged();
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:59:0x00cf A[SYNTHETIC] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:62:0x007a A[SYNTHETIC] */
|
|
@StoreThread
|
|
public final void handleConnectionOpen(ModelPayload modelPayload) {
|
|
long j;
|
|
List<Channel> g;
|
|
Object obj;
|
|
UtcDateTime d;
|
|
boolean z2;
|
|
m.checkNotNullParameter(modelPayload, "payload");
|
|
ModelPayload.VersionedReadStates readState = modelPayload.getReadState();
|
|
m.checkNotNullExpressionValue(readState, "payload.readState");
|
|
if (!readState.isPartial()) {
|
|
this.acks.clear();
|
|
}
|
|
Map<Long, Ack> map = this.acks;
|
|
ModelPayload.VersionedReadStates readState2 = modelPayload.getReadState();
|
|
m.checkNotNullExpressionValue(readState2, "payload.readState");
|
|
List<ModelReadState> entries = readState2.getEntries();
|
|
m.checkNotNullExpressionValue(entries, "payload.readState.entries");
|
|
LinkedHashMap linkedHashMap = new LinkedHashMap(a.I(entries, 10, 16));
|
|
for (ModelReadState modelReadState : entries) {
|
|
Pair pair = o.to(Long.valueOf(modelReadState.getChannelId()), new Ack(modelReadState, false, false));
|
|
linkedHashMap.put(pair.getFirst(), pair.getSecond());
|
|
}
|
|
map.putAll(linkedHashMap);
|
|
List<Guild> guilds = modelPayload.getGuilds();
|
|
m.checkNotNullExpressionValue(guilds, "payload.guilds");
|
|
for (Guild guild : guilds) {
|
|
List<GuildMember> s2 = guild.s();
|
|
if (s2 != null) {
|
|
Iterator<T> it = s2.iterator();
|
|
while (true) {
|
|
if (!it.hasNext()) {
|
|
obj = null;
|
|
break;
|
|
}
|
|
obj = it.next();
|
|
if (((GuildMember) obj).j().i() == modelPayload.getMe().i()) {
|
|
z2 = true;
|
|
continue;
|
|
} else {
|
|
z2 = false;
|
|
continue;
|
|
}
|
|
if (z2) {
|
|
break;
|
|
}
|
|
}
|
|
GuildMember guildMember = (GuildMember) obj;
|
|
if (!(guildMember == null || (d = guildMember.d()) == null)) {
|
|
j = d.f();
|
|
g = guild.g();
|
|
if (g == null) {
|
|
ArrayList arrayList = new ArrayList();
|
|
for (Object obj2 : g) {
|
|
Channel channel = (Channel) obj2;
|
|
if (AnimatableValueParser.k1(channel) && !this.acks.containsKey(Long.valueOf(channel.h()))) {
|
|
arrayList.add(obj2);
|
|
}
|
|
}
|
|
ArrayList<Channel> arrayList2 = new ArrayList();
|
|
for (Object obj3 : arrayList) {
|
|
if ((((Channel) obj3).i() >>> 22) + 1420070400000L < j) {
|
|
arrayList2.add(obj3);
|
|
}
|
|
}
|
|
for (Channel channel2 : arrayList2) {
|
|
this.acks.put(Long.valueOf(channel2.h()), new Ack(channel2.i(), false, false));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
j = 0;
|
|
g = guild.g();
|
|
if (g == null) {
|
|
}
|
|
}
|
|
pruneAcks();
|
|
Subscription subscription = this.threadSyncSubscription;
|
|
if (subscription != null) {
|
|
subscription.unsubscribe();
|
|
}
|
|
ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.computationLatest(observeActiveJoinedThreadIdsWithPrevious()), StoreMessageAck.class, (Context) null, new StoreMessageAck$handleConnectionOpen$3(this), (Function1) null, (Function0) null, (Function0) null, new StoreMessageAck$handleConnectionOpen$4(this), 58, (Object) null);
|
|
markChanged();
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleGuildCreate() {
|
|
pruneAcks();
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleMessageAck(ModelReadState modelReadState) {
|
|
m.checkNotNullParameter(modelReadState, "readState");
|
|
updateAcks(modelReadState.getChannelId(), new Ack(modelReadState, false, false));
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleMessageCreate(Message message) {
|
|
m.checkNotNullParameter(message, "message");
|
|
User e = message.e();
|
|
if (e != null && e.i() == this.stream.getUsers$app_productionBetaRelease().getMeInternal$app_productionBetaRelease().getId()) {
|
|
updateAcks(message.g(), new Ack(message.o(), false, false));
|
|
}
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handlePreLogout() {
|
|
Subscription subscription = this.threadSyncSubscription;
|
|
if (subscription != null) {
|
|
subscription.unsubscribe();
|
|
}
|
|
this.threadSyncSubscription = null;
|
|
}
|
|
|
|
@Override // com.discord.stores.Store
|
|
public void init(Context context) {
|
|
m.checkNotNullParameter(context, "context");
|
|
super.init(context);
|
|
Observable<R> Y = StoreStream.Companion.getChannelsSelected().observeId().r().Y(new StoreMessageAck$init$1(this));
|
|
m.checkNotNullExpressionValue(Y, "StoreStream\n .get… 0L\n }\n }");
|
|
Observable<Long> o = ObservableExtensionsKt.computationLatest(Y).o(500, TimeUnit.MILLISECONDS);
|
|
m.checkNotNullExpressionValue(o, "StoreStream\n .get…0, TimeUnit.MILLISECONDS)");
|
|
postPendingAck$default(this, getPendingAck(o, false, false), 0, 1, null);
|
|
}
|
|
|
|
public final void markUnread(long j, long j2) {
|
|
Observable j3 = Observable.j(this.stream.getMessages$app_productionBetaRelease().observeMessagesForChannel(j).x(StoreMessageAck$markUnread$1.INSTANCE), observeThreadState(j), StoreMessageAck$markUnread$2.INSTANCE);
|
|
m.checkNotNullExpressionValue(j3, "Observable\n .comb…lMessages, threadState) }");
|
|
ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.takeSingleUntilTimeout(j3, 10, false), StoreMessageAck.class, (Context) null, (Function1) null, (Function1) null, (Function0) null, (Function0) null, new StoreMessageAck$markUnread$3(this, j2, j), 62, (Object) null);
|
|
}
|
|
|
|
public final Observable<Map<Long, Ack>> observeAll() {
|
|
Observable<Map<Long, Ack>> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreMessageAck$observeAll$1(this), 14, null).r();
|
|
m.checkNotNullExpressionValue(r, "observationDeck.connectR… .distinctUntilChanged()");
|
|
return r;
|
|
}
|
|
|
|
public final Observable<Ack> observeForChannel(long j) {
|
|
Observable<Ack> r = ObservationDeck.connectRx$default(this.observationDeck, new ObservationDeck.UpdateSource[]{this}, false, null, null, new StoreMessageAck$observeForChannel$1(this, j), 14, null).r();
|
|
m.checkNotNullExpressionValue(r, "observationDeck.connectR… .distinctUntilChanged()");
|
|
return r;
|
|
}
|
|
|
|
@Override // com.discord.stores.StoreV2
|
|
public void snapshotData() {
|
|
super.snapshotData();
|
|
HashMap hashMap = new HashMap(f.coerceAtLeast(this.acks.size(), 1), 0.75f);
|
|
hashMap.putAll(this.acks);
|
|
this.acksSnapshot = hashMap;
|
|
Persister.set$default(this.acksPersister, hashMap, false, 2, null);
|
|
}
|
|
}
|