728 lines
38 KiB
Java
728 lines
38 KiB
Java
package com.discord.stores;
|
|
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.net.Uri;
|
|
import androidx.work.Operation;
|
|
import androidx.work.WorkManager;
|
|
import com.discord.api.activity.Activity;
|
|
import com.discord.api.application.Application;
|
|
import com.discord.api.interaction.InteractionStateUpdate;
|
|
import com.discord.api.message.MessageReference;
|
|
import com.discord.api.message.activity.MessageActivity;
|
|
import com.discord.api.message.reaction.MessageReactionUpdate;
|
|
import com.discord.api.sticker.Sticker;
|
|
import com.discord.app.AppLog;
|
|
import com.discord.models.commands.ApplicationCommandLocalSendData;
|
|
import com.discord.models.domain.ModelAllowedMentions;
|
|
import com.discord.models.domain.ModelMessage;
|
|
import com.discord.models.domain.ModelMessageDelete;
|
|
import com.discord.models.domain.ModelPayload;
|
|
import com.discord.models.messages.LocalAttachment;
|
|
import com.discord.models.user.CoreUser;
|
|
import com.discord.models.user.User;
|
|
import com.discord.stores.StoreMessagesLoader;
|
|
import com.discord.utilities.attachments.AttachmentUtilsKt;
|
|
import com.discord.utilities.logging.Logger;
|
|
import com.discord.utilities.messagesend.MessageQueue;
|
|
import com.discord.utilities.messagesend.MessageRequest;
|
|
import com.discord.utilities.messagesend.MessageResult;
|
|
import com.discord.utilities.rest.ProcessedMessageContent;
|
|
import com.discord.utilities.rest.RestAPI;
|
|
import com.discord.utilities.rest.SendUtilsKt;
|
|
import com.discord.utilities.rx.ObservableExtensionsKt;
|
|
import com.discord.utilities.time.Clock;
|
|
import com.discord.utilities.user.UserUtils;
|
|
import com.lytefast.flexinput.model.Attachment;
|
|
import d0.t.o;
|
|
import d0.t.u;
|
|
import d0.z.d.m;
|
|
import j0.l.a.q;
|
|
import j0.l.a.r;
|
|
import j0.l.a.u0;
|
|
import j0.l.a.x0;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.TreeMap;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
import kotlin.jvm.functions.Function0;
|
|
import kotlin.jvm.functions.Function1;
|
|
import kotlin.jvm.internal.DefaultConstructorMarker;
|
|
import kotlin.jvm.internal.Ref$ObjectRef;
|
|
import rx.Emitter;
|
|
import rx.Observable;
|
|
import rx.subjects.BehaviorSubject;
|
|
/* compiled from: StoreMessages.kt */
|
|
public final class StoreMessages extends Store {
|
|
private static final long BACKGROUND_SENDING_DELAY_MS = 120000;
|
|
public static final Companion Companion = new Companion(null);
|
|
private final Clock clock;
|
|
private Context context;
|
|
private final Dispatcher dispatcher;
|
|
private final StoreMessagesHolder holder = new StoreMessagesHolder();
|
|
private final BehaviorSubject<Boolean> initResendFinished = BehaviorSubject.m0(Boolean.FALSE);
|
|
private final StoreLocalMessagesHolder localMessagesHolder = new StoreLocalMessagesHolder();
|
|
private final HashMap<Long, MessageQueue> messageQueues = new HashMap<>();
|
|
private final ExecutorService queueExecutor = Executors.newSingleThreadExecutor();
|
|
private final StoreStream stream;
|
|
|
|
/* compiled from: StoreMessages.kt */
|
|
public static final class Companion {
|
|
private Companion() {
|
|
}
|
|
|
|
public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
|
|
this();
|
|
}
|
|
|
|
public static final /* synthetic */ Operation access$cancelBackgroundSendingWork(Companion companion, Context context) {
|
|
return companion.cancelBackgroundSendingWork(context);
|
|
}
|
|
|
|
private final Operation cancelBackgroundSendingWork(Context context) {
|
|
Operation cancelUniqueWork = WorkManager.getInstance(context).cancelUniqueWork("BACKGROUND_MESSAGE_SENDING");
|
|
m.checkNotNullExpressionValue(cancelUniqueWork, "WorkManager.getInstance(…dWorker.UNIQUE_WORK_NAME)");
|
|
return cancelUniqueWork;
|
|
}
|
|
}
|
|
|
|
public StoreMessages(StoreStream storeStream, Dispatcher dispatcher, Clock clock) {
|
|
m.checkNotNullParameter(storeStream, "stream");
|
|
m.checkNotNullParameter(dispatcher, "dispatcher");
|
|
m.checkNotNullParameter(clock, "clock");
|
|
this.stream = storeStream;
|
|
this.dispatcher = dispatcher;
|
|
this.clock = clock;
|
|
}
|
|
|
|
public static final /* synthetic */ Context access$getContext$p(StoreMessages storeMessages) {
|
|
Context context = storeMessages.context;
|
|
if (context == null) {
|
|
m.throwUninitializedPropertyAccessException("context");
|
|
}
|
|
return context;
|
|
}
|
|
|
|
public static final /* synthetic */ Dispatcher access$getDispatcher$p(StoreMessages storeMessages) {
|
|
return storeMessages.dispatcher;
|
|
}
|
|
|
|
public static final /* synthetic */ BehaviorSubject access$getInitResendFinished$p(StoreMessages storeMessages) {
|
|
return storeMessages.initResendFinished;
|
|
}
|
|
|
|
public static final /* synthetic */ MessageQueue access$getMessageQueue(StoreMessages storeMessages, long j) {
|
|
return storeMessages.getMessageQueue(j);
|
|
}
|
|
|
|
public static final /* synthetic */ StoreStream access$getStream$p(StoreMessages storeMessages) {
|
|
return storeMessages.stream;
|
|
}
|
|
|
|
public static final /* synthetic */ void access$handleLocalMessageCreate(StoreMessages storeMessages, ModelMessage modelMessage) {
|
|
storeMessages.handleLocalMessageCreate(modelMessage);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$handleLocalMessageDelete(StoreMessages storeMessages, ModelMessage modelMessage) {
|
|
storeMessages.handleLocalMessageDelete(modelMessage);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$handleSendMessageFailure(StoreMessages storeMessages, ModelMessage modelMessage) {
|
|
storeMessages.handleSendMessageFailure(modelMessage);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$handleSendMessageValidationError(StoreMessages storeMessages, ModelMessage modelMessage, String str) {
|
|
storeMessages.handleSendMessageValidationError(modelMessage, str);
|
|
}
|
|
|
|
public static final /* synthetic */ void access$setContext$p(StoreMessages storeMessages, Context context) {
|
|
storeMessages.context = context;
|
|
}
|
|
|
|
public static final /* synthetic */ void access$trackFailedLocalMessageResolved(StoreMessages storeMessages, ModelMessage modelMessage, FailedMessageResolutionType failedMessageResolutionType) {
|
|
storeMessages.trackFailedLocalMessageResolved(modelMessage, failedMessageResolutionType);
|
|
}
|
|
|
|
private final synchronized MessageQueue getMessageQueue(long j) {
|
|
MessageQueue messageQueue;
|
|
messageQueue = this.messageQueues.get(Long.valueOf(j));
|
|
if (messageQueue == null) {
|
|
Context context = this.context;
|
|
if (context == null) {
|
|
m.throwUninitializedPropertyAccessException("context");
|
|
}
|
|
ContentResolver contentResolver = context.getContentResolver();
|
|
m.checkNotNullExpressionValue(contentResolver, "context.contentResolver");
|
|
ExecutorService executorService = this.queueExecutor;
|
|
m.checkNotNullExpressionValue(executorService, "queueExecutor");
|
|
messageQueue = new MessageQueue(contentResolver, executorService, this.clock);
|
|
this.messageQueues.put(Long.valueOf(j), messageQueue);
|
|
}
|
|
return messageQueue;
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleInteractionStateUpdate(InteractionStateUpdate interactionStateUpdate, boolean z2, boolean z3) {
|
|
ModelMessage message;
|
|
ApplicationCommandLocalSendData applicationCommandLocalSendData = this.stream.getApplicationInteractions$app_productionGoogleRelease().getApplicationCommandLocalSendDataSet$app_productionGoogleRelease().get(interactionStateUpdate.b());
|
|
if (applicationCommandLocalSendData != null && (message = this.localMessagesHolder.getMessage(applicationCommandLocalSendData.getChannelId(), applicationCommandLocalSendData.getNonceString())) != null) {
|
|
ModelMessage createLocalApplicationCommandMessage = ModelMessage.createLocalApplicationCommandMessage(message, interactionStateUpdate.a(), z2, z3, this.clock);
|
|
StoreLocalMessagesHolder storeLocalMessagesHolder = this.localMessagesHolder;
|
|
m.checkNotNullExpressionValue(createLocalApplicationCommandMessage, "updatedMessage");
|
|
storeLocalMessagesHolder.addMessage(createLocalApplicationCommandMessage);
|
|
}
|
|
}
|
|
|
|
public static /* synthetic */ void handleInteractionStateUpdate$default(StoreMessages storeMessages, InteractionStateUpdate interactionStateUpdate, boolean z2, boolean z3, int i, Object obj) {
|
|
if ((i & 2) != 0) {
|
|
z2 = false;
|
|
}
|
|
if ((i & 4) != 0) {
|
|
z3 = false;
|
|
}
|
|
storeMessages.handleInteractionStateUpdate(interactionStateUpdate, z2, z3);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleLocalMessageCreate(ModelMessage modelMessage) {
|
|
this.localMessagesHolder.addMessage(modelMessage);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleLocalMessageDelete(long j, String str) {
|
|
this.localMessagesHolder.deleteMessage(j, str);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleLocalMessageDelete(ModelMessage modelMessage) {
|
|
this.localMessagesHolder.deleteMessage(modelMessage);
|
|
}
|
|
|
|
private final void handleMessageDelete(long j, List<Long> list) {
|
|
this.holder.deleteMessages(j, list);
|
|
}
|
|
|
|
@StoreThread
|
|
private final void handleSendMessageFailure(ModelMessage modelMessage) {
|
|
deleteMessage(modelMessage);
|
|
ModelMessage createLocalMessage = ModelMessage.createLocalMessage(modelMessage.getContent(), modelMessage.getChannelId(), modelMessage.getAuthor(), modelMessage.getMentions(), true, modelMessage.isHasLocalUploads(), modelMessage.getApplication(), modelMessage.getActivity(), this.clock, modelMessage.localAttachments, modelMessage.getLastManualAttemptTimestamp(), modelMessage.getInitialAttemptTimestamp(), modelMessage.getNumRetries(), modelMessage.getStickers(), modelMessage.getMessageReference(), modelMessage.getAllowedMentions());
|
|
m.checkNotNullExpressionValue(createLocalMessage, "failedMessage");
|
|
handleLocalMessageCreate(createLocalMessage);
|
|
}
|
|
|
|
private final void handleSendMessageValidationError(ModelMessage modelMessage, String str) {
|
|
Logger.e$default(AppLog.g, "ValidationError", str, null, null, 12, null);
|
|
deleteMessage(modelMessage);
|
|
}
|
|
|
|
private final Observable<List<ModelMessage>> observeLocalMessagesForChannel(long j) {
|
|
Observable<R> G = this.localMessagesHolder.getMessagesPublisher().G(new StoreMessages$observeLocalMessagesForChannel$1(j));
|
|
m.checkNotNullExpressionValue(G, "localMessagesHolder\n …annelId] ?: emptyList() }");
|
|
Observable computationBuffered = ObservableExtensionsKt.computationBuffered(G);
|
|
Observable<List<ModelMessage>> i02 = Observable.i0(new r(computationBuffered.i, new u0(StoreMessages$observeLocalMessagesForChannel$2.INSTANCE)));
|
|
m.checkNotNullExpressionValue(i02, "localMessagesHolder\n …messages1 === messages2 }");
|
|
return i02;
|
|
}
|
|
|
|
private final Observable<List<ModelMessage>> observeSyncedMessagesForChannel(long j) {
|
|
Observable<R> G = this.holder.getMessagesPublisher().G(new StoreMessages$observeSyncedMessagesForChannel$1(j));
|
|
m.checkNotNullExpressionValue(G, "holder\n .messag…annelId] ?: emptyList() }");
|
|
Observable computationBuffered = ObservableExtensionsKt.computationBuffered(G);
|
|
Observable<List<ModelMessage>> i02 = Observable.i0(new r(computationBuffered.i, new u0(StoreMessages$observeSyncedMessagesForChannel$2.INSTANCE)));
|
|
m.checkNotNullExpressionValue(i02, "holder\n .messag…messages1 === messages2 }");
|
|
return i02;
|
|
}
|
|
|
|
@StoreThread
|
|
private final void resendAllLocalMessages() {
|
|
List<ModelMessage> flattenedMessages = this.localMessagesHolder.getFlattenedMessages();
|
|
ArrayList<ModelMessage> arrayList = new ArrayList();
|
|
Iterator<T> it = flattenedMessages.iterator();
|
|
while (true) {
|
|
boolean z2 = true;
|
|
if (!it.hasNext()) {
|
|
break;
|
|
}
|
|
Object next = it.next();
|
|
if (((ModelMessage) next).getType() != -1) {
|
|
z2 = false;
|
|
}
|
|
if (z2) {
|
|
arrayList.add(next);
|
|
}
|
|
}
|
|
ArrayList arrayList2 = new ArrayList(o.collectionSizeOrDefault(arrayList, 10));
|
|
for (ModelMessage modelMessage : arrayList) {
|
|
arrayList2.add(resendMessage(modelMessage, true));
|
|
}
|
|
Observable i02 = Observable.i0(new q(arrayList2));
|
|
Observable i03 = Observable.i0(new r(i02.i, x0.a.a));
|
|
m.checkNotNullExpressionValue(i03, "Observable\n .mergeDelayError(observables)");
|
|
ObservableExtensionsKt.appSubscribe$default(i03, StoreMessages.class, (Context) null, (Function1) null, (Function1) null, new StoreMessages$resendAllLocalMessages$1(this), (Function0) null, StoreMessages$resendAllLocalMessages$2.INSTANCE, 46, (Object) null);
|
|
}
|
|
|
|
public static /* synthetic */ Observable resendMessage$default(StoreMessages storeMessages, ModelMessage modelMessage, boolean z2, int i, Object obj) {
|
|
if ((i & 2) != 0) {
|
|
z2 = false;
|
|
}
|
|
return storeMessages.resendMessage(modelMessage, z2);
|
|
}
|
|
|
|
public static /* synthetic */ Observable sendMessage$default(StoreMessages storeMessages, long j, User user, String str, List list, List list2, List list3, MessageReference messageReference, ModelAllowedMentions modelAllowedMentions, Application application, Activity activity, MessageActivity messageActivity, Long l, Long l2, Integer num, int i, Object obj) {
|
|
return storeMessages.sendMessage(j, user, str, list, list2, (i & 32) != 0 ? null : list3, (i & 64) != 0 ? null : messageReference, (i & 128) != 0 ? null : modelAllowedMentions, (i & 256) != 0 ? null : application, (i & 512) != 0 ? null : activity, (i & 1024) != 0 ? null : messageActivity, (i & 2048) != 0 ? null : l, (i & 4096) != 0 ? null : l2, (i & 8192) != 0 ? null : num);
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:15:0x0042 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:19:0x0049 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:36:0x0082 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:43:0x00c4 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:45:0x00c7 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:50:0x00d9 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:51:0x00e0 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:54:0x00eb */
|
|
/* JADX WARNING: Removed duplicated region for block: B:55:0x00f1 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:58:0x00f9 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:61:0x010f */
|
|
private final void trackFailedLocalMessageResolved(ModelMessage modelMessage, FailedMessageResolutionType failedMessageResolutionType) {
|
|
boolean z2;
|
|
List<LocalAttachment> list;
|
|
boolean z3;
|
|
List<LocalAttachment> list2;
|
|
ArrayList arrayList;
|
|
Long initialAttemptTimestamp;
|
|
Integer numRetries;
|
|
Long l;
|
|
boolean z4;
|
|
boolean z5;
|
|
List<LocalAttachment> list3 = modelMessage.localAttachments;
|
|
if (list3 != null) {
|
|
if (!list3.isEmpty()) {
|
|
Iterator<T> it = list3.iterator();
|
|
while (true) {
|
|
if (!it.hasNext()) {
|
|
break;
|
|
}
|
|
LocalAttachment localAttachment = (LocalAttachment) it.next();
|
|
m.checkNotNullExpressionValue(localAttachment, "localAttachment");
|
|
Context context = this.context;
|
|
if (context == null) {
|
|
m.throwUninitializedPropertyAccessException("context");
|
|
}
|
|
ContentResolver contentResolver = context.getContentResolver();
|
|
m.checkNotNullExpressionValue(contentResolver, "context.contentResolver");
|
|
if (AttachmentUtilsKt.isImageAttachment(localAttachment, contentResolver)) {
|
|
z5 = true;
|
|
break;
|
|
}
|
|
}
|
|
if (z5) {
|
|
z2 = true;
|
|
list = modelMessage.localAttachments;
|
|
if (list != null) {
|
|
if (!list.isEmpty()) {
|
|
Iterator<T> it2 = list.iterator();
|
|
while (true) {
|
|
if (!it2.hasNext()) {
|
|
break;
|
|
}
|
|
LocalAttachment localAttachment2 = (LocalAttachment) it2.next();
|
|
m.checkNotNullExpressionValue(localAttachment2, "localAttachment");
|
|
Context context2 = this.context;
|
|
if (context2 == null) {
|
|
m.throwUninitializedPropertyAccessException("context");
|
|
}
|
|
ContentResolver contentResolver2 = context2.getContentResolver();
|
|
m.checkNotNullExpressionValue(contentResolver2, "context.contentResolver");
|
|
if (AttachmentUtilsKt.isVideoAttachment(localAttachment2, contentResolver2)) {
|
|
z4 = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
z4 = false;
|
|
if (z4) {
|
|
z3 = true;
|
|
list2 = modelMessage.localAttachments;
|
|
if (list2 != null) {
|
|
arrayList = new ArrayList(o.collectionSizeOrDefault(list2, 10));
|
|
for (LocalAttachment localAttachment3 : list2) {
|
|
Uri parse = Uri.parse(localAttachment3.getUriString());
|
|
m.checkNotNullExpressionValue(parse, "Uri.parse(localAttachment.uriString)");
|
|
Context context3 = this.context;
|
|
if (context3 == null) {
|
|
m.throwUninitializedPropertyAccessException("context");
|
|
}
|
|
ContentResolver contentResolver3 = context3.getContentResolver();
|
|
m.checkNotNullExpressionValue(contentResolver3, "context.contentResolver");
|
|
arrayList.add(Long.valueOf(SendUtilsKt.computeFileSizeBytes(parse, contentResolver3)));
|
|
}
|
|
} else {
|
|
arrayList = null;
|
|
}
|
|
int longValue = (arrayList != null || (l = (Long) u.maxOrNull(arrayList)) == null) ? 0 : (int) l.longValue();
|
|
int sumOfLong = arrayList != null ? (int) u.sumOfLong(arrayList) : 0;
|
|
StoreAnalytics analytics = StoreStream.Companion.getAnalytics();
|
|
List<LocalAttachment> list4 = modelMessage.localAttachments;
|
|
int size = list4 != null ? list4.size() : 0;
|
|
initialAttemptTimestamp = modelMessage.getInitialAttemptTimestamp();
|
|
if (initialAttemptTimestamp == null) {
|
|
initialAttemptTimestamp = 0L;
|
|
}
|
|
m.checkNotNullExpressionValue(initialAttemptTimestamp, "localMessage.initialAttemptTimestamp ?: 0L");
|
|
long longValue2 = initialAttemptTimestamp.longValue();
|
|
numRetries = modelMessage.getNumRetries();
|
|
if (numRetries == null) {
|
|
numRetries = 0;
|
|
}
|
|
m.checkNotNullExpressionValue(numRetries, "localMessage.numRetries ?: 0");
|
|
analytics.trackFailedMessageResolved(size, longValue, sumOfLong, z2, z3, failedMessageResolutionType, longValue2, numRetries.intValue(), modelMessage.getChannelId());
|
|
}
|
|
}
|
|
z3 = false;
|
|
list2 = modelMessage.localAttachments;
|
|
if (list2 != null) {
|
|
}
|
|
if (arrayList != null) {
|
|
}
|
|
if (arrayList != null) {
|
|
}
|
|
StoreAnalytics analytics = StoreStream.Companion.getAnalytics();
|
|
List<LocalAttachment> list4 = modelMessage.localAttachments;
|
|
if (list4 != null) {
|
|
}
|
|
initialAttemptTimestamp = modelMessage.getInitialAttemptTimestamp();
|
|
if (initialAttemptTimestamp == null) {
|
|
}
|
|
m.checkNotNullExpressionValue(initialAttemptTimestamp, "localMessage.initialAttemptTimestamp ?: 0L");
|
|
long longValue2 = initialAttemptTimestamp.longValue();
|
|
numRetries = modelMessage.getNumRetries();
|
|
if (numRetries == null) {
|
|
}
|
|
m.checkNotNullExpressionValue(numRetries, "localMessage.numRetries ?: 0");
|
|
analytics.trackFailedMessageResolved(size, longValue, sumOfLong, z2, z3, failedMessageResolutionType, longValue2, numRetries.intValue(), modelMessage.getChannelId());
|
|
}
|
|
}
|
|
z5 = false;
|
|
if (z5) {
|
|
}
|
|
}
|
|
z2 = false;
|
|
list = modelMessage.localAttachments;
|
|
if (list != null) {
|
|
}
|
|
z3 = false;
|
|
list2 = modelMessage.localAttachments;
|
|
if (list2 != null) {
|
|
}
|
|
if (arrayList != null) {
|
|
}
|
|
if (arrayList != null) {
|
|
}
|
|
StoreAnalytics analytics = StoreStream.Companion.getAnalytics();
|
|
List<LocalAttachment> list4 = modelMessage.localAttachments;
|
|
if (list4 != null) {
|
|
}
|
|
initialAttemptTimestamp = modelMessage.getInitialAttemptTimestamp();
|
|
if (initialAttemptTimestamp == null) {
|
|
}
|
|
m.checkNotNullExpressionValue(initialAttemptTimestamp, "localMessage.initialAttemptTimestamp ?: 0L");
|
|
long longValue2 = initialAttemptTimestamp.longValue();
|
|
numRetries = modelMessage.getNumRetries();
|
|
if (numRetries == null) {
|
|
}
|
|
m.checkNotNullExpressionValue(numRetries, "localMessage.numRetries ?: 0");
|
|
analytics.trackFailedMessageResolved(size, longValue, sumOfLong, z2, z3, failedMessageResolutionType, longValue2, numRetries.intValue(), modelMessage.getChannelId());
|
|
}
|
|
|
|
public final void cancelMessageSend(long j, String str) {
|
|
m.checkNotNullParameter(str, "requestId");
|
|
getMessageQueue(j).cancel(str);
|
|
}
|
|
|
|
@StoreThread
|
|
public final void deleteLocalMessage(long j, String str) {
|
|
m.checkNotNullParameter(str, "nonce");
|
|
getMessageQueue(j).cancel(str);
|
|
handleLocalMessageDelete(j, str);
|
|
}
|
|
|
|
public final void deleteMessage(ModelMessage modelMessage) {
|
|
if (modelMessage != null) {
|
|
long id2 = modelMessage.getId();
|
|
long channelId = modelMessage.getChannelId();
|
|
if (modelMessage.isLocal() || modelMessage.isEphemeralMessage()) {
|
|
this.dispatcher.schedule(new StoreMessages$deleteMessage$2(this, modelMessage, channelId, id2));
|
|
} else {
|
|
ObservableExtensionsKt.appSubscribe$default(ObservableExtensionsKt.restSubscribeOn$default(RestAPI.Companion.getApi().deleteMessage(channelId, id2), false, 1, null), (Context) null, "deleteMessage", (Function1) null, StoreMessages$deleteMessage$1.INSTANCE, (Function1) null, (Function0) null, (Function0) null, 117, (Object) null);
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void editMessage(long j, long j2, String str, ModelAllowedMentions modelAllowedMentions) {
|
|
m.checkNotNullParameter(str, "content");
|
|
getMessageQueue(j2).enqueue(new MessageRequest.Edit(j2, str, j, modelAllowedMentions, this.clock.currentTimeMillis()));
|
|
}
|
|
|
|
public final Observable<Set<Long>> getAllDetached() {
|
|
Observable<Set<Long>> detachedChannelSubject = this.holder.getDetachedChannelSubject();
|
|
m.checkNotNullExpressionValue(detachedChannelSubject, "holder\n .detachedChannelSubject");
|
|
return ObservableExtensionsKt.computationLatest(detachedChannelSubject);
|
|
}
|
|
|
|
@StoreThread
|
|
public final ModelMessage getMessage(long j, long j2) {
|
|
TreeMap<Long, ModelMessage> messagesForChannel = this.holder.getMessagesForChannel(Long.valueOf(j));
|
|
if (messagesForChannel != null) {
|
|
return messagesForChannel.get(Long.valueOf(j2));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public final void handleChannelSelected(long j) {
|
|
this.holder.setSelectedChannelId(j);
|
|
}
|
|
|
|
public final void handleConnected(boolean z2) {
|
|
if (!z2) {
|
|
this.holder.invalidate();
|
|
return;
|
|
}
|
|
Collection<MessageQueue> values = this.messageQueues.values();
|
|
m.checkNotNullExpressionValue(values, "messageQueues.values");
|
|
for (MessageQueue messageQueue : values) {
|
|
messageQueue.handleConnected();
|
|
}
|
|
}
|
|
|
|
public final void handleConnectionOpen(ModelPayload modelPayload) {
|
|
m.checkNotNullParameter(modelPayload, "payload");
|
|
this.holder.setMyUserId(modelPayload.getMe().i());
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleInteractionCreate(InteractionStateUpdate interactionStateUpdate) {
|
|
m.checkNotNullParameter(interactionStateUpdate, "interactionUpdate");
|
|
handleInteractionStateUpdate$default(this, interactionStateUpdate, false, true, 2, null);
|
|
}
|
|
|
|
@StoreThread
|
|
public final void handleInteractionFailure(InteractionStateUpdate interactionStateUpdate) {
|
|
m.checkNotNullParameter(interactionStateUpdate, "interactionUpdate");
|
|
handleInteractionStateUpdate$default(this, interactionStateUpdate, true, false, 4, null);
|
|
}
|
|
|
|
public final void handleMessageCreate(List<? extends ModelMessage> list) {
|
|
m.checkNotNullParameter(list, "messagesList");
|
|
for (ModelMessage modelMessage : list) {
|
|
String nonce = modelMessage.getNonce();
|
|
if (nonce != null) {
|
|
this.localMessagesHolder.deleteMessage(modelMessage.getChannelId(), nonce);
|
|
}
|
|
}
|
|
this.holder.addMessages(list);
|
|
}
|
|
|
|
public final void handleMessageDelete(ModelMessageDelete modelMessageDelete) {
|
|
m.checkNotNullParameter(modelMessageDelete, "messageDelete");
|
|
long channelId = modelMessageDelete.getChannelId();
|
|
List<Long> messageIds = modelMessageDelete.getMessageIds();
|
|
m.checkNotNullExpressionValue(messageIds, "messageDelete.messageIds");
|
|
handleMessageDelete(channelId, messageIds);
|
|
}
|
|
|
|
public final void handleMessageUpdate(ModelMessage modelMessage) {
|
|
m.checkNotNullParameter(modelMessage, "message");
|
|
this.holder.updateMessages(modelMessage);
|
|
}
|
|
|
|
public final void handleMessagesLoaded(StoreMessagesLoader.ChannelChunk channelChunk) {
|
|
m.checkNotNullParameter(channelChunk, "chunk");
|
|
this.holder.loadMessageChunks(d0.t.m.listOf(channelChunk));
|
|
}
|
|
|
|
public final void handlePreLogout() {
|
|
this.localMessagesHolder.clearCache();
|
|
}
|
|
|
|
public final void handleReactionUpdate(List<MessageReactionUpdate> list, boolean z2) {
|
|
m.checkNotNullParameter(list, "updates");
|
|
this.holder.updateReactions(list, z2);
|
|
}
|
|
|
|
public final void handleReactionsRemoveAll(MessageReactionUpdate messageReactionUpdate) {
|
|
m.checkNotNullParameter(messageReactionUpdate, "update");
|
|
this.holder.removeAllReactions(messageReactionUpdate);
|
|
}
|
|
|
|
public final void handleReactionsRemoveEmoji(MessageReactionUpdate messageReactionUpdate) {
|
|
m.checkNotNullParameter(messageReactionUpdate, "update");
|
|
this.holder.removeEmojiReactions(messageReactionUpdate);
|
|
}
|
|
|
|
@Override // com.discord.stores.Store
|
|
public void init(Context context) {
|
|
m.checkNotNullParameter(context, "context");
|
|
super.init(context);
|
|
this.context = context;
|
|
this.holder.init(true);
|
|
StoreLocalMessagesHolder.init$default(this.localMessagesHolder, false, 1, null);
|
|
resendAllLocalMessages();
|
|
}
|
|
|
|
public final BehaviorSubject<Boolean> observeInitResendFinished() {
|
|
BehaviorSubject<Boolean> behaviorSubject = this.initResendFinished;
|
|
m.checkNotNullExpressionValue(behaviorSubject, "initResendFinished");
|
|
return behaviorSubject;
|
|
}
|
|
|
|
public final Observable<Boolean> observeIsDetached(long j) {
|
|
Observable<Boolean> s2 = getAllDetached().G(new StoreMessages$observeIsDetached$1(j)).s();
|
|
m.checkNotNullExpressionValue(s2, "allDetached\n .m… .distinctUntilChanged()");
|
|
return s2;
|
|
}
|
|
|
|
public final Observable<List<ModelMessage>> observeMessagesForChannel(long j) {
|
|
Observable<List<ModelMessage>> i = Observable.i(observeSyncedMessagesForChannel(j), observeLocalMessagesForChannel(j), observeIsDetached(j), StoreMessages$observeMessagesForChannel$1.INSTANCE);
|
|
m.checkNotNullExpressionValue(i, "Observable.combineLatest…ges + localMessages\n }");
|
|
return i;
|
|
}
|
|
|
|
public final Observable<ModelMessage> observeMessagesForChannel(long j, long j2) {
|
|
Observable<ModelMessage> s2 = observeMessagesForChannel(j).G(new StoreMessages$observeMessagesForChannel$2(j2)).s();
|
|
m.checkNotNullExpressionValue(s2, "observeMessagesForChanne… .distinctUntilChanged()");
|
|
return s2;
|
|
}
|
|
|
|
public final Observable<MessageResult> resendMessage(ModelMessage modelMessage, boolean z2) {
|
|
ArrayList arrayList;
|
|
ArrayList arrayList2;
|
|
m.checkNotNullParameter(modelMessage, "message");
|
|
if ((!z2 || modelMessage.getType() == -1) && (z2 || modelMessage.getType() == -2)) {
|
|
this.dispatcher.schedule(new StoreMessages$resendMessage$1(this, modelMessage));
|
|
Integer numRetries = modelMessage.getNumRetries();
|
|
if (numRetries == null) {
|
|
numRetries = 0;
|
|
}
|
|
m.checkNotNullExpressionValue(numRetries, "message.numRetries ?: 0");
|
|
int intValue = numRetries.intValue();
|
|
long channelId = modelMessage.getChannelId();
|
|
com.discord.api.user.User author = modelMessage.getAuthor();
|
|
m.checkNotNullExpressionValue(author, "message.author");
|
|
CoreUser coreUser = new CoreUser(author);
|
|
String content = modelMessage.getContent();
|
|
if (content == null) {
|
|
content = "";
|
|
}
|
|
List<com.discord.api.user.User> mentions = modelMessage.getMentions();
|
|
if (mentions != null) {
|
|
arrayList = new ArrayList(o.collectionSizeOrDefault(mentions, 10));
|
|
for (com.discord.api.user.User user : mentions) {
|
|
m.checkNotNullExpressionValue(user, "it");
|
|
arrayList.add(new CoreUser(user));
|
|
}
|
|
} else {
|
|
arrayList = null;
|
|
}
|
|
List<LocalAttachment> list = modelMessage.localAttachments;
|
|
if (list != null) {
|
|
arrayList2 = new ArrayList(o.collectionSizeOrDefault(list, 10));
|
|
for (LocalAttachment localAttachment : list) {
|
|
Uri parse = Uri.parse(localAttachment.getUriString());
|
|
long id2 = localAttachment.getId();
|
|
m.checkNotNullExpressionValue(parse, "contentUri");
|
|
arrayList2.add(new Attachment(id2, parse, localAttachment.getDisplayName(), null));
|
|
}
|
|
} else {
|
|
arrayList2 = null;
|
|
}
|
|
return sendMessage$default(this, channelId, coreUser, content, arrayList, arrayList2, null, modelMessage.getMessageReference(), modelMessage.getAllowedMentions(), null, null, null, z2 ? modelMessage.getLastManualAttemptTimestamp() : null, modelMessage.getInitialAttemptTimestamp(), Integer.valueOf(intValue + 1), 1824, null);
|
|
}
|
|
throw new IllegalArgumentException("Incorrect " + z2 + " auto attempt and message type " + modelMessage.getType());
|
|
}
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r31v0, resolved type: java.util.List<? extends com.lytefast.flexinput.model.Attachment<?>> */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARNING: Unknown variable types count: 1 */
|
|
public final Observable<MessageResult> sendMessage(long j, User user, String str, List<? extends User> list, List<? extends Attachment<?>> list2, List<Sticker> list3, MessageReference messageReference, ModelAllowedMentions modelAllowedMentions, Application application, Activity activity, MessageActivity messageActivity, Long l, Long l2, Integer num) {
|
|
ArrayList arrayList;
|
|
String str2 = str;
|
|
Emitter.BackpressureMode backpressureMode = Emitter.BackpressureMode.ERROR;
|
|
m.checkNotNullParameter(user, "author");
|
|
m.checkNotNullParameter(str2, "content");
|
|
Ref$ObjectRef ref$ObjectRef = new Ref$ObjectRef();
|
|
ref$ObjectRef.element = list2;
|
|
if (!(list2 == 0 || list2.isEmpty())) {
|
|
ProcessedMessageContent.Companion companion = ProcessedMessageContent.Companion;
|
|
Context context = this.context;
|
|
if (context == null) {
|
|
m.throwUninitializedPropertyAccessException("context");
|
|
}
|
|
ProcessedMessageContent fromAttachments = companion.fromAttachments(list2, str2, context);
|
|
List<Attachment<?>> invalidAttachments = fromAttachments.getInvalidAttachments();
|
|
if (!invalidAttachments.isEmpty()) {
|
|
com.discord.api.user.User synthesizeApiUser = UserUtils.INSTANCE.synthesizeApiUser(user);
|
|
Clock clock = this.clock;
|
|
ArrayList arrayList2 = new ArrayList(o.collectionSizeOrDefault(invalidAttachments, 10));
|
|
Iterator<T> it = invalidAttachments.iterator();
|
|
while (it.hasNext()) {
|
|
arrayList2.add(AttachmentUtilsKt.toLocalAttachment((Attachment) it.next()));
|
|
}
|
|
this.dispatcher.schedule(new StoreMessages$sendMessage$1(this, ModelMessage.createInvalidAttachmentsMessage(j, synthesizeApiUser, clock, arrayList2)));
|
|
}
|
|
ref$ObjectRef.element = fromAttachments.getValidAttachments();
|
|
str2 = fromAttachments.getContent();
|
|
List list4 = ref$ObjectRef.element;
|
|
if (list4 == null || list4.isEmpty()) {
|
|
if (str2.length() == 0) {
|
|
Observable<MessageResult> n = Observable.n(StoreMessages$sendMessage$2.INSTANCE, backpressureMode);
|
|
m.checkNotNullExpressionValue(n, "Observable.create({ emit…r.BackpressureMode.ERROR)");
|
|
return n;
|
|
}
|
|
}
|
|
}
|
|
long longValue = l != null ? l.longValue() : this.clock.currentTimeMillis();
|
|
com.discord.api.user.User synthesizeApiUser2 = UserUtils.INSTANCE.synthesizeApiUser(user);
|
|
ArrayList arrayList3 = null;
|
|
if (list != null) {
|
|
arrayList = new ArrayList(o.collectionSizeOrDefault(list, 10));
|
|
for (User user2 : list) {
|
|
arrayList.add(UserUtils.INSTANCE.synthesizeApiUser(user2));
|
|
}
|
|
} else {
|
|
arrayList = null;
|
|
}
|
|
List list5 = ref$ObjectRef.element;
|
|
boolean z2 = !(list5 == null || list5.isEmpty());
|
|
Clock clock2 = this.clock;
|
|
List<Attachment> list6 = ref$ObjectRef.element;
|
|
if (list6 != null) {
|
|
arrayList3 = new ArrayList(o.collectionSizeOrDefault(list6, 10));
|
|
for (Attachment attachment : list6) {
|
|
arrayList3.add(AttachmentUtilsKt.toLocalAttachment(attachment));
|
|
}
|
|
}
|
|
ModelMessage createLocalMessage = ModelMessage.createLocalMessage(str2, j, synthesizeApiUser2, arrayList, false, z2, application, messageActivity, clock2, arrayList3, Long.valueOf(longValue), Long.valueOf(l2 != null ? l2.longValue() : this.clock.currentTimeMillis()), Integer.valueOf(num != null ? num.intValue() : 0), list3, messageReference, modelAllowedMentions);
|
|
if (messageActivity == null) {
|
|
this.dispatcher.schedule(new StoreMessages$sendMessage$3(this, createLocalMessage));
|
|
}
|
|
this.dispatcher.schedule(new StoreMessages$sendMessage$4(this));
|
|
Observable<MessageResult> n2 = Observable.n(new StoreMessages$sendMessage$5(this, j, new StoreMessages$sendMessage$request$1(this, createLocalMessage, ref$ObjectRef, activity, longValue)), backpressureMode);
|
|
m.checkNotNullExpressionValue(n2, "Observable.create({ emit…r.BackpressureMode.ERROR)");
|
|
return n2;
|
|
}
|
|
|
|
public final Observable<MessageResult> sendMessage(ModelMessage modelMessage, ApplicationCommandLocalSendData applicationCommandLocalSendData) {
|
|
m.checkNotNullParameter(modelMessage, "message");
|
|
m.checkNotNullParameter(applicationCommandLocalSendData, "applicationCommandLocalSendData");
|
|
this.dispatcher.schedule(new StoreMessages$sendMessage$6(this, modelMessage));
|
|
Observable<MessageResult> n = Observable.n(new StoreMessages$sendMessage$7(this, modelMessage, applicationCommandLocalSendData), Emitter.BackpressureMode.NONE);
|
|
m.checkNotNullExpressionValue(n, "Observable.create({ emit…er.BackpressureMode.NONE)");
|
|
return n;
|
|
}
|
|
}
|