2013-10-25 17:19:00 +02:00
|
|
|
/*
|
2013-12-20 20:25:49 +01:00
|
|
|
* This is the source code of Telegram for Android v. 1.3.2.
|
2013-10-25 17:19:00 +02:00
|
|
|
* It is licensed under GNU GPL v. 2 or later.
|
|
|
|
* You should have received a copy of the license in this archive (see LICENSE).
|
|
|
|
*
|
|
|
|
* Copyright Nikolai Kudashov, 2013.
|
|
|
|
*/
|
|
|
|
|
2014-07-03 00:39:05 +02:00
|
|
|
package org.telegram.android;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
import android.app.Activity;
|
2013-10-25 17:19:00 +02:00
|
|
|
import android.app.AlertDialog;
|
|
|
|
import android.app.ProgressDialog;
|
|
|
|
import android.content.Context;
|
2014-03-22 23:31:55 +01:00
|
|
|
import android.content.DialogInterface;
|
2013-10-25 17:19:00 +02:00
|
|
|
import android.content.SharedPreferences;
|
|
|
|
import android.content.pm.PackageInfo;
|
|
|
|
import android.os.Build;
|
|
|
|
import android.text.Html;
|
2014-10-10 19:16:39 +02:00
|
|
|
import android.util.SparseArray;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-07-03 00:39:05 +02:00
|
|
|
import org.telegram.messenger.BuffersStorage;
|
|
|
|
import org.telegram.messenger.ByteBufferDesc;
|
|
|
|
import org.telegram.messenger.ConnectionsManager;
|
|
|
|
import org.telegram.messenger.FileLoader;
|
|
|
|
import org.telegram.messenger.FileLog;
|
|
|
|
import org.telegram.messenger.MessageKeyData;
|
|
|
|
import org.telegram.messenger.R;
|
|
|
|
import org.telegram.messenger.RPCRequest;
|
|
|
|
import org.telegram.messenger.TLClassStore;
|
|
|
|
import org.telegram.messenger.TLObject;
|
|
|
|
import org.telegram.messenger.TLRPC;
|
|
|
|
import org.telegram.messenger.UserConfig;
|
|
|
|
import org.telegram.messenger.Utilities;
|
2013-10-25 17:19:00 +02:00
|
|
|
import org.telegram.ui.ApplicationLoader;
|
|
|
|
|
|
|
|
import java.math.BigInteger;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.Comparator;
|
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.Locale;
|
|
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
import java.util.concurrent.Semaphore;
|
|
|
|
|
|
|
|
public class MessagesController implements NotificationCenter.NotificationCenterDelegate {
|
2014-08-22 16:24:33 +02:00
|
|
|
private ConcurrentHashMap<Integer, TLRPC.Chat> chats = new ConcurrentHashMap<Integer, TLRPC.Chat>(100, 1.0f, 2);
|
|
|
|
private ConcurrentHashMap<Integer, TLRPC.EncryptedChat> encryptedChats = new ConcurrentHashMap<Integer, TLRPC.EncryptedChat>(10, 1.0f, 2);
|
|
|
|
private ConcurrentHashMap<Integer, TLRPC.User> users = new ConcurrentHashMap<Integer, TLRPC.User>(100, 1.0f, 2);
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
public ArrayList<TLRPC.TL_dialog> dialogs = new ArrayList<TLRPC.TL_dialog>();
|
|
|
|
public ArrayList<TLRPC.TL_dialog> dialogsServerOnly = new ArrayList<TLRPC.TL_dialog>();
|
2014-02-11 15:32:09 +01:00
|
|
|
public ConcurrentHashMap<Long, TLRPC.TL_dialog> dialogs_dict = new ConcurrentHashMap<Long, TLRPC.TL_dialog>(100, 1.0f, 2);
|
2014-07-03 00:39:05 +02:00
|
|
|
public HashMap<Integer, MessageObject> dialogMessage = new HashMap<Integer, MessageObject>();
|
2013-10-25 17:19:00 +02:00
|
|
|
public ConcurrentHashMap<Long, ArrayList<PrintingUser>> printingUsers = new ConcurrentHashMap<Long, ArrayList<PrintingUser>>(100, 1.0f, 2);
|
|
|
|
public HashMap<Long, CharSequence> printingStrings = new HashMap<Long, CharSequence>();
|
2014-08-23 01:22:33 +02:00
|
|
|
public HashMap<Long, Boolean> sendingTypings = new HashMap<Long, Boolean>();
|
2014-05-20 22:22:44 +02:00
|
|
|
private int lastPrintingStringCount = 0;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
public boolean loadingBlockedUsers = false;
|
|
|
|
public ArrayList<Integer> blockedUsers = new ArrayList<Integer>();
|
|
|
|
|
2014-07-03 00:39:05 +02:00
|
|
|
public HashMap<Integer, TLRPC.User> hidenAddToContacts = new HashMap<Integer, TLRPC.User>();
|
|
|
|
private HashMap<Integer, TLRPC.EncryptedChat> acceptingChats = new HashMap<Integer, TLRPC.EncryptedChat>();
|
2014-02-04 19:36:55 +01:00
|
|
|
private ArrayList<TLRPC.Updates> updatesQueue = new ArrayList<TLRPC.Updates>();
|
2014-03-22 23:31:55 +01:00
|
|
|
private ArrayList<Long> pendingEncMessagesToDelete = new ArrayList<Long>();
|
2014-02-04 19:36:55 +01:00
|
|
|
private long updatesStartWaitTime = 0;
|
2014-03-22 23:31:55 +01:00
|
|
|
public ArrayList<TLRPC.Update> delayedEncryptedChatUpdates = new ArrayList<TLRPC.Update>();
|
|
|
|
private boolean startingSecretChat = false;
|
2014-10-17 20:29:13 +02:00
|
|
|
private ArrayList<Integer> loadingFullUsers = new ArrayList<Integer>();
|
|
|
|
private ArrayList<Integer> loadedFullUsers = new ArrayList<Integer>();
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-10-28 18:07:44 +01:00
|
|
|
private HashMap<Integer, ArrayList<TLRPC.TL_decryptedMessageHolder>> secretHolesQueue = new HashMap<Integer, ArrayList<TLRPC.TL_decryptedMessageHolder>>();
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
private boolean gettingNewDeleteTask = false;
|
|
|
|
private int currentDeletingTaskTime = 0;
|
|
|
|
private ArrayList<Integer> currentDeletingTaskMids = null;
|
2014-10-14 10:13:16 +02:00
|
|
|
private Runnable currentDeleteTaskRunnable = null;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
public int totalDialogsCount = 0;
|
|
|
|
public boolean loadingDialogs = false;
|
|
|
|
public boolean dialogsEndReached = false;
|
|
|
|
public boolean gettingDifference = false;
|
2013-12-20 20:25:49 +01:00
|
|
|
public boolean gettingDifferenceAgain = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
public boolean updatingState = false;
|
|
|
|
public boolean firstGettingTask = false;
|
|
|
|
public boolean registeringForPush = false;
|
2014-07-03 00:39:05 +02:00
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
private long lastStatusUpdateTime = 0;
|
2014-02-28 23:28:25 +01:00
|
|
|
private long statusRequest = 0;
|
|
|
|
private int statusSettingState = 0;
|
|
|
|
private boolean offlineSent = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
private String uploadingAvatar = null;
|
2014-07-03 00:39:05 +02:00
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
public boolean enableJoined = true;
|
2014-07-03 00:39:05 +02:00
|
|
|
public int fontSize = AndroidUtilities.dp(16);
|
2014-08-06 01:17:40 +02:00
|
|
|
public int maxGroupCount = 200;
|
|
|
|
public int maxBroadcastCount = 100;
|
2014-02-04 19:36:55 +01:00
|
|
|
|
|
|
|
private class UserActionUpdates extends TLRPC.Updates {
|
|
|
|
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
public static final int UPDATE_MASK_NAME = 1;
|
|
|
|
public static final int UPDATE_MASK_AVATAR = 2;
|
|
|
|
public static final int UPDATE_MASK_STATUS = 4;
|
2014-02-04 19:36:55 +01:00
|
|
|
public static final int UPDATE_MASK_CHAT_AVATAR = 8;
|
|
|
|
public static final int UPDATE_MASK_CHAT_NAME = 16;
|
|
|
|
public static final int UPDATE_MASK_CHAT_MEMBERS = 32;
|
|
|
|
public static final int UPDATE_MASK_USER_PRINT = 64;
|
|
|
|
public static final int UPDATE_MASK_USER_PHONE = 128;
|
2014-03-22 23:31:55 +01:00
|
|
|
public static final int UPDATE_MASK_READ_DIALOG_MESSAGE = 256;
|
|
|
|
public static final int UPDATE_MASK_ALL = UPDATE_MASK_AVATAR | UPDATE_MASK_STATUS | UPDATE_MASK_NAME | UPDATE_MASK_CHAT_AVATAR | UPDATE_MASK_CHAT_NAME | UPDATE_MASK_CHAT_MEMBERS | UPDATE_MASK_USER_PRINT | UPDATE_MASK_USER_PHONE | UPDATE_MASK_READ_DIALOG_MESSAGE;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
public static class PrintingUser {
|
|
|
|
public long lastTime;
|
|
|
|
public int userId;
|
|
|
|
}
|
|
|
|
|
2014-03-22 23:31:55 +01:00
|
|
|
private static volatile MessagesController Instance = null;
|
|
|
|
public static MessagesController getInstance() {
|
|
|
|
MessagesController localInstance = Instance;
|
|
|
|
if (localInstance == null) {
|
|
|
|
synchronized (MessagesController.class) {
|
|
|
|
localInstance = Instance;
|
|
|
|
if (localInstance == null) {
|
|
|
|
Instance = localInstance = new MessagesController();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return localInstance;
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
public MessagesController() {
|
2014-08-22 16:24:33 +02:00
|
|
|
ImageLoader.getInstance();
|
|
|
|
MessagesStorage.getInstance();
|
|
|
|
NotificationCenter.getInstance().addObserver(this, NotificationCenter.FileDidUpload);
|
|
|
|
NotificationCenter.getInstance().addObserver(this, NotificationCenter.FileDidFailUpload);
|
|
|
|
NotificationCenter.getInstance().addObserver(this, NotificationCenter.FileDidLoaded);
|
|
|
|
NotificationCenter.getInstance().addObserver(this, NotificationCenter.FileDidFailedLoad);
|
|
|
|
NotificationCenter.getInstance().addObserver(this, NotificationCenter.messageReceivedByServer);
|
2013-10-25 17:19:00 +02:00
|
|
|
addSupportUser();
|
2014-02-04 19:36:55 +01:00
|
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("Notifications", Activity.MODE_PRIVATE);
|
|
|
|
enableJoined = preferences.getBoolean("EnableContactJoined", true);
|
2014-08-22 16:24:33 +02:00
|
|
|
|
2014-02-28 23:28:25 +01:00
|
|
|
preferences = ApplicationLoader.applicationContext.getSharedPreferences("mainconfig", Activity.MODE_PRIVATE);
|
2014-08-06 01:17:40 +02:00
|
|
|
maxGroupCount = preferences.getInt("maxGroupCount", 200);
|
|
|
|
maxBroadcastCount = preferences.getInt("maxBroadcastCount", 100);
|
2014-09-24 04:17:27 +02:00
|
|
|
fontSize = preferences.getInt("fons_size", AndroidUtilities.isTablet() ? 18 : 16);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-08-06 01:17:40 +02:00
|
|
|
public void updateConfig(final TLRPC.TL_config config) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-08-06 01:17:40 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
maxBroadcastCount = config.broadcast_size_max;
|
|
|
|
maxGroupCount = config.chat_size_max;
|
|
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("mainconfig", Activity.MODE_PRIVATE);
|
|
|
|
SharedPreferences.Editor editor = preferences.edit();
|
|
|
|
editor.putInt("maxGroupCount", maxGroupCount);
|
|
|
|
editor.putInt("maxBroadcastCount", maxBroadcastCount);
|
|
|
|
editor.commit();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
public void addSupportUser() {
|
|
|
|
TLRPC.TL_userForeign user = new TLRPC.TL_userForeign();
|
|
|
|
user.phone = "333";
|
|
|
|
user.id = 333000;
|
|
|
|
user.first_name = "Telegram";
|
|
|
|
user.last_name = "";
|
|
|
|
user.status = null;
|
|
|
|
user.photo = new TLRPC.TL_userProfilePhotoEmpty();
|
2014-08-22 16:24:33 +02:00
|
|
|
putUser(user, true);
|
2014-08-29 23:06:04 +02:00
|
|
|
|
|
|
|
user = new TLRPC.TL_userForeign();
|
|
|
|
user.phone = "42777";
|
|
|
|
user.id = 777000;
|
|
|
|
user.first_name = "Telegram";
|
|
|
|
user.last_name = "Notifications";
|
|
|
|
user.status = null;
|
|
|
|
user.photo = new TLRPC.TL_userProfilePhotoEmpty();
|
|
|
|
putUser(user, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
public static TLRPC.InputUser getInputUser(TLRPC.User user) {
|
|
|
|
if (user == null) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
TLRPC.InputUser inputUser = null;
|
2014-06-13 12:42:21 +02:00
|
|
|
if (user.id == UserConfig.getClientUserId()) {
|
2014-02-04 19:36:55 +01:00
|
|
|
inputUser = new TLRPC.TL_inputUserSelf();
|
|
|
|
} else if (user instanceof TLRPC.TL_userForeign || user instanceof TLRPC.TL_userRequest) {
|
|
|
|
inputUser = new TLRPC.TL_inputUserForeign();
|
|
|
|
inputUser.user_id = user.id;
|
|
|
|
inputUser.access_hash = user.access_hash;
|
|
|
|
} else {
|
|
|
|
inputUser = new TLRPC.TL_inputUserContact();
|
|
|
|
inputUser.user_id = user.id;
|
|
|
|
}
|
|
|
|
return inputUser;
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void didReceivedNotification(int id, Object... args) {
|
2014-08-22 16:24:33 +02:00
|
|
|
if (id == NotificationCenter.FileDidUpload) {
|
2014-07-03 00:39:05 +02:00
|
|
|
final String location = (String)args[0];
|
|
|
|
final TLRPC.InputFile file = (TLRPC.InputFile)args[1];
|
|
|
|
final TLRPC.InputEncryptedFile encryptedFile = (TLRPC.InputEncryptedFile)args[2];
|
|
|
|
|
|
|
|
if (uploadingAvatar != null && uploadingAvatar.equals(location)) {
|
|
|
|
TLRPC.TL_photos_uploadProfilePhoto req = new TLRPC.TL_photos_uploadProfilePhoto();
|
|
|
|
req.caption = "";
|
|
|
|
req.crop = new TLRPC.TL_inputPhotoCropAuto();
|
|
|
|
req.file = file;
|
|
|
|
req.geo_point = new TLRPC.TL_inputGeoPointEmpty();
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(UserConfig.getClientUserId());
|
2014-07-03 00:39:05 +02:00
|
|
|
if (user == null) {
|
|
|
|
user = UserConfig.getCurrentUser();
|
2014-08-22 16:24:33 +02:00
|
|
|
putUser(user, true);
|
2014-07-03 00:39:05 +02:00
|
|
|
} else {
|
|
|
|
UserConfig.setCurrentUser(user);
|
|
|
|
}
|
|
|
|
if (user == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
TLRPC.TL_photos_photo photo = (TLRPC.TL_photos_photo) response;
|
|
|
|
ArrayList<TLRPC.PhotoSize> sizes = photo.photo.sizes;
|
2014-10-01 21:55:24 +02:00
|
|
|
TLRPC.PhotoSize smallSize = FileLoader.getClosestPhotoSizeWithSize(sizes, 100);
|
|
|
|
TLRPC.PhotoSize bigSize = FileLoader.getClosestPhotoSizeWithSize(sizes, 1000);
|
2014-07-03 00:39:05 +02:00
|
|
|
user.photo = new TLRPC.TL_userProfilePhoto();
|
|
|
|
user.photo.photo_id = photo.photo.id;
|
|
|
|
if (smallSize != null) {
|
|
|
|
user.photo.photo_small = smallSize.location;
|
|
|
|
}
|
|
|
|
if (bigSize != null) {
|
|
|
|
user.photo.photo_big = bigSize.location;
|
|
|
|
} else if (smallSize != null) {
|
|
|
|
user.photo.photo_small = smallSize.location;
|
|
|
|
}
|
|
|
|
MessagesStorage.getInstance().clearUserPhotos(user.id);
|
|
|
|
ArrayList<TLRPC.User> users = new ArrayList<TLRPC.User>();
|
|
|
|
users.add(user);
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(users, null, false, true);
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-03 00:39:05 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_AVATAR);
|
2014-07-03 00:39:05 +02:00
|
|
|
UserConfig.saveConfig(true);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
} else if (id == NotificationCenter.FileDidFailUpload) {
|
2014-07-03 00:39:05 +02:00
|
|
|
final String location = (String) args[0];
|
|
|
|
final boolean enc = (Boolean) args[1];
|
|
|
|
|
|
|
|
if (uploadingAvatar != null && uploadingAvatar.equals(location)) {
|
|
|
|
uploadingAvatar = null;
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
} else if (id == NotificationCenter.messageReceivedByServer) {
|
2013-10-25 17:19:00 +02:00
|
|
|
Integer msgId = (Integer)args[0];
|
|
|
|
MessageObject obj = dialogMessage.get(msgId);
|
|
|
|
if (obj != null) {
|
|
|
|
Integer newMsgId = (Integer)args[1];
|
|
|
|
dialogMessage.remove(msgId);
|
|
|
|
dialogMessage.put(newMsgId, obj);
|
|
|
|
obj.messageOwner.id = newMsgId;
|
2014-08-22 16:24:33 +02:00
|
|
|
obj.messageOwner.send_state = MessageObject.MESSAGE_SEND_STATE_SENT;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
long uid;
|
|
|
|
if (obj.messageOwner.to_id.chat_id != 0) {
|
|
|
|
uid = -obj.messageOwner.to_id.chat_id;
|
|
|
|
} else {
|
2014-06-13 12:42:21 +02:00
|
|
|
if (obj.messageOwner.to_id.user_id == UserConfig.getClientUserId()) {
|
2013-10-25 17:19:00 +02:00
|
|
|
obj.messageOwner.to_id.user_id = obj.messageOwner.from_id;
|
|
|
|
}
|
|
|
|
uid = obj.messageOwner.to_id.user_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
TLRPC.TL_dialog dialog = dialogs_dict.get(uid);
|
|
|
|
if (dialog != null) {
|
|
|
|
if (dialog.top_message == msgId) {
|
|
|
|
dialog.top_message = newMsgId;
|
|
|
|
}
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
} else {
|
|
|
|
NotificationCenter.getInstance().addObserver(this, NotificationCenter.FileDidLoaded);
|
|
|
|
NotificationCenter.getInstance().addObserver(this, NotificationCenter.FileDidFailedLoad);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void cleanUp() {
|
2014-03-22 23:31:55 +01:00
|
|
|
ContactsController.getInstance().cleanup();
|
|
|
|
MediaController.getInstance().cleanup();
|
2014-07-10 02:15:58 +02:00
|
|
|
NotificationsController.getInstance().cleanup();
|
2014-08-22 16:24:33 +02:00
|
|
|
SendMessagesHelper.getInstance().cleanUp();
|
2014-02-04 19:36:55 +01:00
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
dialogs_dict.clear();
|
|
|
|
dialogs.clear();
|
|
|
|
dialogsServerOnly.clear();
|
|
|
|
acceptingChats.clear();
|
|
|
|
users.clear();
|
|
|
|
chats.clear();
|
|
|
|
dialogMessage.clear();
|
|
|
|
printingUsers.clear();
|
|
|
|
printingStrings.clear();
|
|
|
|
totalDialogsCount = 0;
|
2014-05-20 22:22:44 +02:00
|
|
|
lastPrintingStringCount = 0;
|
2013-10-25 17:19:00 +02:00
|
|
|
hidenAddToContacts.clear();
|
2014-02-04 19:36:55 +01:00
|
|
|
updatesQueue.clear();
|
2014-03-22 23:31:55 +01:00
|
|
|
pendingEncMessagesToDelete.clear();
|
|
|
|
delayedEncryptedChatUpdates.clear();
|
2014-08-22 16:24:33 +02:00
|
|
|
blockedUsers.clear();
|
2014-08-23 01:22:33 +02:00
|
|
|
sendingTypings.clear();
|
2014-10-17 20:29:13 +02:00
|
|
|
loadingFullUsers.clear();
|
|
|
|
loadedFullUsers.clear();
|
2014-10-28 18:07:44 +01:00
|
|
|
secretHolesQueue.clear();
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
updatesStartWaitTime = 0;
|
2013-10-25 17:19:00 +02:00
|
|
|
currentDeletingTaskTime = 0;
|
|
|
|
currentDeletingTaskMids = null;
|
|
|
|
gettingNewDeleteTask = false;
|
|
|
|
loadingDialogs = false;
|
|
|
|
dialogsEndReached = false;
|
|
|
|
gettingDifference = false;
|
2013-12-20 20:25:49 +01:00
|
|
|
gettingDifferenceAgain = false;
|
2014-08-22 16:24:33 +02:00
|
|
|
loadingBlockedUsers = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
firstGettingTask = false;
|
|
|
|
updatingState = false;
|
|
|
|
lastStatusUpdateTime = 0;
|
2014-02-28 23:28:25 +01:00
|
|
|
offlineSent = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
registeringForPush = false;
|
|
|
|
uploadingAvatar = null;
|
2014-03-22 23:31:55 +01:00
|
|
|
startingSecretChat = false;
|
2014-02-28 23:28:25 +01:00
|
|
|
statusRequest = 0;
|
|
|
|
statusSettingState = 0;
|
2014-10-14 10:13:16 +02:00
|
|
|
|
|
|
|
if (currentDeleteTaskRunnable != null) {
|
|
|
|
Utilities.stageQueue.cancelRunnable(currentDeleteTaskRunnable);
|
|
|
|
currentDeleteTaskRunnable = null;
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
addSupportUser();
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
public TLRPC.User getUser(Integer id) {
|
|
|
|
return users.get(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
public TLRPC.Chat getChat(Integer id) {
|
|
|
|
return chats.get(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
public TLRPC.EncryptedChat getEncryptedChat(Integer id) {
|
|
|
|
return encryptedChats.get(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
public TLRPC.EncryptedChat getEncryptedChatDB(int chat_id) {
|
|
|
|
TLRPC.EncryptedChat chat = encryptedChats.get(chat_id);
|
|
|
|
if (chat == null) {
|
|
|
|
Semaphore semaphore = new Semaphore(0);
|
|
|
|
ArrayList<TLObject> result = new ArrayList<TLObject>();
|
|
|
|
MessagesStorage.getInstance().getEncryptedChat(chat_id, semaphore, result);
|
|
|
|
try {
|
|
|
|
semaphore.acquire();
|
|
|
|
} catch (Exception e) {
|
|
|
|
FileLog.e("tmessages", e);
|
|
|
|
}
|
|
|
|
if (result.size() == 2) {
|
|
|
|
chat = (TLRPC.EncryptedChat)result.get(0);
|
|
|
|
TLRPC.User user = (TLRPC.User)result.get(1);
|
|
|
|
putEncryptedChat(chat, false);
|
|
|
|
putUser(user, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return chat;
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean putUser(TLRPC.User user, boolean fromCache) {
|
|
|
|
if (user == null) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
fromCache = fromCache && user.id / 1000 != 333;
|
|
|
|
TLRPC.User oldUser = users.get(user.id);
|
|
|
|
if (!fromCache) {
|
|
|
|
users.put(user.id, user);
|
|
|
|
if (user.id == UserConfig.getClientUserId()) {
|
|
|
|
UserConfig.setCurrentUser(user);
|
2014-10-17 20:29:13 +02:00
|
|
|
UserConfig.saveConfig(true);
|
2014-08-22 16:24:33 +02:00
|
|
|
}
|
|
|
|
if (oldUser != null && user.status != null && oldUser.status != null && user.status.expires != oldUser.status.expires) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else if (oldUser == null) {
|
|
|
|
users.put(user.id, user);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void putUsers(ArrayList<TLRPC.User> users, boolean fromCache) {
|
|
|
|
if (users == null || users.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
boolean updateStatus = false;
|
|
|
|
for (TLRPC.User user : users) {
|
|
|
|
if (putUser(user, fromCache)) {
|
|
|
|
updateStatus = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (updateStatus) {
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_STATUS);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void putChat(TLRPC.Chat chat, boolean fromCache) {
|
|
|
|
if (chat == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (fromCache) {
|
|
|
|
chats.putIfAbsent(chat.id, chat);
|
|
|
|
} else {
|
|
|
|
chats.put(chat.id, chat);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void putChats(ArrayList<TLRPC.Chat> chats, boolean fromCache) {
|
|
|
|
if (chats == null || chats.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (TLRPC.Chat chat : chats) {
|
|
|
|
putChat(chat, fromCache);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void putEncryptedChat(TLRPC.EncryptedChat encryptedChat, boolean fromCache) {
|
|
|
|
if (encryptedChat == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (fromCache) {
|
|
|
|
encryptedChats.putIfAbsent(encryptedChat.id, encryptedChat);
|
|
|
|
} else {
|
|
|
|
encryptedChats.put(encryptedChat.id, encryptedChat);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void putEncryptedChats(ArrayList<TLRPC.EncryptedChat> encryptedChats, boolean fromCache) {
|
|
|
|
if (encryptedChats == null || encryptedChats.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (TLRPC.EncryptedChat encryptedChat : encryptedChats) {
|
|
|
|
putEncryptedChat(encryptedChat, fromCache);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-17 20:29:13 +02:00
|
|
|
public void cancelLoadFullUser(int uid) {
|
|
|
|
loadingFullUsers.remove((Integer) uid);
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
public void loadFullUser(final TLRPC.User user, final int classGuid) {
|
2014-10-17 20:29:13 +02:00
|
|
|
if (user == null || loadingFullUsers.contains(user.id) || loadedFullUsers.contains(user.id)) {
|
2014-08-22 16:24:33 +02:00
|
|
|
return;
|
|
|
|
}
|
2014-10-17 20:29:13 +02:00
|
|
|
loadingFullUsers.add(user.id);
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.TL_users_getFullUser req = new TLRPC.TL_users_getFullUser();
|
|
|
|
req.id = getInputUser(user);
|
|
|
|
long reqId = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(final TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-10-17 20:29:13 +02:00
|
|
|
loadingFullUsers.remove((Integer)user.id);
|
|
|
|
loadedFullUsers.add(user.id);
|
|
|
|
String names = user.first_name + user.last_name + user.username;
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.TL_userFull userFull = (TLRPC.TL_userFull)response;
|
|
|
|
ArrayList<TLRPC.User> users = new ArrayList<TLRPC.User>();
|
|
|
|
users.add(userFull.user);
|
|
|
|
putUsers(users, false);
|
2014-10-17 20:29:13 +02:00
|
|
|
MessagesStorage.getInstance().putUsersAndChats(users, null, false, true);
|
|
|
|
if (!names.equals(userFull.user.first_name + userFull.user.last_name + userFull.user.username)) {
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_NAME);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
loadingFullUsers.remove((Integer)user.id);
|
2014-08-22 16:24:33 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
ConnectionsManager.getInstance().bindRequestToGuid(reqId, classGuid);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected void processNewDifferenceParams(int seq, int pts, int date) {
|
|
|
|
if (MessagesStorage.lastSeqValue + 1 == seq) {
|
|
|
|
if (seq != -1) {
|
|
|
|
MessagesStorage.lastSeqValue = seq;
|
|
|
|
}
|
|
|
|
if (date != -1) {
|
|
|
|
MessagesStorage.lastDateValue = date;
|
|
|
|
}
|
|
|
|
if (pts != -1) {
|
|
|
|
MessagesStorage.lastPtsValue = pts;
|
|
|
|
}
|
|
|
|
MessagesStorage.getInstance().saveDiffParams(MessagesStorage.lastSeqValue, MessagesStorage.lastPtsValue, MessagesStorage.lastDateValue, MessagesStorage.lastQtsValue);
|
|
|
|
} else if (MessagesStorage.lastSeqValue != seq) {
|
|
|
|
if (gettingDifference || updatesStartWaitTime == 0 || updatesStartWaitTime != 0 && updatesStartWaitTime + 1500 > System.currentTimeMillis()) {
|
|
|
|
if (updatesStartWaitTime == 0) {
|
|
|
|
updatesStartWaitTime = System.currentTimeMillis();
|
|
|
|
}
|
|
|
|
UserActionUpdates updates = new UserActionUpdates();
|
|
|
|
updates.seq = seq;
|
|
|
|
updatesQueue.add(updates);
|
|
|
|
} else {
|
|
|
|
getDifference();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-10 19:16:39 +02:00
|
|
|
public void didAddedNewTask(final int minDate, final SparseArray<ArrayList<Integer>> mids) {
|
2013-10-25 17:19:00 +02:00
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-10-08 22:22:22 +02:00
|
|
|
if (currentDeletingTaskMids == null && !gettingNewDeleteTask || currentDeletingTaskTime != 0 && minDate < currentDeletingTaskTime) {
|
2013-10-25 17:19:00 +02:00
|
|
|
getNewDeleteTask(null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2014-10-10 19:16:39 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.didCreatedNewDeleteTask, mids);
|
|
|
|
}
|
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-10-08 22:22:22 +02:00
|
|
|
public void getNewDeleteTask(final ArrayList<Integer> oldTask) {
|
2013-10-25 17:19:00 +02:00
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
gettingNewDeleteTask = true;
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().getNewTask(oldTask);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2014-10-14 10:13:16 +02:00
|
|
|
private boolean checkDeletingTask(boolean runnable) {
|
2014-03-22 23:31:55 +01:00
|
|
|
int currentServerTime = ConnectionsManager.getInstance().getCurrentTime();
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-10-14 10:13:16 +02:00
|
|
|
if (currentDeletingTaskMids != null && (runnable || currentDeletingTaskTime != 0 && currentDeletingTaskTime <= currentServerTime)) {
|
2013-10-25 17:19:00 +02:00
|
|
|
currentDeletingTaskTime = 0;
|
2014-10-14 10:13:16 +02:00
|
|
|
if (currentDeleteTaskRunnable != null && !runnable) {
|
|
|
|
Utilities.stageQueue.cancelRunnable(currentDeleteTaskRunnable);
|
|
|
|
}
|
|
|
|
currentDeleteTaskRunnable = null;
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-03-22 23:31:55 +01:00
|
|
|
deleteMessages(currentDeletingTaskMids, null, null);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-10-08 22:22:22 +02:00
|
|
|
getNewDeleteTask(currentDeletingTaskMids);
|
2013-10-25 17:19:00 +02:00
|
|
|
currentDeletingTaskTime = 0;
|
2014-10-08 22:22:22 +02:00
|
|
|
currentDeletingTaskMids = null;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2014-10-14 10:13:16 +02:00
|
|
|
return true;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-10-14 10:13:16 +02:00
|
|
|
return false;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-10-08 22:22:22 +02:00
|
|
|
public void processLoadedDeleteTask(final int taskTime, final ArrayList<Integer> messages) {
|
2013-10-25 17:19:00 +02:00
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
gettingNewDeleteTask = false;
|
2014-10-08 22:22:22 +02:00
|
|
|
if (messages != null) {
|
2013-10-25 17:19:00 +02:00
|
|
|
currentDeletingTaskTime = taskTime;
|
|
|
|
currentDeletingTaskMids = messages;
|
|
|
|
|
2014-10-14 10:13:16 +02:00
|
|
|
if (currentDeleteTaskRunnable != null) {
|
|
|
|
Utilities.stageQueue.cancelRunnable(currentDeleteTaskRunnable);
|
|
|
|
currentDeleteTaskRunnable = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!checkDeletingTask(false)) {
|
|
|
|
currentDeleteTaskRunnable = new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
checkDeletingTask(true);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
int currentServerTime = ConnectionsManager.getInstance().getCurrentTime();
|
|
|
|
Utilities.stageQueue.postRunnable(currentDeleteTaskRunnable, (long)Math.abs(currentServerTime - currentDeletingTaskTime) * 1000);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
|
|
|
currentDeletingTaskTime = 0;
|
|
|
|
currentDeletingTaskMids = null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2013-12-20 20:25:49 +01:00
|
|
|
public void loadUserPhotos(final int uid, final int offset, final int count, final long max_id, final boolean fromCache, final int classGuid) {
|
|
|
|
if (fromCache) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().getUserPhotos(uid, offset, count, max_id, classGuid);
|
2013-12-20 20:25:49 +01:00
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(uid);
|
2013-12-20 20:25:49 +01:00
|
|
|
if (user == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
TLRPC.TL_photos_getUserPhotos req = new TLRPC.TL_photos_getUserPhotos();
|
|
|
|
req.limit = count;
|
|
|
|
req.offset = offset;
|
|
|
|
req.max_id = (int)max_id;
|
2014-02-04 19:36:55 +01:00
|
|
|
req.user_id = getInputUser(user);
|
2014-03-22 23:31:55 +01:00
|
|
|
long reqId = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-12-20 20:25:49 +01:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
TLRPC.photos_Photos res = (TLRPC.photos_Photos) response;
|
2013-12-20 20:25:49 +01:00
|
|
|
processLoadedUserPhotos(res, uid, offset, count, max_id, fromCache, classGuid);
|
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().bindRequestToGuid(reqId, classGuid);
|
2013-12-20 20:25:49 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
public void blockUser(int user_id) {
|
|
|
|
final TLRPC.User user = getUser(user_id);
|
|
|
|
if (user == null || MessagesController.getInstance().blockedUsers.contains(user_id)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
blockedUsers.add(user_id);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.blockedUsersDidLoaded);
|
|
|
|
TLRPC.TL_contacts_block req = new TLRPC.TL_contacts_block();
|
|
|
|
req.id = MessagesController.getInputUser(user);
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
|
|
|
ArrayList<Integer> ids = new ArrayList<Integer>();
|
|
|
|
ids.add(user.id);
|
|
|
|
MessagesStorage.getInstance().putBlockedUsers(ids, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
public void unblockUser(int user_id) {
|
|
|
|
TLRPC.TL_contacts_unblock req = new TLRPC.TL_contacts_unblock();
|
|
|
|
final TLRPC.User user = MessagesController.getInstance().getUser(user_id);
|
|
|
|
if (user == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
blockedUsers.remove((Integer)user.id);
|
|
|
|
req.id = MessagesController.getInputUser(user);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.blockedUsersDidLoaded);
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
MessagesStorage.getInstance().deleteBlockedUser(user.id);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
public void getBlockedUsers(boolean cache) {
|
|
|
|
if (!UserConfig.isClientActivated() || loadingBlockedUsers) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
loadingBlockedUsers = true;
|
|
|
|
if (cache) {
|
|
|
|
MessagesStorage.getInstance().getBlockedUsers();
|
|
|
|
} else {
|
|
|
|
TLRPC.TL_contacts_getBlocked req = new TLRPC.TL_contacts_getBlocked();
|
|
|
|
req.offset = 0;
|
|
|
|
req.limit = 200;
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
ArrayList<Integer> blocked = new ArrayList<Integer>();
|
|
|
|
ArrayList<TLRPC.User> users = null;
|
|
|
|
if (error == null) {
|
|
|
|
final TLRPC.contacts_Blocked res = (TLRPC.contacts_Blocked)response;
|
|
|
|
for (TLRPC.TL_contactBlocked contactBlocked : res.blocked) {
|
|
|
|
blocked.add(contactBlocked.user_id);
|
|
|
|
}
|
|
|
|
users = res.users;
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, null, true, true);
|
|
|
|
MessagesStorage.getInstance().putBlockedUsers(blocked, true);
|
|
|
|
}
|
|
|
|
processLoadedBlockedUsers(blocked, users, false);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void processLoadedBlockedUsers(final ArrayList<Integer> ids, final ArrayList<TLRPC.User> users, final boolean cache) {
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (users != null) {
|
|
|
|
MessagesController.getInstance().putUsers(users, cache);
|
|
|
|
}
|
|
|
|
loadingBlockedUsers = false;
|
|
|
|
if (ids.isEmpty() && cache && !UserConfig.blockedUsersLoaded) {
|
|
|
|
getBlockedUsers(false);
|
|
|
|
return;
|
|
|
|
} else if (!cache) {
|
|
|
|
UserConfig.blockedUsersLoaded = true;
|
|
|
|
UserConfig.saveConfig(false);
|
|
|
|
}
|
|
|
|
blockedUsers = ids;
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.blockedUsersDidLoaded);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
public void deleteUserPhoto(TLRPC.InputPhoto photo) {
|
|
|
|
if (photo == null) {
|
|
|
|
TLRPC.TL_photos_updateProfilePhoto req = new TLRPC.TL_photos_updateProfilePhoto();
|
|
|
|
req.id = new TLRPC.TL_inputPhotoEmpty();
|
|
|
|
req.crop = new TLRPC.TL_inputPhotoCropAuto();
|
|
|
|
UserConfig.getCurrentUser().photo = new TLRPC.TL_userProfilePhotoEmpty();
|
|
|
|
TLRPC.User user = MessagesController.getInstance().getUser(UserConfig.getClientUserId());
|
|
|
|
if (user == null) {
|
|
|
|
user = UserConfig.getCurrentUser();
|
|
|
|
}
|
|
|
|
if (user == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (user != null) {
|
|
|
|
user.photo = UserConfig.getCurrentUser().photo;
|
|
|
|
}
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, MessagesController.UPDATE_MASK_ALL);
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
|
|
|
TLRPC.User user = MessagesController.getInstance().getUser(UserConfig.getClientUserId());
|
|
|
|
if (user == null) {
|
|
|
|
user = UserConfig.getCurrentUser();
|
|
|
|
MessagesController.getInstance().putUser(user, false);
|
|
|
|
} else {
|
|
|
|
UserConfig.setCurrentUser(user);
|
|
|
|
}
|
|
|
|
if (user == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
MessagesStorage.getInstance().clearUserPhotos(user.id);
|
|
|
|
ArrayList<TLRPC.User> users = new ArrayList<TLRPC.User>();
|
|
|
|
users.add(user);
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(users, null, false, true);
|
|
|
|
user.photo = (TLRPC.UserProfilePhoto)response;
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, MessagesController.UPDATE_MASK_ALL);
|
|
|
|
UserConfig.saveConfig(true);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
TLRPC.TL_photos_deletePhotos req = new TLRPC.TL_photos_deletePhotos();
|
|
|
|
req.id.add(photo);
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-20 20:25:49 +01:00
|
|
|
public void processLoadedUserPhotos(final TLRPC.photos_Photos res, final int uid, final int offset, final int count, final long max_id, final boolean fromCache, final int classGuid) {
|
|
|
|
if (!fromCache) {
|
2014-07-14 23:27:26 +02:00
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, null, true, true);
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putUserPhotos(uid, res);
|
2013-12-20 20:25:49 +01:00
|
|
|
} else if (res == null || res.photos.isEmpty()) {
|
|
|
|
loadUserPhotos(uid, offset, count, max_id, false, classGuid);
|
|
|
|
return;
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-12-20 20:25:49 +01:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, fromCache);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.userPhotosLoaded, uid, offset, count, fromCache, classGuid, res.photos);
|
2013-12-20 20:25:49 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
public void processLoadedMedia(final TLRPC.messages_Messages res, final long uid, int offset, int count, int max_id, final boolean fromCache, final int classGuid) {
|
|
|
|
int lower_part = (int)uid;
|
|
|
|
if (fromCache && res.messages.isEmpty() && lower_part != 0) {
|
|
|
|
loadMedia(uid, offset, count, max_id, false, classGuid);
|
|
|
|
} else {
|
|
|
|
if (!fromCache) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, true, true);
|
|
|
|
MessagesStorage.getInstance().putMedia(uid, res.messages);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
final HashMap<Integer, TLRPC.User> usersLocal = new HashMap<Integer, TLRPC.User>();
|
|
|
|
for (TLRPC.User u : res.users) {
|
|
|
|
usersLocal.put(u.id, u);
|
|
|
|
}
|
|
|
|
final ArrayList<MessageObject> objects = new ArrayList<MessageObject>();
|
|
|
|
for (TLRPC.Message message : res.messages) {
|
|
|
|
objects.add(new MessageObject(message, usersLocal));
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
int totalCount;
|
|
|
|
if (res instanceof TLRPC.TL_messages_messagesSlice) {
|
|
|
|
totalCount = res.count;
|
|
|
|
} else {
|
|
|
|
totalCount = res.messages.size();
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, fromCache);
|
2013-10-25 17:19:00 +02:00
|
|
|
for (TLRPC.Chat chat : res.chats) {
|
2014-08-22 16:24:33 +02:00
|
|
|
putChat(chat, fromCache);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.mediaDidLoaded, uid, totalCount, objects, fromCache, classGuid);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void loadMedia(final long uid, final int offset, final int count, final int max_id, final boolean fromCache, final int classGuid) {
|
|
|
|
int lower_part = (int)uid;
|
|
|
|
if (fromCache || lower_part == 0) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().loadMedia(uid, offset, count, max_id, classGuid);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
|
|
|
TLRPC.TL_messages_search req = new TLRPC.TL_messages_search();
|
|
|
|
req.offset = offset;
|
|
|
|
req.limit = count;
|
|
|
|
req.max_id = max_id;
|
|
|
|
req.filter = new TLRPC.TL_inputMessagesFilterPhotoVideo();
|
|
|
|
req.q = "";
|
|
|
|
if (uid < 0) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerChat();
|
|
|
|
req.peer.chat_id = -lower_part;
|
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(lower_part);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (user instanceof TLRPC.TL_userForeign || user instanceof TLRPC.TL_userRequest) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerForeign();
|
|
|
|
req.peer.access_hash = user.access_hash;
|
|
|
|
} else {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerContact();
|
|
|
|
}
|
|
|
|
req.peer.user_id = lower_part;
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
long reqId = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
final TLRPC.messages_Messages res = (TLRPC.messages_Messages) response;
|
2013-10-25 17:19:00 +02:00
|
|
|
processLoadedMedia(res, uid, offset, count, max_id, false, classGuid);
|
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().bindRequestToGuid(reqId, classGuid);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void processLoadedMediaCount(final int count, final long uid, final int classGuid, final boolean fromCache) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
int lower_part = (int)uid;
|
|
|
|
if (fromCache && count == -1 && lower_part != 0) {
|
|
|
|
getMediaCount(uid, classGuid, false);
|
|
|
|
} else {
|
|
|
|
if (!fromCache) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putMediaCount(uid, count);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.mediaCountDidLoaded, uid, (fromCache && count == -1 ? 0 : count), fromCache);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
public void getMediaCount(final long uid, final int classGuid, boolean fromCache) {
|
|
|
|
int lower_part = (int)uid;
|
|
|
|
if (fromCache || lower_part == 0) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().getMediaCount(uid, classGuid);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
|
|
|
TLRPC.TL_messages_search req = new TLRPC.TL_messages_search();
|
|
|
|
req.offset = 0;
|
|
|
|
req.limit = 1;
|
|
|
|
req.max_id = 0;
|
|
|
|
req.filter = new TLRPC.TL_inputMessagesFilterPhotoVideo();
|
|
|
|
req.q = "";
|
|
|
|
if (uid < 0) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerChat();
|
|
|
|
req.peer.chat_id = -lower_part;
|
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(lower_part);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (user instanceof TLRPC.TL_userForeign || user instanceof TLRPC.TL_userRequest) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerForeign();
|
|
|
|
req.peer.access_hash = user.access_hash;
|
|
|
|
} else {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerContact();
|
|
|
|
}
|
|
|
|
req.peer.user_id = lower_part;
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
long reqId = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
final TLRPC.messages_Messages res = (TLRPC.messages_Messages) response;
|
2014-08-02 01:31:15 +02:00
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, true, true);
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-08-02 01:31:15 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, false);
|
2014-08-02 01:31:15 +02:00
|
|
|
for (TLRPC.Chat chat : res.chats) {
|
2014-08-22 16:24:33 +02:00
|
|
|
putChat(chat, false);
|
2014-08-02 01:31:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
if (res instanceof TLRPC.TL_messages_messagesSlice) {
|
|
|
|
processLoadedMediaCount(res.count, uid, classGuid, false);
|
|
|
|
} else {
|
|
|
|
processLoadedMediaCount(res.messages.size(), uid, classGuid, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().bindRequestToGuid(reqId, classGuid);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void uploadAndApplyUserAvatar(TLRPC.PhotoSize bigPhoto) {
|
|
|
|
if (bigPhoto != null) {
|
2014-09-25 05:54:35 +02:00
|
|
|
uploadingAvatar = FileLoader.getInstance().getDirectory(FileLoader.MEDIA_DIR_CACHE) + "/" + bigPhoto.location.volume_id + "_" + bigPhoto.location.local_id + ".jpg";
|
2014-09-01 17:43:03 +02:00
|
|
|
FileLoader.getInstance().uploadFile(uploadingAvatar, false, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-22 23:31:55 +01:00
|
|
|
public void deleteMessages(ArrayList<Integer> messages, ArrayList<Long> randoms, TLRPC.EncryptedChat encryptedChat) {
|
2014-09-14 01:40:36 +02:00
|
|
|
if (messages == null) {
|
|
|
|
return;
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
for (Integer id : messages) {
|
|
|
|
MessageObject obj = dialogMessage.get(id);
|
|
|
|
if (obj != null) {
|
|
|
|
obj.deleted = true;
|
|
|
|
}
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().markMessagesAsDeleted(messages, true);
|
|
|
|
MessagesStorage.getInstance().updateDialogsWithDeletedMessages(messages, true);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.messagesDeleted, messages);
|
2014-03-22 23:31:55 +01:00
|
|
|
|
|
|
|
if (randoms != null && encryptedChat != null && !randoms.isEmpty()) {
|
2014-10-22 22:01:07 +02:00
|
|
|
SendMessagesHelper.getInstance().sendMessagesDeleteMessage(encryptedChat, randoms, null);
|
2014-03-22 23:31:55 +01:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
ArrayList<Integer> toSend = new ArrayList<Integer>();
|
|
|
|
for (Integer mid : messages) {
|
|
|
|
if (mid > 0) {
|
|
|
|
toSend.add(mid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (toSend.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
TLRPC.TL_messages_deleteMessages req = new TLRPC.TL_messages_deleteMessages();
|
|
|
|
req.id = messages;
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void deleteDialog(final long did, int offset, final boolean onlyHistory) {
|
|
|
|
TLRPC.TL_dialog dialog = dialogs_dict.get(did);
|
|
|
|
if (dialog != null) {
|
|
|
|
int lower_part = (int)did;
|
2014-07-27 12:53:00 +02:00
|
|
|
int high_id = (int)(did >> 32);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
if (offset == 0) {
|
|
|
|
if (!onlyHistory) {
|
|
|
|
dialogs.remove(dialog);
|
|
|
|
dialogsServerOnly.remove(dialog);
|
|
|
|
dialogs_dict.remove(did);
|
|
|
|
totalDialogsCount--;
|
2014-07-27 00:28:33 +02:00
|
|
|
} else {
|
|
|
|
dialog.unread_count = 0;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
dialogMessage.remove(dialog.top_message);
|
2014-07-30 09:49:39 +02:00
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-30 09:49:39 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationsController.getInstance().processReadMessages(null, did, 0, Integer.MAX_VALUE, false);
|
2014-07-30 09:49:39 +02:00
|
|
|
HashMap<Long, Integer> dialogsToUpdate = new HashMap<Long, Integer>();
|
|
|
|
dialogsToUpdate.put(did, 0);
|
2014-08-27 00:26:25 +02:00
|
|
|
NotificationsController.getInstance().processDialogsUpdateRead(dialogsToUpdate);
|
2014-07-30 09:49:39 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().deleteDialog(did, onlyHistory);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.removeAllMessagesFromDialog, did);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-07-27 12:53:00 +02:00
|
|
|
if (high_id == 1) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
if (lower_part != 0) {
|
|
|
|
TLRPC.TL_messages_deleteHistory req = new TLRPC.TL_messages_deleteHistory();
|
|
|
|
req.offset = offset;
|
|
|
|
if (did < 0) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerChat();
|
|
|
|
req.peer.chat_id = -lower_part;
|
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(lower_part);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (user instanceof TLRPC.TL_userForeign || user instanceof TLRPC.TL_userRequest) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerForeign();
|
|
|
|
req.peer.access_hash = user.access_hash;
|
|
|
|
} else {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerContact();
|
|
|
|
}
|
|
|
|
req.peer.user_id = lower_part;
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
TLRPC.TL_messages_affectedHistory res = (TLRPC.TL_messages_affectedHistory) response;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (res.offset > 0) {
|
|
|
|
deleteDialog(did, res.offset, onlyHistory);
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
processNewDifferenceParams(res.seq, res.pts, -1);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2014-07-27 12:53:00 +02:00
|
|
|
if (onlyHistory) {
|
2014-10-22 22:01:07 +02:00
|
|
|
SendMessagesHelper.getInstance().sendClearHistoryMessage(getEncryptedChat(high_id), null);
|
2014-07-27 12:53:00 +02:00
|
|
|
} else {
|
|
|
|
declineSecretChat(high_id);
|
2014-03-22 23:31:55 +01:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-08 12:17:06 +02:00
|
|
|
public void loadChatInfo(final int chat_id, Semaphore semaphore) {
|
|
|
|
MessagesStorage.getInstance().loadChatInfo(chat_id, semaphore);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void processChatInfo(final int chat_id, final TLRPC.ChatParticipants info, final ArrayList<TLRPC.User> usersArr, final boolean fromCache) {
|
|
|
|
if (info == null && fromCache) {
|
|
|
|
TLRPC.TL_messages_getFullChat req = new TLRPC.TL_messages_getFullChat();
|
|
|
|
req.chat_id = chat_id;
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error != null) {
|
|
|
|
return;
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
final TLRPC.TL_messages_chatFull res = (TLRPC.TL_messages_chatFull) response;
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, true, true);
|
|
|
|
MessagesStorage.getInstance().updateChatInfo(chat_id, res.full_chat.participants, false);
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, false);
|
|
|
|
putChats(res.chats, false);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatInfoDidLoaded, chat_id, res.full_chat.participants);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(usersArr, fromCache);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatInfoDidLoaded, chat_id, info);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void updateTimerProc() {
|
|
|
|
long currentTime = System.currentTimeMillis();
|
|
|
|
|
2014-10-14 10:13:16 +02:00
|
|
|
checkDeletingTask(false);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-06-13 12:42:21 +02:00
|
|
|
if (UserConfig.isClientActivated()) {
|
2014-07-27 00:28:33 +02:00
|
|
|
if (ConnectionsManager.getInstance().getPauseTime() == 0 && ApplicationLoader.isScreenOn && !ApplicationLoader.mainInterfacePaused) {
|
2014-02-28 23:28:25 +01:00
|
|
|
if (statusSettingState != 1 && (lastStatusUpdateTime == 0 || lastStatusUpdateTime <= System.currentTimeMillis() - 55000 || offlineSent)) {
|
|
|
|
statusSettingState = 1;
|
|
|
|
|
|
|
|
if (statusRequest != 0) {
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().cancelRpc(statusRequest, true);
|
2014-02-28 23:28:25 +01:00
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
TLRPC.TL_account_updateStatus req = new TLRPC.TL_account_updateStatus();
|
|
|
|
req.offline = false;
|
2014-03-22 23:31:55 +01:00
|
|
|
statusRequest = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
2014-02-28 23:28:25 +01:00
|
|
|
if (error == null) {
|
|
|
|
lastStatusUpdateTime = System.currentTimeMillis();
|
|
|
|
offlineSent = false;
|
|
|
|
statusSettingState = 0;
|
|
|
|
} else {
|
|
|
|
if (lastStatusUpdateTime != 0) {
|
|
|
|
lastStatusUpdateTime += 5000;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
statusRequest = 0;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
} else if (statusSettingState != 2 && !offlineSent && ConnectionsManager.getInstance().getPauseTime() <= System.currentTimeMillis() - 2000) {
|
2014-02-28 23:28:25 +01:00
|
|
|
statusSettingState = 2;
|
|
|
|
if (statusRequest != 0) {
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().cancelRpc(statusRequest, true);
|
2014-02-28 23:28:25 +01:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
TLRPC.TL_account_updateStatus req = new TLRPC.TL_account_updateStatus();
|
|
|
|
req.offline = true;
|
2014-03-22 23:31:55 +01:00
|
|
|
statusRequest = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
2014-02-28 23:28:25 +01:00
|
|
|
if (error == null) {
|
|
|
|
offlineSent = true;
|
|
|
|
} else {
|
|
|
|
if (lastStatusUpdateTime != 0) {
|
|
|
|
lastStatusUpdateTime += 5000;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
statusRequest = 0;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-02-04 19:36:55 +01:00
|
|
|
|
|
|
|
if (updatesStartWaitTime != 0 && updatesStartWaitTime + 1500 < currentTime) {
|
|
|
|
FileLog.e("tmessages", "UPDATES WAIT TIMEOUT - CHECK QUEUE");
|
2014-07-23 01:27:00 +02:00
|
|
|
processUpdatesQueue(0);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-05-20 22:22:44 +02:00
|
|
|
if (!printingUsers.isEmpty() || lastPrintingStringCount != printingUsers.size()) {
|
2014-02-04 19:36:55 +01:00
|
|
|
boolean updated = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
ArrayList<Long> keys = new ArrayList<Long>(printingUsers.keySet());
|
|
|
|
for (int b = 0; b < keys.size(); b++) {
|
|
|
|
Long key = keys.get(b);
|
|
|
|
ArrayList<PrintingUser> arr = printingUsers.get(key);
|
|
|
|
for (int a = 0; a < arr.size(); a++) {
|
|
|
|
PrintingUser user = arr.get(a);
|
|
|
|
if (user.lastTime + 5900 < currentTime) {
|
2014-02-04 19:36:55 +01:00
|
|
|
updated = true;
|
2013-10-25 17:19:00 +02:00
|
|
|
arr.remove(user);
|
|
|
|
a--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (arr.isEmpty()) {
|
|
|
|
printingUsers.remove(key);
|
|
|
|
keys.remove(b);
|
|
|
|
b--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
updatePrintingStrings();
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
if (updated) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_USER_PRINT);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void updatePrintingStrings() {
|
|
|
|
final HashMap<Long, CharSequence> newPrintingStrings = new HashMap<Long, CharSequence>();
|
|
|
|
|
|
|
|
ArrayList<Long> keys = new ArrayList<Long>(printingUsers.keySet());
|
|
|
|
for (Long key : keys) {
|
2014-06-11 01:05:54 +02:00
|
|
|
if (key > 0 || key.intValue() == 0) {
|
2014-03-22 23:31:55 +01:00
|
|
|
newPrintingStrings.put(key, LocaleController.getString("Typing", R.string.Typing));
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
|
|
|
ArrayList<PrintingUser> arr = printingUsers.get(key);
|
|
|
|
int count = 0;
|
|
|
|
String label = "";
|
|
|
|
for (PrintingUser pu : arr) {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(pu.userId);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (user != null) {
|
|
|
|
if (label.length() != 0) {
|
|
|
|
label += ", ";
|
|
|
|
}
|
2014-09-24 04:17:27 +02:00
|
|
|
label += ContactsController.formatName(user.first_name, user.last_name);
|
2013-10-25 17:19:00 +02:00
|
|
|
count++;
|
|
|
|
}
|
|
|
|
if (count == 2) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (label.length() != 0) {
|
|
|
|
if (count > 1) {
|
|
|
|
if (arr.size() > 2) {
|
2014-07-03 16:55:04 +02:00
|
|
|
newPrintingStrings.put(key, Html.fromHtml(String.format("%s %s", label, LocaleController.formatPluralString("AndMoreTyping", arr.size() - 2))));
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2014-03-22 23:31:55 +01:00
|
|
|
newPrintingStrings.put(key, Html.fromHtml(String.format("%s %s", label, LocaleController.getString("AreTyping", R.string.AreTyping))));
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else {
|
2014-03-22 23:31:55 +01:00
|
|
|
newPrintingStrings.put(key, Html.fromHtml(String.format("%s %s", label, LocaleController.getString("IsTyping", R.string.IsTyping))));
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-20 22:22:44 +02:00
|
|
|
lastPrintingStringCount = newPrintingStrings.size();
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
printingStrings = newPrintingStrings;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2014-08-23 01:22:33 +02:00
|
|
|
public void cancelTyping(long dialog_id) {
|
|
|
|
sendingTypings.remove(dialog_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void sendTyping(final long dialog_id, int classGuid) {
|
2013-10-25 17:19:00 +02:00
|
|
|
if (dialog_id == 0) {
|
|
|
|
return;
|
|
|
|
}
|
2014-08-23 01:22:33 +02:00
|
|
|
if (sendingTypings.get(dialog_id) != null) {
|
|
|
|
return;
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
int lower_part = (int)dialog_id;
|
2014-07-27 12:53:00 +02:00
|
|
|
int high_id = (int)(dialog_id >> 32);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (lower_part != 0) {
|
2014-07-27 12:53:00 +02:00
|
|
|
if (high_id == 1) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
TLRPC.TL_messages_setTyping req = new TLRPC.TL_messages_setTyping();
|
|
|
|
if (lower_part < 0) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerChat();
|
|
|
|
req.peer.chat_id = -lower_part;
|
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(lower_part);
|
2013-12-20 20:25:49 +01:00
|
|
|
if (user != null) {
|
|
|
|
if (user instanceof TLRPC.TL_userForeign || user instanceof TLRPC.TL_userRequest) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerForeign();
|
|
|
|
req.peer.user_id = user.id;
|
|
|
|
req.peer.access_hash = user.access_hash;
|
|
|
|
} else {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerContact();
|
|
|
|
req.peer.user_id = user.id;
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2013-12-20 20:25:49 +01:00
|
|
|
return;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-10-07 22:14:27 +02:00
|
|
|
req.action = new TLRPC.TL_sendMessageTypingAction();
|
2014-08-23 01:22:33 +02:00
|
|
|
sendingTypings.put(dialog_id, true);
|
2014-03-22 23:31:55 +01:00
|
|
|
long reqId = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
2014-08-23 01:22:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
sendingTypings.remove(dialog_id);
|
|
|
|
}
|
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-12 17:38:37 +02:00
|
|
|
}, true, RPCRequest.RPCRequestClassGeneric | RPCRequest.RPCRequestClassFailOnServerErrors);
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().bindRequestToGuid(reqId, classGuid);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.EncryptedChat chat = getEncryptedChat(high_id);
|
2014-07-27 12:53:00 +02:00
|
|
|
if (chat.auth_key != null && chat.auth_key.length > 1 && chat instanceof TLRPC.TL_encryptedChat) {
|
|
|
|
TLRPC.TL_messages_setEncryptedTyping req = new TLRPC.TL_messages_setEncryptedTyping();
|
|
|
|
req.peer = new TLRPC.TL_inputEncryptedChat();
|
|
|
|
req.peer.chat_id = chat.id;
|
|
|
|
req.peer.access_hash = chat.access_hash;
|
|
|
|
req.typing = true;
|
2014-08-23 01:22:33 +02:00
|
|
|
sendingTypings.put(dialog_id, true);
|
2014-07-27 12:53:00 +02:00
|
|
|
long reqId = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
2014-08-23 01:22:33 +02:00
|
|
|
sendingTypings.remove(dialog_id);
|
2014-07-27 12:53:00 +02:00
|
|
|
}
|
|
|
|
}, true, RPCRequest.RPCRequestClassGeneric | RPCRequest.RPCRequestClassFailOnServerErrors);
|
|
|
|
ConnectionsManager.getInstance().bindRequestToGuid(reqId, classGuid);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-08 22:22:22 +02:00
|
|
|
public void loadMessages(final long dialog_id, final int count, final int max_id, boolean fromCache, int midDate, final int classGuid, boolean from_unread, boolean forward, final Semaphore semaphore) {
|
2013-10-25 17:19:00 +02:00
|
|
|
int lower_part = (int)dialog_id;
|
|
|
|
if (fromCache || lower_part == 0) {
|
2014-10-08 22:22:22 +02:00
|
|
|
MessagesStorage.getInstance().getMessages(dialog_id, count, max_id, midDate, classGuid, from_unread, forward, semaphore);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
|
|
|
TLRPC.TL_messages_getHistory req = new TLRPC.TL_messages_getHistory();
|
|
|
|
if (lower_part < 0) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerChat();
|
|
|
|
req.peer.chat_id = -lower_part;
|
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(lower_part);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (user instanceof TLRPC.TL_userForeign || user instanceof TLRPC.TL_userRequest) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerForeign();
|
|
|
|
req.peer.user_id = user.id;
|
|
|
|
req.peer.access_hash = user.access_hash;
|
|
|
|
} else {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerContact();
|
|
|
|
req.peer.user_id = user.id;
|
|
|
|
}
|
|
|
|
}
|
2014-08-02 01:31:15 +02:00
|
|
|
req.offset = 0;
|
2013-10-25 17:19:00 +02:00
|
|
|
req.limit = count;
|
|
|
|
req.max_id = max_id;
|
2014-03-22 23:31:55 +01:00
|
|
|
long reqId = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
final TLRPC.messages_Messages res = (TLRPC.messages_Messages) response;
|
2014-10-08 22:22:22 +02:00
|
|
|
processLoadedMessages(res, dialog_id, count, max_id, false, classGuid, 0, 0, 0, 0, false, semaphore);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().bindRequestToGuid(reqId, classGuid);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-08 22:22:22 +02:00
|
|
|
public void processLoadedMessages(final TLRPC.messages_Messages messagesRes, final long dialog_id, final int count, final int max_id, final boolean isCache, final int classGuid, final int first_unread, final int last_unread, final int unread_count, final int last_date, final boolean isForward, final Semaphore semaphore) {
|
2013-10-25 17:19:00 +02:00
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
int lower_id = (int)dialog_id;
|
|
|
|
if (!isCache) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putMessages(messagesRes, dialog_id);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2013-12-20 20:25:49 +01:00
|
|
|
if (lower_id != 0 && isCache && messagesRes.messages.size() == 0 && !isForward) {
|
2014-10-08 22:22:22 +02:00
|
|
|
if (semaphore != null) {
|
|
|
|
semaphore.release();
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-10-08 22:22:22 +02:00
|
|
|
loadMessages(dialog_id, count, max_id, false, 0, classGuid, false, false, null);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
final HashMap<Integer, TLRPC.User> usersLocal = new HashMap<Integer, TLRPC.User>();
|
|
|
|
for (TLRPC.User u : messagesRes.users) {
|
|
|
|
usersLocal.put(u.id, u);
|
|
|
|
}
|
|
|
|
final ArrayList<MessageObject> objects = new ArrayList<MessageObject>();
|
|
|
|
for (TLRPC.Message message : messagesRes.messages) {
|
|
|
|
message.dialog_id = dialog_id;
|
2014-07-27 00:28:33 +02:00
|
|
|
objects.add(new MessageObject(message, usersLocal, 2));
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-10-08 22:22:22 +02:00
|
|
|
if (semaphore != null) {
|
|
|
|
putUsers(messagesRes.users, isCache);
|
|
|
|
putChats(messagesRes.chats, isCache);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.messagesDidLoaded, dialog_id, count, objects, isCache, first_unread, last_unread, unread_count, last_date, isForward);
|
|
|
|
semaphore.release();
|
|
|
|
} else {
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
putUsers(messagesRes.users, isCache);
|
|
|
|
putChats(messagesRes.chats, isCache);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.messagesDidLoaded, dialog_id, count, objects, isCache, first_unread, last_unread, unread_count, last_date, isForward);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
public void loadDialogs(final int offset, final int serverOffset, final int count, boolean fromCache) {
|
|
|
|
if (loadingDialogs) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
loadingDialogs = true;
|
|
|
|
|
|
|
|
if (fromCache) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().getDialogs(offset, serverOffset, count);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
|
|
|
TLRPC.TL_messages_getDialogs req = new TLRPC.TL_messages_getDialogs();
|
|
|
|
req.offset = serverOffset;
|
|
|
|
req.limit = count;
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
final TLRPC.messages_Dialogs dialogsRes = (TLRPC.messages_Dialogs) response;
|
2013-10-25 17:19:00 +02:00
|
|
|
processLoadedDialogs(dialogsRes, null, offset, serverOffset, count, false, false);
|
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void applyDialogsNotificationsSettings(ArrayList<TLRPC.TL_dialog> dialogs) {
|
|
|
|
SharedPreferences.Editor editor = null;
|
|
|
|
for (TLRPC.TL_dialog dialog : dialogs) {
|
|
|
|
if (dialog.peer != null && dialog.notify_settings instanceof TLRPC.TL_peerNotifySettings) {
|
|
|
|
if (editor == null) {
|
|
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("Notifications", Activity.MODE_PRIVATE);
|
|
|
|
editor = preferences.edit();
|
|
|
|
}
|
|
|
|
int dialog_id = dialog.peer.user_id;
|
|
|
|
if (dialog_id == 0) {
|
|
|
|
dialog_id = -dialog.peer.chat_id;
|
|
|
|
}
|
|
|
|
if (dialog.notify_settings.mute_until != 0) {
|
|
|
|
editor.putInt("notify2_" + dialog_id, 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (editor != null) {
|
|
|
|
editor.commit();
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-11 15:54:17 +02:00
|
|
|
public void processDialogsUpdateRead(final HashMap<Long, Integer> dialogsToUpdate) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-02-28 23:28:25 +01:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
for (HashMap.Entry<Long, Integer> entry : dialogsToUpdate.entrySet()) {
|
|
|
|
TLRPC.TL_dialog currentDialog = dialogs_dict.get(entry.getKey());
|
|
|
|
if (currentDialog != null) {
|
|
|
|
currentDialog.unread_count = entry.getValue();
|
|
|
|
}
|
|
|
|
}
|
2014-08-27 00:26:25 +02:00
|
|
|
NotificationsController.getInstance().processDialogsUpdateRead(dialogsToUpdate);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2014-02-28 23:28:25 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
public void processDialogsUpdate(final TLRPC.messages_Dialogs dialogsRes, ArrayList<TLRPC.EncryptedChat> encChats) {
|
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
final HashMap<Long, TLRPC.TL_dialog> new_dialogs_dict = new HashMap<Long, TLRPC.TL_dialog>();
|
|
|
|
final HashMap<Integer, MessageObject> new_dialogMessage = new HashMap<Integer, MessageObject>();
|
|
|
|
final HashMap<Integer, TLRPC.User> usersLocal = new HashMap<Integer, TLRPC.User>();
|
2014-07-11 15:54:17 +02:00
|
|
|
final HashMap<Long, Integer> dialogsToUpdate = new HashMap<Long, Integer>();
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
for (TLRPC.User u : dialogsRes.users) {
|
|
|
|
usersLocal.put(u.id, u);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (TLRPC.Message m : dialogsRes.messages) {
|
2014-07-27 00:28:33 +02:00
|
|
|
new_dialogMessage.put(m.id, new MessageObject(m, usersLocal, 0));
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
for (TLRPC.TL_dialog d : dialogsRes.dialogs) {
|
|
|
|
if (d.last_message_date == 0) {
|
|
|
|
MessageObject mess = new_dialogMessage.get(d.top_message);
|
|
|
|
if (mess != null) {
|
|
|
|
d.last_message_date = mess.messageOwner.date;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (d.id == 0) {
|
|
|
|
if (d.peer instanceof TLRPC.TL_peerUser) {
|
|
|
|
d.id = d.peer.user_id;
|
|
|
|
} else if (d.peer instanceof TLRPC.TL_peerChat) {
|
|
|
|
d.id = -d.peer.chat_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
new_dialogs_dict.put(d.id, d);
|
2014-07-11 15:54:17 +02:00
|
|
|
dialogsToUpdate.put(d.id, d.unread_count);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(dialogsRes.users, true);
|
|
|
|
putChats(dialogsRes.chats, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
for (HashMap.Entry<Long, TLRPC.TL_dialog> pair : new_dialogs_dict.entrySet()) {
|
|
|
|
long key = pair.getKey();
|
|
|
|
TLRPC.TL_dialog value = pair.getValue();
|
|
|
|
TLRPC.TL_dialog currentDialog = dialogs_dict.get(key);
|
|
|
|
if (currentDialog == null) {
|
|
|
|
dialogs_dict.put(key, value);
|
|
|
|
dialogMessage.put(value.top_message, new_dialogMessage.get(value.top_message));
|
|
|
|
} else {
|
|
|
|
currentDialog.unread_count = value.unread_count;
|
|
|
|
MessageObject oldMsg = dialogMessage.get(currentDialog.top_message);
|
|
|
|
if (oldMsg == null || currentDialog.top_message > 0) {
|
|
|
|
if (oldMsg != null && oldMsg.deleted || value.top_message > currentDialog.top_message) {
|
|
|
|
dialogs_dict.put(key, value);
|
|
|
|
if (oldMsg != null) {
|
|
|
|
dialogMessage.remove(oldMsg.messageOwner.id);
|
|
|
|
}
|
|
|
|
dialogMessage.put(value.top_message, new_dialogMessage.get(value.top_message));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
MessageObject newMsg = new_dialogMessage.get(value.top_message);
|
|
|
|
if (oldMsg.deleted || newMsg == null || newMsg.messageOwner.date > oldMsg.messageOwner.date) {
|
|
|
|
dialogs_dict.put(key, value);
|
|
|
|
dialogMessage.remove(oldMsg.messageOwner.id);
|
|
|
|
dialogMessage.put(value.top_message, new_dialogMessage.get(value.top_message));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dialogs.clear();
|
|
|
|
dialogsServerOnly.clear();
|
|
|
|
dialogs.addAll(dialogs_dict.values());
|
|
|
|
Collections.sort(dialogs, new Comparator<TLRPC.TL_dialog>() {
|
|
|
|
@Override
|
|
|
|
public int compare(TLRPC.TL_dialog tl_dialog, TLRPC.TL_dialog tl_dialog2) {
|
|
|
|
if (tl_dialog.last_message_date == tl_dialog2.last_message_date) {
|
|
|
|
return 0;
|
|
|
|
} else if (tl_dialog.last_message_date < tl_dialog2.last_message_date) {
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
for (TLRPC.TL_dialog d : dialogs) {
|
2014-07-30 09:49:39 +02:00
|
|
|
int high_id = (int)(d.id >> 32);
|
|
|
|
if ((int)d.id != 0 && high_id != 1) {
|
2013-10-25 17:19:00 +02:00
|
|
|
dialogsServerOnly.add(d);
|
|
|
|
}
|
|
|
|
}
|
2014-08-27 00:26:25 +02:00
|
|
|
NotificationsController.getInstance().processDialogsUpdateRead(dialogsToUpdate);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
public void processLoadedDialogs(final TLRPC.messages_Dialogs dialogsRes, final ArrayList<TLRPC.EncryptedChat> encChats, final int offset, final int serverOffset, final int count, final boolean isCache, final boolean resetEnd) {
|
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (isCache && dialogsRes.dialogs.size() == 0) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(dialogsRes.users, isCache);
|
2013-10-25 17:19:00 +02:00
|
|
|
loadingDialogs = false;
|
|
|
|
if (resetEnd) {
|
|
|
|
dialogsEndReached = false;
|
|
|
|
}
|
|
|
|
loadDialogs(offset, serverOffset, count, false);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
final HashMap<Long, TLRPC.TL_dialog> new_dialogs_dict = new HashMap<Long, TLRPC.TL_dialog>();
|
|
|
|
final HashMap<Integer, MessageObject> new_dialogMessage = new HashMap<Integer, MessageObject>();
|
|
|
|
final HashMap<Integer, TLRPC.User> usersLocal = new HashMap<Integer, TLRPC.User>();
|
|
|
|
int new_totalDialogsCount;
|
|
|
|
|
|
|
|
if (!isCache) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putDialogs(dialogsRes);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (dialogsRes instanceof TLRPC.TL_messages_dialogsSlice) {
|
|
|
|
TLRPC.TL_messages_dialogsSlice slice = (TLRPC.TL_messages_dialogsSlice)dialogsRes;
|
|
|
|
new_totalDialogsCount = slice.count;
|
|
|
|
} else {
|
|
|
|
new_totalDialogsCount = dialogsRes.dialogs.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
for (TLRPC.User u : dialogsRes.users) {
|
|
|
|
usersLocal.put(u.id, u);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (TLRPC.Message m : dialogsRes.messages) {
|
2014-07-27 00:28:33 +02:00
|
|
|
new_dialogMessage.put(m.id, new MessageObject(m, usersLocal, 0));
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
for (TLRPC.TL_dialog d : dialogsRes.dialogs) {
|
|
|
|
if (d.last_message_date == 0) {
|
|
|
|
MessageObject mess = new_dialogMessage.get(d.top_message);
|
|
|
|
if (mess != null) {
|
|
|
|
d.last_message_date = mess.messageOwner.date;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (d.id == 0) {
|
|
|
|
if (d.peer instanceof TLRPC.TL_peerUser) {
|
|
|
|
d.id = d.peer.user_id;
|
|
|
|
} else if (d.peer instanceof TLRPC.TL_peerChat) {
|
|
|
|
d.id = -d.peer.chat_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
new_dialogs_dict.put(d.id, d);
|
|
|
|
}
|
|
|
|
|
|
|
|
final int arg1 = new_totalDialogsCount;
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-07-03 00:39:05 +02:00
|
|
|
if (!isCache) {
|
|
|
|
applyDialogsNotificationsSettings(dialogsRes.dialogs);
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(dialogsRes.users, isCache);
|
|
|
|
putChats(dialogsRes.chats, isCache);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (encChats != null) {
|
|
|
|
for (TLRPC.EncryptedChat encryptedChat : encChats) {
|
2014-10-22 22:01:07 +02:00
|
|
|
if (encryptedChat instanceof TLRPC.TL_encryptedChat && AndroidUtilities.getMyLayerVersion(encryptedChat.layer) < SendMessagesHelper.CURRENT_SECRET_CHAT_LAYER) {
|
|
|
|
SendMessagesHelper.getInstance().sendNotifyLayerMessage(encryptedChat, null);
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
putEncryptedChat(encryptedChat, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
loadingDialogs = false;
|
|
|
|
totalDialogsCount = arg1;
|
|
|
|
|
|
|
|
for (HashMap.Entry<Long, TLRPC.TL_dialog> pair : new_dialogs_dict.entrySet()) {
|
|
|
|
long key = pair.getKey();
|
|
|
|
TLRPC.TL_dialog value = pair.getValue();
|
|
|
|
TLRPC.TL_dialog currentDialog = dialogs_dict.get(key);
|
|
|
|
if (currentDialog == null) {
|
|
|
|
dialogs_dict.put(key, value);
|
|
|
|
dialogMessage.put(value.top_message, new_dialogMessage.get(value.top_message));
|
|
|
|
} else {
|
|
|
|
MessageObject oldMsg = dialogMessage.get(value.top_message);
|
|
|
|
if (oldMsg == null || currentDialog.top_message > 0) {
|
|
|
|
if (oldMsg != null && oldMsg.deleted || value.top_message > currentDialog.top_message) {
|
|
|
|
if (oldMsg != null) {
|
|
|
|
dialogMessage.remove(oldMsg.messageOwner.id);
|
|
|
|
}
|
|
|
|
dialogs_dict.put(key, value);
|
|
|
|
dialogMessage.put(value.top_message, new_dialogMessage.get(value.top_message));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
MessageObject newMsg = new_dialogMessage.get(value.top_message);
|
|
|
|
if (oldMsg.deleted || newMsg == null || newMsg.messageOwner.date > oldMsg.messageOwner.date) {
|
|
|
|
dialogMessage.remove(oldMsg.messageOwner.id);
|
|
|
|
dialogs_dict.put(key, value);
|
|
|
|
dialogMessage.put(value.top_message, new_dialogMessage.get(value.top_message));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dialogs.clear();
|
|
|
|
dialogsServerOnly.clear();
|
|
|
|
dialogs.addAll(dialogs_dict.values());
|
|
|
|
Collections.sort(dialogs, new Comparator<TLRPC.TL_dialog>() {
|
|
|
|
@Override
|
|
|
|
public int compare(TLRPC.TL_dialog tl_dialog, TLRPC.TL_dialog tl_dialog2) {
|
|
|
|
if (tl_dialog.last_message_date == tl_dialog2.last_message_date) {
|
|
|
|
return 0;
|
|
|
|
} else if (tl_dialog.last_message_date < tl_dialog2.last_message_date) {
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
for (TLRPC.TL_dialog d : dialogs) {
|
2014-07-30 09:49:39 +02:00
|
|
|
int high_id = (int)(d.id >> 32);
|
|
|
|
if ((int)d.id != 0 && high_id != 1) {
|
2013-10-25 17:19:00 +02:00
|
|
|
dialogsServerOnly.add(d);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dialogsEndReached = (dialogsRes.dialogs.size() == 0 || dialogsRes.dialogs.size() != count) && !isCache;
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2014-10-22 22:01:07 +02:00
|
|
|
public void markMessageAsRead(final long dialog_id, final long random_id, int ttl) {
|
2014-10-23 17:30:35 +02:00
|
|
|
if (random_id == 0 || dialog_id == 0 || ttl <= 0) {
|
2014-10-09 17:55:05 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
int lower_part = (int)dialog_id;
|
|
|
|
int high_id = (int)(dialog_id >> 32);
|
|
|
|
if (lower_part != 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
TLRPC.EncryptedChat chat = getEncryptedChat(high_id);
|
|
|
|
if (chat == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ArrayList<Long> random_ids = new ArrayList<Long>();
|
|
|
|
random_ids.add(random_id);
|
2014-10-22 22:01:07 +02:00
|
|
|
SendMessagesHelper.getInstance().sendMessagesReadMessage(chat, random_ids, null);
|
2014-10-23 17:30:35 +02:00
|
|
|
int time = ConnectionsManager.getInstance().getCurrentTime();
|
|
|
|
MessagesStorage.getInstance().createTaskForSecretChat(chat.id, time, time, 0, random_ids);
|
2014-10-09 17:55:05 +02:00
|
|
|
}
|
|
|
|
|
2014-08-08 12:17:06 +02:00
|
|
|
public void markDialogAsRead(final long dialog_id, final int max_id, final int max_positive_id, final int offset, final int max_date, final boolean was, final boolean popup) {
|
2013-10-25 17:19:00 +02:00
|
|
|
int lower_part = (int)dialog_id;
|
2014-07-27 12:53:00 +02:00
|
|
|
int high_id = (int)(dialog_id >> 32);
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
if (lower_part != 0) {
|
2014-10-04 17:56:09 +02:00
|
|
|
if (max_positive_id == 0 && offset == 0 || high_id == 1) {
|
2013-10-25 17:19:00 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
TLRPC.TL_messages_readHistory req = new TLRPC.TL_messages_readHistory();
|
|
|
|
if (lower_part < 0) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerChat();
|
|
|
|
req.peer.chat_id = -lower_part;
|
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(lower_part);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (user instanceof TLRPC.TL_userForeign || user instanceof TLRPC.TL_userRequest) {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerForeign();
|
|
|
|
req.peer.user_id = user.id;
|
|
|
|
req.peer.access_hash = user.access_hash;
|
|
|
|
} else {
|
|
|
|
req.peer = new TLRPC.TL_inputPeerContact();
|
|
|
|
req.peer.user_id = user.id;
|
|
|
|
}
|
|
|
|
}
|
2013-12-20 20:25:49 +01:00
|
|
|
req.max_id = max_positive_id;
|
2013-10-25 17:19:00 +02:00
|
|
|
req.offset = offset;
|
2014-10-07 22:14:27 +02:00
|
|
|
req.read_contents = true;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (offset == 0) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().processPendingRead(dialog_id, max_positive_id, max_date, false);
|
2014-07-12 12:23:36 +02:00
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-12 12:23:36 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
TLRPC.TL_dialog dialog = dialogs_dict.get(dialog_id);
|
|
|
|
if (dialog != null) {
|
|
|
|
dialog.unread_count = 0;
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
|
|
|
}
|
|
|
|
if (!popup) {
|
|
|
|
NotificationsController.getInstance().processReadMessages(null, dialog_id, 0, max_positive_id, false);
|
|
|
|
HashMap<Long, Integer> dialogsToUpdate = new HashMap<Long, Integer>();
|
|
|
|
dialogsToUpdate.put(dialog_id, 0);
|
2014-08-27 00:26:25 +02:00
|
|
|
NotificationsController.getInstance().processDialogsUpdateRead(dialogsToUpdate);
|
2014-08-22 16:24:33 +02:00
|
|
|
} else {
|
|
|
|
NotificationsController.getInstance().processReadMessages(null, dialog_id, 0, max_positive_id, true);
|
|
|
|
HashMap<Long, Integer> dialogsToUpdate = new HashMap<Long, Integer>();
|
2014-08-27 00:26:25 +02:00
|
|
|
dialogsToUpdate.put(dialog_id, -1);
|
|
|
|
NotificationsController.getInstance().processDialogsUpdateRead(dialogsToUpdate);
|
2014-08-22 16:24:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2014-06-20 02:18:13 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
if (req.max_id != Integer.MAX_VALUE) {
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
|
|
|
MessagesStorage.getInstance().processPendingRead(dialog_id, max_positive_id, max_date, true);
|
|
|
|
TLRPC.TL_messages_affectedHistory res = (TLRPC.TL_messages_affectedHistory) response;
|
|
|
|
if (res.offset > 0) {
|
|
|
|
markDialogAsRead(dialog_id, 0, max_positive_id, res.offset, max_date, was, popup);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
processNewDifferenceParams(res.seq, res.pts, -1);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
if (max_date == 0) {
|
|
|
|
return;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.EncryptedChat chat = getEncryptedChat(high_id);
|
|
|
|
if (chat.auth_key != null && chat.auth_key.length > 1 && chat instanceof TLRPC.TL_encryptedChat) {
|
|
|
|
TLRPC.TL_messages_readEncryptedHistory req = new TLRPC.TL_messages_readEncryptedHistory();
|
|
|
|
req.peer = new TLRPC.TL_inputEncryptedChat();
|
|
|
|
req.peer.chat_id = chat.id;
|
|
|
|
req.peer.access_hash = chat.access_hash;
|
|
|
|
req.max_date = max_date;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
//MessagesStorage.getInstance().processPendingRead(dialog_id, max_id, max_date, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
});
|
|
|
|
}
|
|
|
|
MessagesStorage.getInstance().processPendingRead(dialog_id, max_id, max_date, false);
|
|
|
|
|
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationsController.getInstance().processReadMessages(null, dialog_id, max_date, 0, popup);
|
|
|
|
TLRPC.TL_dialog dialog = dialogs_dict.get(dialog_id);
|
|
|
|
if (dialog != null) {
|
|
|
|
dialog.unread_count = 0;
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
HashMap<Long, Integer> dialogsToUpdate = new HashMap<Long, Integer>();
|
|
|
|
dialogsToUpdate.put(dialog_id, 0);
|
2014-08-27 00:26:25 +02:00
|
|
|
NotificationsController.getInstance().processDialogsUpdateRead(dialogsToUpdate);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
if (chat.ttl > 0 && was) {
|
|
|
|
int serverTime = Math.max(ConnectionsManager.getInstance().getCurrentTime(), max_date);
|
2014-10-09 17:55:05 +02:00
|
|
|
MessagesStorage.getInstance().createTaskForSecretChat(chat.id, serverTime, serverTime, 0, null);
|
2014-08-22 16:24:33 +02:00
|
|
|
}
|
2014-02-28 23:28:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
private void processPendingEncMessages() {
|
2014-10-09 17:55:05 +02:00
|
|
|
if (!pendingEncMessagesToDelete.isEmpty()) {
|
|
|
|
ArrayList<Long> arr = new ArrayList<Long>(pendingEncMessagesToDelete);
|
|
|
|
MessagesStorage.getInstance().markMessagesAsDeletedByRandoms(arr);
|
|
|
|
pendingEncMessagesToDelete.clear();
|
2014-02-28 23:28:25 +01:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-07-27 00:28:33 +02:00
|
|
|
public long createChat(String title, ArrayList<Integer> selectedContacts, final TLRPC.InputFile uploadedAvatar, boolean isBroadcast) {
|
|
|
|
if (isBroadcast) {
|
|
|
|
TLRPC.TL_chat chat = new TLRPC.TL_chat();
|
|
|
|
chat.id = UserConfig.lastBroadcastId;
|
|
|
|
chat.title = title;
|
|
|
|
chat.photo = new TLRPC.TL_chatPhotoEmpty();
|
|
|
|
chat.participants_count = selectedContacts.size();
|
|
|
|
chat.date = (int)(System.currentTimeMillis() / 1000);
|
|
|
|
chat.left = false;
|
|
|
|
chat.version = 1;
|
|
|
|
UserConfig.lastBroadcastId--;
|
2014-08-22 16:24:33 +02:00
|
|
|
putChat(chat, false);
|
2014-07-27 00:28:33 +02:00
|
|
|
ArrayList<TLRPC.Chat> chatsArrays = new ArrayList<TLRPC.Chat>();
|
|
|
|
chatsArrays.add(chat);
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(null, chatsArrays, true, true);
|
|
|
|
|
|
|
|
TLRPC.TL_chatParticipants participants = new TLRPC.TL_chatParticipants();
|
|
|
|
participants.chat_id = chat.id;
|
|
|
|
participants.admin_id = UserConfig.getClientUserId();
|
|
|
|
participants.version = 1;
|
|
|
|
for (Integer id : selectedContacts) {
|
|
|
|
TLRPC.TL_chatParticipant participant = new TLRPC.TL_chatParticipant();
|
|
|
|
participant.user_id = id;
|
|
|
|
participant.inviter_id = UserConfig.getClientUserId();
|
|
|
|
participant.date = (int)(System.currentTimeMillis() / 1000);
|
|
|
|
participants.participants.add(participant);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
MessagesStorage.getInstance().updateChatInfo(chat.id, participants, false);
|
|
|
|
|
|
|
|
TLRPC.TL_messageService newMsg = new TLRPC.TL_messageService();
|
|
|
|
newMsg.action = new TLRPC.TL_messageActionCreatedBroadcastList();
|
|
|
|
newMsg.local_id = newMsg.id = UserConfig.getNewMessageId();
|
|
|
|
newMsg.from_id = UserConfig.getClientUserId();
|
2014-07-27 12:53:00 +02:00
|
|
|
newMsg.dialog_id = AndroidUtilities.makeBroadcastId(chat.id);
|
2014-07-27 00:28:33 +02:00
|
|
|
newMsg.to_id = new TLRPC.TL_peerChat();
|
|
|
|
newMsg.to_id.chat_id = chat.id;
|
|
|
|
newMsg.date = ConnectionsManager.getInstance().getCurrentTime();
|
|
|
|
newMsg.random_id = 0;
|
|
|
|
UserConfig.saveConfig(false);
|
|
|
|
MessageObject newMsgObj = new MessageObject(newMsg, users);
|
2014-08-22 16:24:33 +02:00
|
|
|
newMsgObj.messageOwner.send_state = MessageObject.MESSAGE_SEND_STATE_SENT;
|
2014-07-27 00:28:33 +02:00
|
|
|
|
|
|
|
ArrayList<MessageObject> objArr = new ArrayList<MessageObject>();
|
|
|
|
objArr.add(newMsgObj);
|
|
|
|
ArrayList<TLRPC.Message> arr = new ArrayList<TLRPC.Message>();
|
|
|
|
arr.add(newMsg);
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(arr, false, true, false, 0);
|
2014-07-27 00:28:33 +02:00
|
|
|
updateInterfaceWithMessages(newMsg.dialog_id, objArr);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatDidCreated, chat.id);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2014-07-27 00:28:33 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
TLRPC.TL_messages_createChat req = new TLRPC.TL_messages_createChat();
|
|
|
|
req.title = title;
|
|
|
|
for (Integer uid : selectedContacts) {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(uid);
|
2014-07-27 00:28:33 +02:00
|
|
|
if (user == null) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
req.users.add(getInputUser(user));
|
|
|
|
}
|
|
|
|
return ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error != null) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-27 00:28:33 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatDidFailCreate);
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
final TLRPC.messages_StatedMessage res = (TLRPC.messages_StatedMessage) response;
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, true, true);
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, false);
|
|
|
|
putChats(res.chats, false);
|
2014-07-27 00:28:33 +02:00
|
|
|
final ArrayList<MessageObject> messagesObj = new ArrayList<MessageObject>();
|
|
|
|
messagesObj.add(new MessageObject(res.message, users));
|
|
|
|
TLRPC.Chat chat = res.chats.get(0);
|
|
|
|
updateInterfaceWithMessages(-chat.id, messagesObj);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatDidCreated, chat.id);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2014-07-27 00:28:33 +02:00
|
|
|
if (uploadedAvatar != null) {
|
|
|
|
changeChatAvatar(chat.id, uploadedAvatar);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
2014-02-04 19:36:55 +01:00
|
|
|
|
2014-07-27 00:28:33 +02:00
|
|
|
final ArrayList<TLRPC.Message> messages = new ArrayList<TLRPC.Message>();
|
|
|
|
messages.add(res.message);
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(messages, true, true, false, 0);
|
|
|
|
processNewDifferenceParams(res.seq, res.pts, -1);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
});
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-07-10 23:15:39 +02:00
|
|
|
public void addUserToChat(int chat_id, final TLRPC.User user, final TLRPC.ChatParticipants info, int count_fwd) {
|
2014-02-04 19:36:55 +01:00
|
|
|
if (user == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-07-27 00:28:33 +02:00
|
|
|
if (chat_id > 0) {
|
|
|
|
TLRPC.TL_messages_addChatUser req = new TLRPC.TL_messages_addChatUser();
|
|
|
|
req.chat_id = chat_id;
|
|
|
|
req.fwd_limit = count_fwd;
|
|
|
|
req.user_id = getInputUser(user);
|
2014-02-04 19:36:55 +01:00
|
|
|
|
2014-07-27 00:28:33 +02:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error != null) {
|
|
|
|
return;
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-07-27 00:28:33 +02:00
|
|
|
final TLRPC.messages_StatedMessage res = (TLRPC.messages_StatedMessage) response;
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, true, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-27 00:28:33 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, false);
|
|
|
|
putChats(res.chats, false);
|
2014-07-27 00:28:33 +02:00
|
|
|
final ArrayList<MessageObject> messagesObj = new ArrayList<MessageObject>();
|
|
|
|
messagesObj.add(new MessageObject(res.message, users));
|
|
|
|
TLRPC.Chat chat = res.chats.get(0);
|
|
|
|
updateInterfaceWithMessages(-chat.id, messagesObj);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_CHAT_MEMBERS);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-07-27 00:28:33 +02:00
|
|
|
if (info != null) {
|
|
|
|
for (TLRPC.TL_chatParticipant p : info.participants) {
|
|
|
|
if (p.user_id == user.id) {
|
|
|
|
return;
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
TLRPC.TL_chatParticipant newPart = new TLRPC.TL_chatParticipant();
|
|
|
|
newPart.user_id = user.id;
|
|
|
|
newPart.inviter_id = UserConfig.getClientUserId();
|
|
|
|
newPart.date = ConnectionsManager.getInstance().getCurrentTime();
|
|
|
|
info.participants.add(0, newPart);
|
|
|
|
MessagesStorage.getInstance().updateChatInfo(info.chat_id, info, true);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatInfoDidLoaded, info.chat_id, info);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
});
|
2014-02-04 19:36:55 +01:00
|
|
|
|
2014-07-27 00:28:33 +02:00
|
|
|
final ArrayList<TLRPC.Message> messages = new ArrayList<TLRPC.Message>();
|
|
|
|
messages.add(res.message);
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(messages, true, true, false, 0);
|
|
|
|
processNewDifferenceParams(res.seq, res.pts, -1);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
});
|
|
|
|
} else {
|
|
|
|
if (info != null) {
|
|
|
|
for (TLRPC.TL_chatParticipant p : info.participants) {
|
|
|
|
if (p.user_id == user.id) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.Chat chat = getChat(chat_id);
|
2014-07-27 00:28:33 +02:00
|
|
|
chat.participants_count++;
|
|
|
|
ArrayList<TLRPC.Chat> chatArrayList = new ArrayList<TLRPC.Chat>();
|
|
|
|
chatArrayList.add(chat);
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(null, chatArrayList, true, true);
|
|
|
|
|
|
|
|
TLRPC.TL_chatParticipant newPart = new TLRPC.TL_chatParticipant();
|
|
|
|
newPart.user_id = user.id;
|
|
|
|
newPart.inviter_id = UserConfig.getClientUserId();
|
|
|
|
newPart.date = ConnectionsManager.getInstance().getCurrentTime();
|
|
|
|
info.participants.add(0, newPart);
|
|
|
|
MessagesStorage.getInstance().updateChatInfo(info.chat_id, info, true);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatInfoDidLoaded, info.chat_id, info);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_CHAT_MEMBERS);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-10-07 22:14:27 +02:00
|
|
|
public void deleteUserFromChat(final int chat_id, final TLRPC.User user, final TLRPC.ChatParticipants info) {
|
2014-02-04 19:36:55 +01:00
|
|
|
if (user == null) {
|
|
|
|
return;
|
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
if (chat_id > 0) {
|
|
|
|
TLRPC.TL_messages_deleteChatUser req = new TLRPC.TL_messages_deleteChatUser();
|
|
|
|
req.chat_id = chat_id;
|
|
|
|
req.user_id = getInputUser(user);
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error != null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
final TLRPC.messages_StatedMessage res = (TLRPC.messages_StatedMessage) response;
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, true, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-27 00:28:33 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, false);
|
|
|
|
putChats(res.chats, false);
|
2014-07-27 00:28:33 +02:00
|
|
|
if (user.id != UserConfig.getClientUserId()) {
|
|
|
|
final ArrayList<MessageObject> messagesObj = new ArrayList<MessageObject>();
|
|
|
|
messagesObj.add(new MessageObject(res.message, users));
|
|
|
|
TLRPC.Chat chat = res.chats.get(0);
|
|
|
|
updateInterfaceWithMessages(-chat.id, messagesObj);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_CHAT_MEMBERS);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
|
|
|
boolean changed = false;
|
|
|
|
if (info != null) {
|
|
|
|
for (int a = 0; a < info.participants.size(); a++) {
|
|
|
|
TLRPC.TL_chatParticipant p = info.participants.get(a);
|
|
|
|
if (p.user_id == user.id) {
|
|
|
|
info.participants.remove(a);
|
|
|
|
changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (changed) {
|
2014-10-07 22:14:27 +02:00
|
|
|
MessagesStorage.getInstance().updateChatInfo(chat_id, info, true);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatInfoDidLoaded, info.chat_id, info);
|
2014-10-07 22:14:27 +02:00
|
|
|
} else {
|
|
|
|
MessagesStorage.getInstance().updateChatInfo(chat_id, user.id, true, 0, 0);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-10-07 22:14:27 +02:00
|
|
|
} else {
|
|
|
|
MessagesStorage.getInstance().updateChatInfo(chat_id, user.id, true, 0, 0);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
if (user.id != UserConfig.getClientUserId()) {
|
|
|
|
final ArrayList<TLRPC.Message> messages = new ArrayList<TLRPC.Message>();
|
|
|
|
messages.add(res.message);
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(messages, true, true, false, 0);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
processNewDifferenceParams(res.seq, res.pts, -1);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
});
|
|
|
|
} else {
|
|
|
|
if (info != null) {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.Chat chat = getChat(chat_id);
|
2014-07-27 00:28:33 +02:00
|
|
|
chat.participants_count--;
|
|
|
|
ArrayList<TLRPC.Chat> chatArrayList = new ArrayList<TLRPC.Chat>();
|
|
|
|
chatArrayList.add(chat);
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(null, chatArrayList, true, true);
|
|
|
|
|
|
|
|
boolean changed = false;
|
|
|
|
if (info != null) {
|
|
|
|
for (int a = 0; a < info.participants.size(); a++) {
|
|
|
|
TLRPC.TL_chatParticipant p = info.participants.get(a);
|
|
|
|
if (p.user_id == user.id) {
|
|
|
|
info.participants.remove(a);
|
|
|
|
changed = true;
|
|
|
|
break;
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
|
|
|
if (changed) {
|
|
|
|
MessagesStorage.getInstance().updateChatInfo(info.chat_id, info, true);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatInfoDidLoaded, info.chat_id, info);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_CHAT_MEMBERS);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void changeChatTitle(int chat_id, String title) {
|
2014-07-27 00:28:33 +02:00
|
|
|
if (chat_id > 0) {
|
|
|
|
TLRPC.TL_messages_editChatTitle req = new TLRPC.TL_messages_editChatTitle();
|
|
|
|
req.chat_id = chat_id;
|
|
|
|
req.title = title;
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error != null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
final TLRPC.messages_StatedMessage res = (TLRPC.messages_StatedMessage) response;
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, true, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-27 00:28:33 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, false);
|
|
|
|
putChats(res.chats, false);
|
2014-07-27 00:28:33 +02:00
|
|
|
final ArrayList<MessageObject> messagesObj = new ArrayList<MessageObject>();
|
|
|
|
messagesObj.add(new MessageObject(res.message, users));
|
|
|
|
TLRPC.Chat chat = res.chats.get(0);
|
|
|
|
updateInterfaceWithMessages(-chat.id, messagesObj);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_CHAT_NAME);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
});
|
2014-02-04 19:36:55 +01:00
|
|
|
|
2014-07-27 00:28:33 +02:00
|
|
|
final ArrayList<TLRPC.Message> messages = new ArrayList<TLRPC.Message>();
|
|
|
|
messages.add(res.message);
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(messages, true, true, false, 0);
|
|
|
|
processNewDifferenceParams(res.seq, res.pts, -1);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
});
|
|
|
|
} else {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.Chat chat = getChat(chat_id);
|
2014-07-27 00:28:33 +02:00
|
|
|
chat.title = title;
|
|
|
|
ArrayList<TLRPC.Chat> chatArrayList = new ArrayList<TLRPC.Chat>();
|
|
|
|
chatArrayList.add(chat);
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(null, chatArrayList, true, true);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_CHAT_NAME);
|
2014-07-27 00:28:33 +02:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2013-12-20 20:25:49 +01:00
|
|
|
public void changeChatAvatar(int chat_id, TLRPC.InputFile uploadedAvatar) {
|
2013-10-25 17:19:00 +02:00
|
|
|
TLRPC.TL_messages_editChatPhoto req2 = new TLRPC.TL_messages_editChatPhoto();
|
|
|
|
req2.chat_id = chat_id;
|
|
|
|
if (uploadedAvatar != null) {
|
|
|
|
req2.photo = new TLRPC.TL_inputChatUploadedPhoto();
|
|
|
|
req2.photo.file = uploadedAvatar;
|
|
|
|
req2.photo.crop = new TLRPC.TL_inputPhotoCropAuto();
|
|
|
|
} else {
|
|
|
|
req2.photo = new TLRPC.TL_inputChatPhotoEmpty();
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req2, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error != null) {
|
|
|
|
return;
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
final TLRPC.messages_StatedMessage res = (TLRPC.messages_StatedMessage) response;
|
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, true, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, false);
|
|
|
|
putChats(res.chats, false);
|
2013-10-25 17:19:00 +02:00
|
|
|
final ArrayList<MessageObject> messagesObj = new ArrayList<MessageObject>();
|
|
|
|
messagesObj.add(new MessageObject(res.message, users));
|
|
|
|
TLRPC.Chat chat = res.chats.get(0);
|
|
|
|
updateInterfaceWithMessages(-chat.id, messagesObj);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_CHAT_AVATAR);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
2014-02-04 19:36:55 +01:00
|
|
|
|
|
|
|
final ArrayList<TLRPC.Message> messages = new ArrayList<TLRPC.Message>();
|
|
|
|
messages.add(res.message);
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(messages, true, true, false, 0);
|
|
|
|
processNewDifferenceParams(res.seq, res.pts, -1);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void unregistedPush() {
|
2014-02-28 23:28:25 +01:00
|
|
|
if (UserConfig.registeredForPush && UserConfig.pushString.length() == 0) {
|
|
|
|
TLRPC.TL_account_unregisterDevice req = new TLRPC.TL_account_unregisterDevice();
|
|
|
|
req.token = UserConfig.pushString;
|
|
|
|
req.token_type = 2;
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2014-02-28 23:28:25 +01:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
2014-02-04 19:36:55 +01:00
|
|
|
|
2014-02-28 23:28:25 +01:00
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-06-13 12:42:21 +02:00
|
|
|
}
|
2014-02-28 23:28:25 +01:00
|
|
|
|
2014-06-13 12:42:21 +02:00
|
|
|
public void logOut() {
|
|
|
|
TLRPC.TL_auth_logOut req = new TLRPC.TL_auth_logOut();
|
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
2014-06-21 23:46:11 +02:00
|
|
|
ConnectionsManager.getInstance().cleanUp();
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void registerForPush(final String regid) {
|
2014-06-13 12:42:21 +02:00
|
|
|
if (regid == null || regid.length() == 0 || registeringForPush || UserConfig.getClientUserId() == 0) {
|
2013-10-25 17:19:00 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (UserConfig.registeredForPush && regid.equals(UserConfig.pushString)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
registeringForPush = true;
|
|
|
|
TLRPC.TL_account_registerDevice req = new TLRPC.TL_account_registerDevice();
|
2013-12-20 20:25:49 +01:00
|
|
|
req.token_type = 2;
|
|
|
|
req.token = regid;
|
|
|
|
req.app_sandbox = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
try {
|
2014-09-14 01:40:36 +02:00
|
|
|
req.lang_code = LocaleController.getLocaleString(Locale.getDefault());
|
2013-10-25 17:19:00 +02:00
|
|
|
req.device_model = Build.MANUFACTURER + Build.MODEL;
|
|
|
|
if (req.device_model == null) {
|
|
|
|
req.device_model = "Android unknown";
|
|
|
|
}
|
|
|
|
req.system_version = "SDK " + Build.VERSION.SDK_INT;
|
2013-11-04 13:31:01 +01:00
|
|
|
PackageInfo pInfo = ApplicationLoader.applicationContext.getPackageManager().getPackageInfo(ApplicationLoader.applicationContext.getPackageName(), 0);
|
2014-06-22 11:36:52 +02:00
|
|
|
req.app_version = pInfo.versionName + " (" + pInfo.versionCode + ")";
|
2013-10-25 17:19:00 +02:00
|
|
|
if (req.app_version == null) {
|
|
|
|
req.app_version = "App version unknown";
|
|
|
|
}
|
2013-12-20 20:25:49 +01:00
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
} catch (Exception e) {
|
2013-12-20 20:25:49 +01:00
|
|
|
FileLog.e("tmessages", e);
|
|
|
|
req.lang_code = "en";
|
|
|
|
req.device_model = "Android unknown";
|
|
|
|
req.system_version = "SDK " + Build.VERSION.SDK_INT;
|
|
|
|
req.app_version = "App version unknown";
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2013-12-26 17:46:13 +01:00
|
|
|
|
|
|
|
if (req.lang_code == null || req.lang_code.length() == 0) {
|
|
|
|
req.lang_code = "en";
|
|
|
|
}
|
|
|
|
if (req.device_model == null || req.device_model.length() == 0) {
|
|
|
|
req.device_model = "Android unknown";
|
|
|
|
}
|
|
|
|
if (req.app_version == null || req.app_version.length() == 0) {
|
|
|
|
req.app_version = "App version unknown";
|
|
|
|
}
|
|
|
|
if (req.system_version == null || req.system_version.length() == 0) {
|
|
|
|
req.system_version = "SDK Unknown";
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
if (req.app_version != null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2013-12-20 20:25:49 +01:00
|
|
|
FileLog.e("tmessages", "registered for push");
|
2013-10-25 17:19:00 +02:00
|
|
|
UserConfig.registeredForPush = true;
|
|
|
|
UserConfig.pushString = regid;
|
2013-11-04 13:31:01 +01:00
|
|
|
UserConfig.saveConfig(false);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
registeringForPush = false;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void loadCurrentState() {
|
|
|
|
if (updatingState) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
updatingState = true;
|
|
|
|
TLRPC.TL_updates_getState req = new TLRPC.TL_updates_getState();
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
updatingState = false;
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
TLRPC.TL_updates_state res = (TLRPC.TL_updates_state) response;
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastDateValue = res.date;
|
|
|
|
MessagesStorage.lastPtsValue = res.pts;
|
|
|
|
MessagesStorage.lastSeqValue = res.seq;
|
|
|
|
MessagesStorage.lastQtsValue = res.qts;
|
2014-07-23 01:27:00 +02:00
|
|
|
processUpdatesQueue(2);
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().saveDiffParams(MessagesStorage.lastSeqValue, MessagesStorage.lastPtsValue, MessagesStorage.lastDateValue, MessagesStorage.lastQtsValue);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2014-02-04 19:36:55 +01:00
|
|
|
if (error.code != 401) {
|
|
|
|
loadCurrentState();
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
private int getUpdateSeq(TLRPC.Updates updates) {
|
|
|
|
if (updates instanceof TLRPC.TL_updatesCombined) {
|
|
|
|
return updates.seq_start;
|
|
|
|
} else {
|
|
|
|
return updates.seq;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-23 01:27:00 +02:00
|
|
|
private void processUpdatesQueue(int state) {
|
2014-02-04 19:36:55 +01:00
|
|
|
if (!updatesQueue.isEmpty()) {
|
|
|
|
Collections.sort(updatesQueue, new Comparator<TLRPC.Updates>() {
|
|
|
|
@Override
|
|
|
|
public int compare(TLRPC.Updates updates, TLRPC.Updates updates2) {
|
|
|
|
int seq1 = getUpdateSeq(updates);
|
|
|
|
int seq2 = getUpdateSeq(updates2);
|
|
|
|
if (seq1 == seq2) {
|
|
|
|
return 0;
|
|
|
|
} else if (seq1 > seq2) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
boolean anyProceed = false;
|
2014-07-23 01:27:00 +02:00
|
|
|
if (state == 2) {
|
|
|
|
TLRPC.Updates updates = updatesQueue.get(0);
|
|
|
|
MessagesStorage.lastSeqValue = getUpdateSeq(updates);
|
|
|
|
}
|
2014-02-04 19:36:55 +01:00
|
|
|
for (int a = 0; a < updatesQueue.size(); a++) {
|
|
|
|
TLRPC.Updates updates = updatesQueue.get(a);
|
|
|
|
int seq = getUpdateSeq(updates);
|
|
|
|
if (MessagesStorage.lastSeqValue + 1 == seq || MessagesStorage.lastSeqValue == seq) {
|
|
|
|
processUpdates(updates, true);
|
|
|
|
anyProceed = true;
|
|
|
|
updatesQueue.remove(a);
|
|
|
|
a--;
|
|
|
|
} else if (MessagesStorage.lastSeqValue < seq) {
|
|
|
|
if (updatesStartWaitTime != 0 && (anyProceed || updatesStartWaitTime + 1500 > System.currentTimeMillis())) {
|
|
|
|
FileLog.e("tmessages", "HOLE IN UPDATES QUEUE - will wait more time");
|
|
|
|
if (anyProceed) {
|
|
|
|
updatesStartWaitTime = System.currentTimeMillis();
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
FileLog.e("tmessages", "HOLE IN UPDATES QUEUE - getDifference");
|
|
|
|
updatesStartWaitTime = 0;
|
|
|
|
updatesQueue.clear();
|
|
|
|
getDifference();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
updatesQueue.remove(a);
|
|
|
|
a--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
updatesQueue.clear();
|
|
|
|
FileLog.e("tmessages", "UPDATES QUEUE PROCEED - OK");
|
|
|
|
updatesStartWaitTime = 0;
|
2014-07-23 01:27:00 +02:00
|
|
|
if (state == 1) {
|
2014-07-03 00:39:05 +02:00
|
|
|
final int stateCopy = ConnectionsManager.getInstance().getConnectionState();
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-02-04 19:36:55 +01:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.didUpdatedConnectionState, stateCopy);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
} else {
|
2014-07-23 01:27:00 +02:00
|
|
|
if (state == 1) {
|
2014-07-03 00:39:05 +02:00
|
|
|
final int stateCopy = ConnectionsManager.getInstance().getConnectionState();
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-02-04 19:36:55 +01:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.didUpdatedConnectionState, stateCopy);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
updatesStartWaitTime = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
public void getDifference() {
|
|
|
|
registerForPush(UserConfig.pushString);
|
2013-11-04 13:31:01 +01:00
|
|
|
if (MessagesStorage.lastDateValue == 0) {
|
2013-10-25 17:19:00 +02:00
|
|
|
loadCurrentState();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (gettingDifference) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!firstGettingTask) {
|
|
|
|
getNewDeleteTask(null);
|
|
|
|
firstGettingTask = true;
|
|
|
|
}
|
|
|
|
gettingDifference = true;
|
|
|
|
TLRPC.TL_updates_getDifference req = new TLRPC.TL_updates_getDifference();
|
2013-11-04 13:31:01 +01:00
|
|
|
req.pts = MessagesStorage.lastPtsValue;
|
|
|
|
req.date = MessagesStorage.lastDateValue;
|
|
|
|
req.qts = MessagesStorage.lastQtsValue;
|
2014-02-04 19:36:55 +01:00
|
|
|
FileLog.e("tmessages", "start getDifference with date = " + MessagesStorage.lastDateValue + " pts = " + MessagesStorage.lastPtsValue + " seq = " + MessagesStorage.lastSeqValue);
|
2014-07-03 00:39:05 +02:00
|
|
|
if (ConnectionsManager.getInstance().getConnectionState() == 0) {
|
|
|
|
ConnectionsManager.getInstance().setConnectionState(3);
|
|
|
|
final int stateCopy = ConnectionsManager.getInstance().getConnectionState();
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.didUpdatedConnectionState, stateCopy);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
2013-12-20 20:25:49 +01:00
|
|
|
gettingDifferenceAgain = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
final TLRPC.updates_Difference res = (TLRPC.updates_Difference) response;
|
2013-12-20 20:25:49 +01:00
|
|
|
gettingDifferenceAgain = res instanceof TLRPC.TL_updates_differenceSlice;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
final HashMap<Integer, TLRPC.User> usersDict = new HashMap<Integer, TLRPC.User>();
|
|
|
|
for (TLRPC.User user : res.users) {
|
|
|
|
usersDict.put(user.id, user);
|
|
|
|
}
|
|
|
|
|
|
|
|
final ArrayList<TLRPC.TL_updateMessageID> msgUpdates = new ArrayList<TLRPC.TL_updateMessageID>();
|
|
|
|
if (!res.other_updates.isEmpty()) {
|
|
|
|
for (int a = 0; a < res.other_updates.size(); a++) {
|
|
|
|
TLRPC.Update upd = res.other_updates.get(a);
|
|
|
|
if (upd instanceof TLRPC.TL_updateMessageID) {
|
2014-03-22 23:31:55 +01:00
|
|
|
msgUpdates.add((TLRPC.TL_updateMessageID) upd);
|
2013-10-25 17:19:00 +02:00
|
|
|
res.other_updates.remove(a);
|
|
|
|
a--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-02-11 15:32:09 +01:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(res.users, false);
|
|
|
|
putChats(res.chats, false);
|
2014-02-11 15:32:09 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (!msgUpdates.isEmpty()) {
|
|
|
|
final HashMap<Integer, Integer> corrected = new HashMap<Integer, Integer>();
|
|
|
|
for (TLRPC.TL_updateMessageID update : msgUpdates) {
|
2014-03-22 23:31:55 +01:00
|
|
|
Integer oldId = MessagesStorage.getInstance().updateMessageStateAndId(update.random_id, null, update.id, 0, false);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (oldId != null) {
|
|
|
|
corrected.put(oldId, update.id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!corrected.isEmpty()) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
for (HashMap.Entry<Integer, Integer> entry : corrected.entrySet()) {
|
|
|
|
Integer oldId = entry.getKey();
|
2014-09-28 15:37:26 +02:00
|
|
|
SendMessagesHelper.getInstance().processSentMessage(oldId);
|
2013-10-25 17:19:00 +02:00
|
|
|
Integer newId = entry.getValue();
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.messageReceivedByServer, oldId, newId, null);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (!res.new_messages.isEmpty() || !res.new_encrypted_messages.isEmpty()) {
|
|
|
|
final HashMap<Long, ArrayList<MessageObject>> messages = new HashMap<Long, ArrayList<MessageObject>>();
|
|
|
|
for (TLRPC.EncryptedMessage encryptedMessage : res.new_encrypted_messages) {
|
2014-10-28 22:27:44 +01:00
|
|
|
ArrayList<TLRPC.Message> decryptedMessages = decryptMessage(encryptedMessage);
|
|
|
|
if (decryptedMessages != null && !decryptedMessages.isEmpty()) {
|
|
|
|
for (TLRPC.Message message : decryptedMessages) {
|
|
|
|
res.new_messages.add(message);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-10 02:15:58 +02:00
|
|
|
final ArrayList<MessageObject> pushMessages = new ArrayList<MessageObject>();
|
2013-10-25 17:19:00 +02:00
|
|
|
for (TLRPC.Message message : res.new_messages) {
|
2014-07-27 00:28:33 +02:00
|
|
|
MessageObject obj = new MessageObject(message, usersDict, 2);
|
2013-12-20 20:25:49 +01:00
|
|
|
|
|
|
|
long dialog_id = obj.messageOwner.dialog_id;
|
|
|
|
if (dialog_id == 0) {
|
|
|
|
if (obj.messageOwner.to_id.chat_id != 0) {
|
|
|
|
dialog_id = -obj.messageOwner.to_id.chat_id;
|
|
|
|
} else {
|
|
|
|
dialog_id = obj.messageOwner.to_id.user_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-10 02:15:58 +02:00
|
|
|
if (!obj.isFromMe() && obj.isUnread()) {
|
|
|
|
pushMessages.add(obj);
|
2013-12-20 20:25:49 +01:00
|
|
|
}
|
2014-07-10 02:15:58 +02:00
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
long uid;
|
|
|
|
if (message.dialog_id != 0) {
|
|
|
|
uid = message.dialog_id;
|
|
|
|
} else {
|
|
|
|
if (message.to_id.chat_id != 0) {
|
|
|
|
uid = -message.to_id.chat_id;
|
|
|
|
} else {
|
2014-06-13 12:42:21 +02:00
|
|
|
if (message.to_id.user_id == UserConfig.getClientUserId()) {
|
2013-10-25 17:19:00 +02:00
|
|
|
message.to_id.user_id = message.from_id;
|
|
|
|
}
|
|
|
|
uid = message.to_id.user_id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ArrayList<MessageObject> arr = messages.get(uid);
|
|
|
|
if (arr == null) {
|
|
|
|
arr = new ArrayList<MessageObject>();
|
|
|
|
messages.put(uid, arr);
|
|
|
|
}
|
|
|
|
arr.add(obj);
|
|
|
|
}
|
|
|
|
|
2014-03-22 23:31:55 +01:00
|
|
|
processPendingEncMessages();
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
for (HashMap.Entry<Long, ArrayList<MessageObject>> pair : messages.entrySet()) {
|
|
|
|
Long key = pair.getKey();
|
|
|
|
ArrayList<MessageObject> value = pair.getValue();
|
|
|
|
updateInterfaceWithMessages(key, value);
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
2014-02-04 19:36:55 +01:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-07-30 09:49:39 +02:00
|
|
|
if (!pushMessages.isEmpty()) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-30 09:49:39 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
NotificationsController.getInstance().processNewMessages(pushMessages, !(res instanceof TLRPC.TL_updates_differenceSlice));
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().startTransaction(false);
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(res.new_messages, false, false, false, MediaController.getInstance().getAutodownloadMask());
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putUsersAndChats(res.users, res.chats, false, false);
|
|
|
|
MessagesStorage.getInstance().commitTransaction(false);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (res != null && !res.other_updates.isEmpty()) {
|
2013-12-20 20:25:49 +01:00
|
|
|
processUpdateArray(res.other_updates, res.users, res.chats);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
gettingDifference = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (res instanceof TLRPC.TL_updates_difference) {
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastSeqValue = res.state.seq;
|
|
|
|
MessagesStorage.lastDateValue = res.state.date;
|
|
|
|
MessagesStorage.lastPtsValue = res.state.pts;
|
|
|
|
MessagesStorage.lastQtsValue = res.state.qts;
|
2014-07-03 00:39:05 +02:00
|
|
|
ConnectionsManager.getInstance().setConnectionState(0);
|
2014-07-23 01:27:00 +02:00
|
|
|
processUpdatesQueue(1);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (res instanceof TLRPC.TL_updates_differenceSlice) {
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastDateValue = res.intermediate_state.date;
|
|
|
|
MessagesStorage.lastPtsValue = res.intermediate_state.pts;
|
|
|
|
MessagesStorage.lastQtsValue = res.intermediate_state.qts;
|
2013-12-20 20:25:49 +01:00
|
|
|
gettingDifferenceAgain = true;
|
2013-10-25 17:19:00 +02:00
|
|
|
getDifference();
|
|
|
|
} else if (res instanceof TLRPC.TL_updates_differenceEmpty) {
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastSeqValue = res.seq;
|
|
|
|
MessagesStorage.lastDateValue = res.date;
|
2014-07-03 00:39:05 +02:00
|
|
|
ConnectionsManager.getInstance().setConnectionState(0);
|
2014-07-23 01:27:00 +02:00
|
|
|
processUpdatesQueue(1);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().saveDiffParams(MessagesStorage.lastSeqValue, MessagesStorage.lastPtsValue, MessagesStorage.lastDateValue, MessagesStorage.lastQtsValue);
|
2014-02-04 19:36:55 +01:00
|
|
|
FileLog.e("tmessages", "received difference with date = " + MessagesStorage.lastDateValue + " pts = " + MessagesStorage.lastPtsValue + " seq = " + MessagesStorage.lastSeqValue);
|
|
|
|
FileLog.e("tmessages", "messages = " + res.new_messages.size() + " users = " + res.users.size() + " chats = " + res.chats.size() + " other updates = " + res.other_updates.size());
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
2014-02-04 19:36:55 +01:00
|
|
|
gettingDifference = false;
|
2014-07-03 00:39:05 +02:00
|
|
|
ConnectionsManager.getInstance().setConnectionState(0);
|
|
|
|
final int stateCopy = ConnectionsManager.getInstance().getConnectionState();
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-06-07 01:35:21 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.didUpdatedConnectionState, stateCopy);
|
2014-06-07 01:35:21 +02:00
|
|
|
}
|
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
public void processUpdates(final TLRPC.Updates updates, boolean fromQueue) {
|
2013-10-25 17:19:00 +02:00
|
|
|
boolean needGetDiff = false;
|
|
|
|
boolean needReceivedQueue = false;
|
2014-02-04 19:36:55 +01:00
|
|
|
boolean addedToQueue = false;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (updates instanceof TLRPC.TL_updateShort) {
|
|
|
|
ArrayList<TLRPC.Update> arr = new ArrayList<TLRPC.Update>();
|
|
|
|
arr.add(updates.update);
|
|
|
|
processUpdateArray(arr, null, null);
|
|
|
|
} else if (updates instanceof TLRPC.TL_updateShortChatMessage) {
|
2014-08-22 16:24:33 +02:00
|
|
|
boolean missingData = getChat(updates.chat_id) == null || getUser(updates.from_id) == null;
|
2014-04-03 23:18:54 +02:00
|
|
|
if (missingData) {
|
|
|
|
needGetDiff = true;
|
|
|
|
} else {
|
2014-04-04 22:18:46 +02:00
|
|
|
if (MessagesStorage.lastSeqValue + 1 == updates.seq) {
|
2014-04-03 23:18:54 +02:00
|
|
|
TLRPC.TL_message message = new TLRPC.TL_message();
|
|
|
|
message.from_id = updates.from_id;
|
|
|
|
message.id = updates.id;
|
|
|
|
message.to_id = new TLRPC.TL_peerChat();
|
|
|
|
message.to_id.chat_id = updates.chat_id;
|
|
|
|
message.message = updates.message;
|
|
|
|
message.date = updates.date;
|
2014-10-07 22:14:27 +02:00
|
|
|
message.flags = TLRPC.MESSAGE_FLAG_UNREAD;
|
2014-04-03 23:18:54 +02:00
|
|
|
message.media = new TLRPC.TL_messageMediaEmpty();
|
|
|
|
MessagesStorage.lastSeqValue = updates.seq;
|
|
|
|
MessagesStorage.lastPtsValue = updates.pts;
|
|
|
|
final MessageObject obj = new MessageObject(message, null);
|
|
|
|
final ArrayList<MessageObject> objArr = new ArrayList<MessageObject>();
|
|
|
|
objArr.add(obj);
|
|
|
|
ArrayList<TLRPC.Message> arr = new ArrayList<TLRPC.Message>();
|
|
|
|
arr.add(message);
|
|
|
|
final boolean printUpdate = updatePrintingUsersWithNewMessages(-updates.chat_id, objArr);
|
|
|
|
if (printUpdate) {
|
|
|
|
updatePrintingStrings();
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-04-03 23:18:54 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (printUpdate) {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_USER_PRINT);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-30 09:49:39 +02:00
|
|
|
|
2014-04-03 23:18:54 +02:00
|
|
|
updateInterfaceWithMessages(-updates.chat_id, objArr);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-04-03 23:18:54 +02:00
|
|
|
});
|
2014-07-30 09:49:39 +02:00
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-30 09:49:39 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (!obj.isFromMe() && obj.isUnread()) {
|
|
|
|
NotificationsController.getInstance().processNewMessages(objArr, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(arr, false, true, false, 0);
|
2014-04-03 23:18:54 +02:00
|
|
|
} else if (MessagesStorage.lastSeqValue != updates.seq) {
|
|
|
|
FileLog.e("tmessages", "need get diff TL_updateShortChatMessage, seq: " + MessagesStorage.lastSeqValue + " " + updates.seq);
|
|
|
|
if (gettingDifference || updatesStartWaitTime == 0 || updatesStartWaitTime != 0 && updatesStartWaitTime + 1500 > System.currentTimeMillis()) {
|
|
|
|
if (updatesStartWaitTime == 0) {
|
|
|
|
updatesStartWaitTime = System.currentTimeMillis();
|
|
|
|
}
|
|
|
|
FileLog.e("tmessages", "add TL_updateShortChatMessage to queue");
|
|
|
|
updatesQueue.add(updates);
|
|
|
|
addedToQueue = true;
|
|
|
|
} else {
|
|
|
|
needGetDiff = true;
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else if (updates instanceof TLRPC.TL_updateShortMessage) {
|
2014-08-22 16:24:33 +02:00
|
|
|
boolean missingData = getUser(updates.from_id) == null;
|
2014-04-03 23:18:54 +02:00
|
|
|
if (missingData) {
|
|
|
|
needGetDiff = true;
|
|
|
|
} else {
|
2014-04-04 22:18:46 +02:00
|
|
|
if (MessagesStorage.lastSeqValue + 1 == updates.seq) {
|
2014-04-03 23:18:54 +02:00
|
|
|
TLRPC.TL_message message = new TLRPC.TL_message();
|
|
|
|
message.from_id = updates.from_id;
|
|
|
|
message.id = updates.id;
|
|
|
|
message.to_id = new TLRPC.TL_peerUser();
|
|
|
|
message.to_id.user_id = updates.from_id;
|
|
|
|
message.message = updates.message;
|
|
|
|
message.date = updates.date;
|
2014-10-07 22:14:27 +02:00
|
|
|
message.flags = TLRPC.MESSAGE_FLAG_UNREAD;
|
2014-04-03 23:18:54 +02:00
|
|
|
message.media = new TLRPC.TL_messageMediaEmpty();
|
|
|
|
MessagesStorage.lastSeqValue = updates.seq;
|
|
|
|
MessagesStorage.lastPtsValue = updates.pts;
|
|
|
|
MessagesStorage.lastDateValue = updates.date;
|
|
|
|
final MessageObject obj = new MessageObject(message, null);
|
|
|
|
final ArrayList<MessageObject> objArr = new ArrayList<MessageObject>();
|
|
|
|
objArr.add(obj);
|
|
|
|
ArrayList<TLRPC.Message> arr = new ArrayList<TLRPC.Message>();
|
|
|
|
arr.add(message);
|
|
|
|
final boolean printUpdate = updatePrintingUsersWithNewMessages(updates.from_id, objArr);
|
|
|
|
if (printUpdate) {
|
|
|
|
updatePrintingStrings();
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-04-03 23:18:54 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (printUpdate) {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, UPDATE_MASK_USER_PRINT);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-04-03 23:18:54 +02:00
|
|
|
updateInterfaceWithMessages(updates.from_id, objArr);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-04-03 23:18:54 +02:00
|
|
|
});
|
2014-07-30 09:49:39 +02:00
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-30 09:49:39 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (!obj.isFromMe() && obj.isUnread()) {
|
|
|
|
NotificationsController.getInstance().processNewMessages(objArr, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(arr, false, true, false, 0);
|
2014-04-03 23:18:54 +02:00
|
|
|
} else if (MessagesStorage.lastSeqValue != updates.seq) {
|
|
|
|
FileLog.e("tmessages", "need get diff TL_updateShortMessage, seq: " + MessagesStorage.lastSeqValue + " " + updates.seq);
|
|
|
|
if (gettingDifference || updatesStartWaitTime == 0 || updatesStartWaitTime != 0 && updatesStartWaitTime + 1500 > System.currentTimeMillis()) {
|
|
|
|
if (updatesStartWaitTime == 0) {
|
|
|
|
updatesStartWaitTime = System.currentTimeMillis();
|
|
|
|
}
|
|
|
|
FileLog.e("tmessages", "add TL_updateShortMessage to queue");
|
|
|
|
updatesQueue.add(updates);
|
|
|
|
addedToQueue = true;
|
|
|
|
} else {
|
|
|
|
needGetDiff = true;
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else if (updates instanceof TLRPC.TL_updatesCombined) {
|
2014-04-04 22:18:46 +02:00
|
|
|
if (MessagesStorage.lastSeqValue + 1 == updates.seq_start || MessagesStorage.lastSeqValue == updates.seq_start) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putUsersAndChats(updates.users, updates.chats, true, true);
|
2013-11-04 13:31:01 +01:00
|
|
|
int lastPtsValue = MessagesStorage.lastPtsValue;
|
|
|
|
int lastQtsValue = MessagesStorage.lastQtsValue;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (!processUpdateArray(updates.updates, updates.users, updates.chats)) {
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastPtsValue = lastPtsValue;
|
|
|
|
MessagesStorage.lastQtsValue = lastQtsValue;
|
2013-12-20 20:25:49 +01:00
|
|
|
FileLog.e("tmessages", "need get diff inner TL_updatesCombined, seq: " + MessagesStorage.lastSeqValue + " " + updates.seq);
|
2013-10-25 17:19:00 +02:00
|
|
|
needGetDiff = true;
|
|
|
|
} else {
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastDateValue = updates.date;
|
|
|
|
MessagesStorage.lastSeqValue = updates.seq;
|
|
|
|
if (MessagesStorage.lastQtsValue != lastQtsValue) {
|
2013-10-25 17:19:00 +02:00
|
|
|
needReceivedQueue = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2013-12-20 20:25:49 +01:00
|
|
|
FileLog.e("tmessages", "need get diff TL_updatesCombined, seq: " + MessagesStorage.lastSeqValue + " " + updates.seq_start);
|
2014-02-04 19:36:55 +01:00
|
|
|
if (gettingDifference || updatesStartWaitTime == 0 || updatesStartWaitTime != 0 && updatesStartWaitTime + 1500 > System.currentTimeMillis()) {
|
|
|
|
if (updatesStartWaitTime == 0) {
|
|
|
|
updatesStartWaitTime = System.currentTimeMillis();
|
|
|
|
}
|
|
|
|
FileLog.e("tmessages", "add TL_updatesCombined to queue");
|
|
|
|
updatesQueue.add(updates);
|
|
|
|
addedToQueue = true;
|
|
|
|
} else {
|
|
|
|
needGetDiff = true;
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else if (updates instanceof TLRPC.TL_updates) {
|
2014-04-04 22:18:46 +02:00
|
|
|
if (MessagesStorage.lastSeqValue + 1 == updates.seq || updates.seq == 0 || updates.seq == MessagesStorage.lastSeqValue) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putUsersAndChats(updates.users, updates.chats, true, true);
|
2013-11-04 13:31:01 +01:00
|
|
|
int lastPtsValue = MessagesStorage.lastPtsValue;
|
|
|
|
int lastQtsValue = MessagesStorage.lastQtsValue;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (!processUpdateArray(updates.updates, updates.users, updates.chats)) {
|
|
|
|
needGetDiff = true;
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastPtsValue = lastPtsValue;
|
|
|
|
MessagesStorage.lastQtsValue = lastQtsValue;
|
2013-12-20 20:25:49 +01:00
|
|
|
FileLog.e("tmessages", "need get diff inner TL_updates, seq: " + MessagesStorage.lastSeqValue + " " + updates.seq);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastDateValue = updates.date;
|
2014-02-04 19:36:55 +01:00
|
|
|
if (updates.seq != 0) {
|
|
|
|
MessagesStorage.lastSeqValue = updates.seq;
|
|
|
|
}
|
2013-11-04 13:31:01 +01:00
|
|
|
if (MessagesStorage.lastQtsValue != lastQtsValue) {
|
2013-10-25 17:19:00 +02:00
|
|
|
needReceivedQueue = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2013-12-20 20:25:49 +01:00
|
|
|
FileLog.e("tmessages", "need get diff TL_updates, seq: " + MessagesStorage.lastSeqValue + " " + updates.seq);
|
2014-02-04 19:36:55 +01:00
|
|
|
if (gettingDifference || updatesStartWaitTime == 0 || updatesStartWaitTime != 0 && updatesStartWaitTime + 1500 > System.currentTimeMillis()) {
|
|
|
|
if (updatesStartWaitTime == 0) {
|
|
|
|
updatesStartWaitTime = System.currentTimeMillis();
|
|
|
|
}
|
|
|
|
FileLog.e("tmessages", "add TL_updates to queue");
|
|
|
|
updatesQueue.add(updates);
|
|
|
|
addedToQueue = true;
|
|
|
|
} else {
|
|
|
|
needGetDiff = true;
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else if (updates instanceof TLRPC.TL_updatesTooLong) {
|
2013-12-20 20:25:49 +01:00
|
|
|
FileLog.e("tmessages", "need get diff TL_updatesTooLong");
|
2013-10-25 17:19:00 +02:00
|
|
|
needGetDiff = true;
|
2014-02-04 19:36:55 +01:00
|
|
|
} else if (updates instanceof UserActionUpdates) {
|
|
|
|
MessagesStorage.lastSeqValue = updates.seq;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-02-04 19:36:55 +01:00
|
|
|
if (needGetDiff && !fromQueue) {
|
2013-10-25 17:19:00 +02:00
|
|
|
getDifference();
|
2014-02-04 19:36:55 +01:00
|
|
|
} else if (!fromQueue && !updatesQueue.isEmpty()) {
|
2014-07-23 01:27:00 +02:00
|
|
|
processUpdatesQueue(0);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
if (needReceivedQueue) {
|
|
|
|
TLRPC.TL_messages_receivedQueue req = new TLRPC.TL_messages_receivedQueue();
|
2013-11-04 13:31:01 +01:00
|
|
|
req.max_qts = MessagesStorage.lastQtsValue;
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().saveDiffParams(MessagesStorage.lastSeqValue, MessagesStorage.lastPtsValue, MessagesStorage.lastDateValue, MessagesStorage.lastQtsValue);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public boolean processUpdateArray(ArrayList<TLRPC.Update> updates, final ArrayList<TLRPC.User> usersArr, final ArrayList<TLRPC.Chat> chatsArr) {
|
|
|
|
if (updates.isEmpty()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
long currentTime = System.currentTimeMillis();
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
final HashMap<Long, ArrayList<MessageObject>> messages = new HashMap<Long, ArrayList<MessageObject>>();
|
2014-07-10 02:15:58 +02:00
|
|
|
final ArrayList<MessageObject> pushMessages = new ArrayList<MessageObject>();
|
2014-02-04 19:36:55 +01:00
|
|
|
final ArrayList<TLRPC.Message> messagesArr = new ArrayList<TLRPC.Message>();
|
|
|
|
final ArrayList<Integer> markAsReadMessages = new ArrayList<Integer>();
|
|
|
|
final HashMap<Integer, Integer> markAsReadEncrypted = new HashMap<Integer, Integer>();
|
|
|
|
final ArrayList<Integer> deletedMessages = new ArrayList<Integer>();
|
2014-05-20 22:22:44 +02:00
|
|
|
boolean printChanged = false;
|
2014-02-04 19:36:55 +01:00
|
|
|
final ArrayList<TLRPC.ChatParticipants> chatInfoToUpdate = new ArrayList<TLRPC.ChatParticipants>();
|
|
|
|
final ArrayList<TLRPC.Update> updatesOnMainThread = new ArrayList<TLRPC.Update>();
|
2013-10-25 17:19:00 +02:00
|
|
|
final ArrayList<TLRPC.TL_updateEncryptedMessagesRead> tasks = new ArrayList<TLRPC.TL_updateEncryptedMessagesRead>();
|
2014-02-04 19:36:55 +01:00
|
|
|
final ArrayList<Integer> contactsIds = new ArrayList<Integer>();
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
boolean checkForUsers = true;
|
|
|
|
ConcurrentHashMap<Integer, TLRPC.User> usersDict;
|
|
|
|
ConcurrentHashMap<Integer, TLRPC.Chat> chatsDict;
|
|
|
|
if (usersArr != null) {
|
|
|
|
usersDict = new ConcurrentHashMap<Integer, TLRPC.User>();
|
|
|
|
for (TLRPC.User user : usersArr) {
|
|
|
|
usersDict.put(user.id, user);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
checkForUsers = false;
|
|
|
|
usersDict = users;
|
|
|
|
}
|
|
|
|
if (chatsArr != null) {
|
|
|
|
chatsDict = new ConcurrentHashMap<Integer, TLRPC.Chat>();
|
|
|
|
for (TLRPC.Chat chat : chatsArr) {
|
|
|
|
chatsDict.put(chat.id, chat);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
checkForUsers = false;
|
|
|
|
chatsDict = chats;
|
|
|
|
}
|
|
|
|
|
2014-02-11 15:32:09 +01:00
|
|
|
if (usersArr != null || chatsArr != null) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-02-11 15:32:09 +01:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putUsers(usersArr, false);
|
|
|
|
putChats(chatsArr, false);
|
2014-02-11 15:32:09 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
int interfaceUpdateMask = 0;
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
for (TLRPC.Update update : updates) {
|
|
|
|
if (update instanceof TLRPC.TL_updateNewMessage) {
|
|
|
|
TLRPC.TL_updateNewMessage upd = (TLRPC.TL_updateNewMessage)update;
|
|
|
|
if (checkForUsers) {
|
2014-08-22 16:24:33 +02:00
|
|
|
if (usersDict.get(upd.message.from_id) == null && getUser(upd.message.from_id) == null || upd.message.to_id.chat_id != 0 && chatsDict.get(upd.message.to_id.chat_id) == null && getChat(upd.message.to_id.chat_id) == null) {
|
2013-10-25 17:19:00 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
messagesArr.add(upd.message);
|
2014-07-27 00:28:33 +02:00
|
|
|
MessageObject obj = new MessageObject(upd.message, usersDict, 2);
|
2013-10-25 17:19:00 +02:00
|
|
|
if (obj.type == 11) {
|
2014-02-04 19:36:55 +01:00
|
|
|
interfaceUpdateMask |= UPDATE_MASK_CHAT_AVATAR;
|
|
|
|
} else if (obj.type == 10) {
|
|
|
|
interfaceUpdateMask |= UPDATE_MASK_CHAT_NAME;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
long uid;
|
|
|
|
if (upd.message.to_id.chat_id != 0) {
|
|
|
|
uid = -upd.message.to_id.chat_id;
|
|
|
|
} else {
|
2014-06-13 12:42:21 +02:00
|
|
|
if (upd.message.to_id.user_id == UserConfig.getClientUserId()) {
|
2013-10-25 17:19:00 +02:00
|
|
|
upd.message.to_id.user_id = upd.message.from_id;
|
|
|
|
}
|
|
|
|
uid = upd.message.to_id.user_id;
|
|
|
|
}
|
|
|
|
ArrayList<MessageObject> arr = messages.get(uid);
|
|
|
|
if (arr == null) {
|
|
|
|
arr = new ArrayList<MessageObject>();
|
|
|
|
messages.put(uid, arr);
|
|
|
|
}
|
|
|
|
arr.add(obj);
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastPtsValue = update.pts;
|
2014-07-10 02:15:58 +02:00
|
|
|
if (!obj.isFromMe() && obj.isUnread()) {
|
|
|
|
pushMessages.add(obj);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else if (update instanceof TLRPC.TL_updateReadMessages) {
|
|
|
|
markAsReadMessages.addAll(update.messages);
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastPtsValue = update.pts;
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateDeleteMessages) {
|
|
|
|
deletedMessages.addAll(update.messages);
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastPtsValue = update.pts;
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateRestoreMessages) {
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastPtsValue = update.pts;
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateUserTyping || update instanceof TLRPC.TL_updateChatUserTyping) {
|
2014-10-07 22:14:27 +02:00
|
|
|
if (update.action instanceof TLRPC.TL_sendMessageTypingAction && update.user_id != UserConfig.getClientUserId()) {
|
2013-10-25 17:19:00 +02:00
|
|
|
long uid = -update.chat_id;
|
|
|
|
if (uid == 0) {
|
|
|
|
uid = update.user_id;
|
|
|
|
}
|
|
|
|
ArrayList<PrintingUser> arr = printingUsers.get(uid);
|
|
|
|
if (arr == null) {
|
|
|
|
arr = new ArrayList<PrintingUser>();
|
|
|
|
printingUsers.put(uid, arr);
|
|
|
|
}
|
|
|
|
boolean exist = false;
|
|
|
|
for (PrintingUser u : arr) {
|
|
|
|
if (u.userId == update.user_id) {
|
|
|
|
exist = true;
|
|
|
|
u.lastTime = currentTime;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!exist) {
|
|
|
|
PrintingUser newUser = new PrintingUser();
|
|
|
|
newUser.userId = update.user_id;
|
|
|
|
newUser.lastTime = currentTime;
|
|
|
|
arr.add(newUser);
|
2014-05-20 22:22:44 +02:00
|
|
|
printChanged = true;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (update instanceof TLRPC.TL_updateChatParticipants) {
|
2014-02-04 19:36:55 +01:00
|
|
|
interfaceUpdateMask |= UPDATE_MASK_CHAT_MEMBERS;
|
2013-10-25 17:19:00 +02:00
|
|
|
chatInfoToUpdate.add(update.participants);
|
|
|
|
} else if (update instanceof TLRPC.TL_updateUserStatus) {
|
2014-02-04 19:36:55 +01:00
|
|
|
interfaceUpdateMask |= UPDATE_MASK_STATUS;
|
2013-10-25 17:19:00 +02:00
|
|
|
updatesOnMainThread.add(update);
|
|
|
|
} else if (update instanceof TLRPC.TL_updateUserName) {
|
2014-02-04 19:36:55 +01:00
|
|
|
interfaceUpdateMask |= UPDATE_MASK_NAME;
|
2013-10-25 17:19:00 +02:00
|
|
|
updatesOnMainThread.add(update);
|
|
|
|
} else if (update instanceof TLRPC.TL_updateUserPhoto) {
|
2014-02-04 19:36:55 +01:00
|
|
|
interfaceUpdateMask |= UPDATE_MASK_AVATAR;
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().clearUserPhotos(update.user_id);
|
2013-10-25 17:19:00 +02:00
|
|
|
updatesOnMainThread.add(update);
|
|
|
|
} else if (update instanceof TLRPC.TL_updateContactRegistered) {
|
2014-02-04 19:36:55 +01:00
|
|
|
if (enableJoined && usersDict.containsKey(update.user_id)) {
|
2013-12-20 20:25:49 +01:00
|
|
|
TLRPC.TL_messageService newMessage = new TLRPC.TL_messageService();
|
|
|
|
newMessage.action = new TLRPC.TL_messageActionUserJoined();
|
|
|
|
newMessage.local_id = newMessage.id = UserConfig.getNewMessageId();
|
|
|
|
UserConfig.saveConfig(false);
|
2014-10-07 22:14:27 +02:00
|
|
|
newMessage.flags = TLRPC.MESSAGE_FLAG_UNREAD;
|
2013-12-20 20:25:49 +01:00
|
|
|
newMessage.date = update.date;
|
|
|
|
newMessage.from_id = update.user_id;
|
|
|
|
newMessage.to_id = new TLRPC.TL_peerUser();
|
2014-06-13 12:42:21 +02:00
|
|
|
newMessage.to_id.user_id = UserConfig.getClientUserId();
|
2013-12-20 20:25:49 +01:00
|
|
|
newMessage.dialog_id = update.user_id;
|
|
|
|
|
|
|
|
messagesArr.add(newMessage);
|
|
|
|
MessageObject obj = new MessageObject(newMessage, usersDict);
|
|
|
|
ArrayList<MessageObject> arr = messages.get(newMessage.dialog_id);
|
|
|
|
if (arr == null) {
|
|
|
|
arr = new ArrayList<MessageObject>();
|
|
|
|
messages.put(newMessage.dialog_id, arr);
|
|
|
|
}
|
|
|
|
arr.add(obj);
|
2014-07-10 02:15:58 +02:00
|
|
|
pushMessages.add(obj);
|
2013-12-20 20:25:49 +01:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateContactLink) {
|
2014-02-04 19:36:55 +01:00
|
|
|
if (update.my_link instanceof TLRPC.TL_contacts_myLinkContact || update.my_link instanceof TLRPC.TL_contacts_myLinkRequested && update.my_link.contact) {
|
|
|
|
int idx = contactsIds.indexOf(-update.user_id);
|
|
|
|
if (idx != -1) {
|
|
|
|
contactsIds.remove(idx);
|
|
|
|
}
|
|
|
|
if (!contactsIds.contains(update.user_id)) {
|
|
|
|
contactsIds.add(update.user_id);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
int idx = contactsIds.indexOf(update.user_id);
|
|
|
|
if (idx != -1) {
|
|
|
|
contactsIds.remove(idx);
|
|
|
|
}
|
|
|
|
if (!contactsIds.contains(update.user_id)) {
|
|
|
|
contactsIds.add(-update.user_id);
|
|
|
|
}
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateActivation) {
|
2014-02-04 19:36:55 +01:00
|
|
|
//DEPRECATED
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateNewAuthorization) {
|
2013-12-20 20:25:49 +01:00
|
|
|
TLRPC.TL_messageService newMessage = new TLRPC.TL_messageService();
|
|
|
|
newMessage.action = new TLRPC.TL_messageActionLoginUnknownLocation();
|
|
|
|
newMessage.action.title = update.device;
|
|
|
|
newMessage.action.address = update.location;
|
|
|
|
newMessage.local_id = newMessage.id = UserConfig.getNewMessageId();
|
|
|
|
UserConfig.saveConfig(false);
|
2014-10-07 22:14:27 +02:00
|
|
|
newMessage.flags = TLRPC.MESSAGE_FLAG_UNREAD;
|
2013-12-20 20:25:49 +01:00
|
|
|
newMessage.date = update.date;
|
2014-08-29 23:06:04 +02:00
|
|
|
newMessage.from_id = 777000;
|
2013-12-20 20:25:49 +01:00
|
|
|
newMessage.to_id = new TLRPC.TL_peerUser();
|
2014-06-13 12:42:21 +02:00
|
|
|
newMessage.to_id.user_id = UserConfig.getClientUserId();
|
2014-08-29 23:06:04 +02:00
|
|
|
newMessage.dialog_id = 777000;
|
2013-12-20 20:25:49 +01:00
|
|
|
|
|
|
|
messagesArr.add(newMessage);
|
|
|
|
MessageObject obj = new MessageObject(newMessage, usersDict);
|
|
|
|
ArrayList<MessageObject> arr = messages.get(newMessage.dialog_id);
|
|
|
|
if (arr == null) {
|
|
|
|
arr = new ArrayList<MessageObject>();
|
|
|
|
messages.put(newMessage.dialog_id, arr);
|
|
|
|
}
|
|
|
|
arr.add(obj);
|
2014-07-10 02:15:58 +02:00
|
|
|
pushMessages.add(obj);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateNewGeoChatMessage) {
|
2014-02-04 19:36:55 +01:00
|
|
|
//DEPRECATED
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateNewEncryptedMessage) {
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.lastQtsValue = update.qts;
|
2014-10-28 22:27:44 +01:00
|
|
|
ArrayList<TLRPC.Message> decryptedMessages = decryptMessage(((TLRPC.TL_updateNewEncryptedMessage)update).message);
|
|
|
|
if (decryptedMessages != null && !decryptedMessages.isEmpty()) {
|
2013-10-25 17:19:00 +02:00
|
|
|
int cid = ((TLRPC.TL_updateNewEncryptedMessage)update).message.chat_id;
|
2014-10-28 22:27:44 +01:00
|
|
|
long uid = ((long) cid) << 32;
|
2013-10-25 17:19:00 +02:00
|
|
|
ArrayList<MessageObject> arr = messages.get(uid);
|
|
|
|
if (arr == null) {
|
|
|
|
arr = new ArrayList<MessageObject>();
|
|
|
|
messages.put(uid, arr);
|
|
|
|
}
|
2014-10-28 22:27:44 +01:00
|
|
|
for (TLRPC.Message message : decryptedMessages) {
|
|
|
|
messagesArr.add(message);
|
|
|
|
MessageObject obj = new MessageObject(message, usersDict, 2);
|
|
|
|
arr.add(obj);
|
|
|
|
pushMessages.add(obj);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else if (update instanceof TLRPC.TL_updateEncryptedChatTyping) {
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.EncryptedChat encryptedChat = getEncryptedChatDB(update.chat_id);
|
2014-06-11 01:05:54 +02:00
|
|
|
if (encryptedChat != null) {
|
|
|
|
update.user_id = encryptedChat.user_id;
|
|
|
|
long uid = ((long) update.chat_id) << 32;
|
|
|
|
ArrayList<PrintingUser> arr = printingUsers.get(uid);
|
|
|
|
if (arr == null) {
|
|
|
|
arr = new ArrayList<PrintingUser>();
|
|
|
|
printingUsers.put(uid, arr);
|
|
|
|
}
|
|
|
|
boolean exist = false;
|
|
|
|
for (PrintingUser u : arr) {
|
|
|
|
if (u.userId == update.user_id) {
|
|
|
|
exist = true;
|
|
|
|
u.lastTime = currentTime;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!exist) {
|
|
|
|
PrintingUser newUser = new PrintingUser();
|
|
|
|
newUser.userId = update.user_id;
|
|
|
|
newUser.lastTime = currentTime;
|
|
|
|
arr.add(newUser);
|
|
|
|
printChanged = true;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (update instanceof TLRPC.TL_updateEncryptedMessagesRead) {
|
|
|
|
markAsReadEncrypted.put(update.chat_id, Math.max(update.max_date, update.date));
|
|
|
|
tasks.add((TLRPC.TL_updateEncryptedMessagesRead)update);
|
2014-02-04 19:36:55 +01:00
|
|
|
} else if (update instanceof TLRPC.TL_updateChatParticipantAdd) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().updateChatInfo(update.chat_id, update.user_id, false, update.inviter_id, update.version);
|
2014-02-04 19:36:55 +01:00
|
|
|
} else if (update instanceof TLRPC.TL_updateChatParticipantDelete) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().updateChatInfo(update.chat_id, update.user_id, true, 0, update.version);
|
2014-02-04 19:36:55 +01:00
|
|
|
} else if (update instanceof TLRPC.TL_updateDcOptions) {
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().updateDcSettings(0);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateEncryption) {
|
|
|
|
final TLRPC.EncryptedChat newChat = update.chat;
|
|
|
|
long dialog_id = ((long)newChat.id) << 32;
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.EncryptedChat existingChat = getEncryptedChatDB(newChat.id);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
if (newChat instanceof TLRPC.TL_encryptedChatRequested && existingChat == null) {
|
|
|
|
int user_id = newChat.participant_id;
|
2014-06-13 12:42:21 +02:00
|
|
|
if (user_id == UserConfig.getClientUserId()) {
|
2013-10-25 17:19:00 +02:00
|
|
|
user_id = newChat.admin_id;
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User user = getUser(user_id);
|
2013-12-20 20:25:49 +01:00
|
|
|
if (user == null) {
|
|
|
|
user = usersDict.get(user_id);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
newChat.user_id = user_id;
|
|
|
|
final TLRPC.TL_dialog dialog = new TLRPC.TL_dialog();
|
|
|
|
dialog.id = dialog_id;
|
|
|
|
dialog.unread_count = 0;
|
|
|
|
dialog.top_message = 0;
|
|
|
|
dialog.last_message_date = update.date;
|
2014-02-11 15:32:09 +01:00
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
dialogs_dict.put(dialog.id, dialog);
|
|
|
|
dialogs.add(dialog);
|
|
|
|
dialogsServerOnly.clear();
|
2014-08-22 16:24:33 +02:00
|
|
|
putEncryptedChat(newChat, false);
|
2013-10-25 17:19:00 +02:00
|
|
|
Collections.sort(dialogs, new Comparator<TLRPC.TL_dialog>() {
|
|
|
|
@Override
|
|
|
|
public int compare(TLRPC.TL_dialog tl_dialog, TLRPC.TL_dialog tl_dialog2) {
|
|
|
|
if (tl_dialog.last_message_date == tl_dialog2.last_message_date) {
|
|
|
|
return 0;
|
|
|
|
} else if (tl_dialog.last_message_date < tl_dialog2.last_message_date) {
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
for (TLRPC.TL_dialog d : dialogs) {
|
2014-07-30 09:49:39 +02:00
|
|
|
int high_id = (int)(d.id >> 32);
|
|
|
|
if ((int)d.id != 0 && high_id != 1) {
|
2013-10-25 17:19:00 +02:00
|
|
|
dialogsServerOnly.add(d);
|
|
|
|
}
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putEncryptedChat(newChat, user, dialog);
|
2013-11-04 13:31:01 +01:00
|
|
|
acceptSecretChat(newChat);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else if (newChat instanceof TLRPC.TL_encryptedChat) {
|
|
|
|
if (existingChat != null && existingChat instanceof TLRPC.TL_encryptedChatWaiting && (existingChat.auth_key == null || existingChat.auth_key.length == 1)) {
|
|
|
|
newChat.a_or_b = existingChat.a_or_b;
|
|
|
|
newChat.user_id = existingChat.user_id;
|
|
|
|
processAcceptedSecretChat(newChat);
|
2014-03-22 23:31:55 +01:00
|
|
|
} else if (existingChat == null && startingSecretChat) {
|
|
|
|
delayedEncryptedChatUpdates.add(update);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
final TLRPC.EncryptedChat exist = existingChat;
|
2014-10-28 18:07:44 +01:00
|
|
|
if (exist != null) {
|
|
|
|
newChat.user_id = exist.user_id;
|
|
|
|
newChat.auth_key = exist.auth_key;
|
|
|
|
newChat.ttl = exist.ttl;
|
|
|
|
newChat.seq_in = exist.seq_in;
|
|
|
|
newChat.seq_out = exist.seq_out;
|
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (exist != null) {
|
2014-08-22 16:24:33 +02:00
|
|
|
putEncryptedChat(newChat, false);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().updateEncryptedChat(newChat);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.encryptedChatUpdated, newChat);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateUserBlocked) {
|
2014-08-22 16:24:33 +02:00
|
|
|
final TLRPC.TL_updateUserBlocked finalUpdate = (TLRPC.TL_updateUserBlocked)update;
|
|
|
|
if (finalUpdate.blocked) {
|
|
|
|
ArrayList<Integer> ids = new ArrayList<Integer>();
|
|
|
|
ids.add(finalUpdate.user_id);
|
|
|
|
MessagesStorage.getInstance().putBlockedUsers(ids, false);
|
|
|
|
} else {
|
|
|
|
MessagesStorage.getInstance().deleteBlockedUser(finalUpdate.user_id);
|
|
|
|
}
|
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (finalUpdate.blocked) {
|
|
|
|
if (!blockedUsers.contains(finalUpdate.user_id)) {
|
|
|
|
blockedUsers.add(finalUpdate.user_id);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
blockedUsers.remove((Integer)finalUpdate.user_id);
|
|
|
|
}
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.blockedUsersDidLoaded);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2014-07-03 00:39:05 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateNotifySettings) {
|
|
|
|
updatesOnMainThread.add(update);
|
2014-10-17 20:29:13 +02:00
|
|
|
} else if (update instanceof TLRPC.TL_updateServiceNotification) {
|
|
|
|
//TODO
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!messages.isEmpty()) {
|
|
|
|
for (HashMap.Entry<Long, ArrayList<MessageObject>> pair : messages.entrySet()) {
|
|
|
|
Long key = pair.getKey();
|
|
|
|
ArrayList<MessageObject> value = pair.getValue();
|
2014-05-20 22:22:44 +02:00
|
|
|
if (updatePrintingUsersWithNewMessages(key, value)) {
|
|
|
|
printChanged = true;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-20 22:22:44 +02:00
|
|
|
if (printChanged) {
|
2013-10-25 17:19:00 +02:00
|
|
|
updatePrintingStrings();
|
|
|
|
}
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
final int interfaceUpdateMaskFinal = interfaceUpdateMask;
|
2014-05-20 22:22:44 +02:00
|
|
|
final boolean printChangedArg = printChanged;
|
2014-02-04 19:36:55 +01:00
|
|
|
|
2014-03-22 23:31:55 +01:00
|
|
|
processPendingEncMessages();
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
if (!contactsIds.isEmpty()) {
|
2014-03-22 23:31:55 +01:00
|
|
|
ContactsController.getInstance().processContactsUpdates(contactsIds, usersDict);
|
2014-02-04 19:36:55 +01:00
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-07-30 09:49:39 +02:00
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-30 09:49:39 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (!pushMessages.isEmpty()) {
|
|
|
|
NotificationsController.getInstance().processNewMessages(pushMessages, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
if (!messagesArr.isEmpty()) {
|
2014-08-22 16:24:33 +02:00
|
|
|
MessagesStorage.getInstance().putMessages(messagesArr, true, true, false, MediaController.getInstance().getAutodownloadMask());
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-10 02:15:58 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
int updateMask = interfaceUpdateMaskFinal;
|
|
|
|
|
|
|
|
boolean avatarsUpdate = false;
|
|
|
|
if (!updatesOnMainThread.isEmpty()) {
|
|
|
|
ArrayList<TLRPC.User> dbUsers = new ArrayList<TLRPC.User>();
|
|
|
|
ArrayList<TLRPC.User> dbUsersStatus = new ArrayList<TLRPC.User>();
|
|
|
|
SharedPreferences.Editor editor = null;
|
|
|
|
for (TLRPC.Update update : updatesOnMainThread) {
|
|
|
|
TLRPC.User toDbUser = new TLRPC.User();
|
|
|
|
toDbUser.id = update.user_id;
|
2014-08-22 16:24:33 +02:00
|
|
|
TLRPC.User currentUser = getUser(update.user_id);
|
2014-07-10 02:15:58 +02:00
|
|
|
if (update instanceof TLRPC.TL_updateUserStatus) {
|
|
|
|
if (currentUser != null) {
|
|
|
|
currentUser.id = update.user_id;
|
|
|
|
currentUser.status = update.status;
|
|
|
|
}
|
|
|
|
toDbUser.status = update.status;
|
|
|
|
dbUsersStatus.add(toDbUser);
|
|
|
|
} else if (update instanceof TLRPC.TL_updateUserName) {
|
|
|
|
if (currentUser != null) {
|
|
|
|
currentUser.first_name = update.first_name;
|
|
|
|
currentUser.last_name = update.last_name;
|
2014-10-17 20:29:13 +02:00
|
|
|
currentUser.username = update.username;
|
2014-07-10 02:15:58 +02:00
|
|
|
}
|
|
|
|
toDbUser.first_name = update.first_name;
|
|
|
|
toDbUser.last_name = update.last_name;
|
2014-10-17 20:29:13 +02:00
|
|
|
toDbUser.username = update.username;
|
2014-07-10 02:15:58 +02:00
|
|
|
dbUsers.add(toDbUser);
|
|
|
|
} else if (update instanceof TLRPC.TL_updateUserPhoto) {
|
|
|
|
if (currentUser != null) {
|
|
|
|
currentUser.photo = update.photo;
|
|
|
|
}
|
|
|
|
avatarsUpdate = true;
|
|
|
|
toDbUser.photo = update.photo;
|
|
|
|
dbUsers.add(toDbUser);
|
|
|
|
} else if (update instanceof TLRPC.TL_updateNotifySettings) {
|
|
|
|
if (update.notify_settings instanceof TLRPC.TL_peerNotifySettings && update.peer instanceof TLRPC.TL_notifyPeer) {
|
|
|
|
if (editor == null) {
|
|
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("Notifications", Activity.MODE_PRIVATE);
|
|
|
|
editor = preferences.edit();
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-10 02:15:58 +02:00
|
|
|
int dialog_id = update.peer.peer.user_id;
|
|
|
|
if (dialog_id == 0) {
|
|
|
|
dialog_id = -update.peer.peer.chat_id;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-10 02:15:58 +02:00
|
|
|
if (update.notify_settings.mute_until != 0) {
|
|
|
|
editor.putInt("notify2_" + dialog_id, 2);
|
|
|
|
} else {
|
|
|
|
editor.remove("notify2_" + dialog_id);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-27 00:28:33 +02:00
|
|
|
}/* else if (update.peer instanceof TLRPC.TL_notifyChats) { disable global settings sync
|
2014-07-10 02:15:58 +02:00
|
|
|
if (editor == null) {
|
|
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("Notifications", Activity.MODE_PRIVATE);
|
|
|
|
editor = preferences.edit();
|
2014-07-03 00:39:05 +02:00
|
|
|
}
|
2014-07-10 02:15:58 +02:00
|
|
|
editor.putBoolean("EnableGroup", update.notify_settings.mute_until == 0);
|
|
|
|
editor.putBoolean("EnablePreviewGroup", update.notify_settings.show_previews);
|
|
|
|
} else if (update.peer instanceof TLRPC.TL_notifyUsers) {
|
|
|
|
if (editor == null) {
|
|
|
|
SharedPreferences preferences = ApplicationLoader.applicationContext.getSharedPreferences("Notifications", Activity.MODE_PRIVATE);
|
|
|
|
editor = preferences.edit();
|
|
|
|
}
|
|
|
|
editor.putBoolean("EnableAll", update.notify_settings.mute_until == 0);
|
|
|
|
editor.putBoolean("EnablePreviewAll", update.notify_settings.show_previews);
|
2014-07-27 00:28:33 +02:00
|
|
|
}*/
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-10 02:15:58 +02:00
|
|
|
if (editor != null) {
|
|
|
|
editor.commit();
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.notificationsSettingsUpdated);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-07-10 02:15:58 +02:00
|
|
|
MessagesStorage.getInstance().updateUsers(dbUsersStatus, true, true, true);
|
|
|
|
MessagesStorage.getInstance().updateUsers(dbUsers, false, true, true);
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
|
2014-07-10 02:15:58 +02:00
|
|
|
if (!messages.isEmpty()) {
|
|
|
|
for (HashMap.Entry<Long, ArrayList<MessageObject>> entry : messages.entrySet()) {
|
|
|
|
Long key = entry.getKey();
|
|
|
|
ArrayList<MessageObject> value = entry.getValue();
|
|
|
|
updateInterfaceWithMessages(key, value);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
2014-07-10 02:15:58 +02:00
|
|
|
}
|
|
|
|
if (printChangedArg) {
|
|
|
|
updateMask |= UPDATE_MASK_USER_PRINT;
|
|
|
|
}
|
|
|
|
if (!contactsIds.isEmpty()) {
|
|
|
|
updateMask |= UPDATE_MASK_NAME;
|
|
|
|
updateMask |= UPDATE_MASK_USER_PHONE;
|
|
|
|
}
|
|
|
|
if (!chatInfoToUpdate.isEmpty()) {
|
|
|
|
for (TLRPC.ChatParticipants info : chatInfoToUpdate) {
|
|
|
|
MessagesStorage.getInstance().updateChatInfo(info.chat_id, info, true);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.chatInfoDidLoaded, info.chat_id, info);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
2014-07-10 02:15:58 +02:00
|
|
|
if (updateMask != 0) {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, updateMask);
|
2014-07-10 02:15:58 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2014-07-30 09:49:39 +02:00
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2014-07-30 09:49:39 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-06 01:17:40 +02:00
|
|
|
int updateMask = 0;
|
2014-07-30 09:49:39 +02:00
|
|
|
if (!markAsReadMessages.isEmpty()) {
|
2014-09-14 01:40:36 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.messagesRead, markAsReadMessages);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationsController.getInstance().processReadMessages(markAsReadMessages, 0, 0, 0, false);
|
2014-08-06 01:17:40 +02:00
|
|
|
|
|
|
|
for (Integer id : markAsReadMessages) {
|
|
|
|
MessageObject obj = dialogMessage.get(id);
|
|
|
|
if (obj != null) {
|
2014-10-09 17:55:05 +02:00
|
|
|
obj.setIsRead();
|
2014-08-06 01:17:40 +02:00
|
|
|
updateMask |= UPDATE_MASK_READ_DIALOG_MESSAGE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!markAsReadEncrypted.isEmpty()) {
|
|
|
|
for (HashMap.Entry<Integer, Integer> entry : markAsReadEncrypted.entrySet()) {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.messagesReadedEncrypted, entry.getKey(), entry.getValue());
|
2014-08-06 01:17:40 +02:00
|
|
|
long dialog_id = (long)(entry.getKey()) << 32;
|
|
|
|
TLRPC.TL_dialog dialog = dialogs_dict.get(dialog_id);
|
|
|
|
if (dialog != null) {
|
|
|
|
MessageObject message = dialogMessage.get(dialog.top_message);
|
|
|
|
if (message != null && message.messageOwner.date <= entry.getValue()) {
|
2014-10-09 17:55:05 +02:00
|
|
|
message.setIsRead();
|
2014-08-06 01:17:40 +02:00
|
|
|
updateMask |= UPDATE_MASK_READ_DIALOG_MESSAGE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!deletedMessages.isEmpty()) {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.messagesDeleted, deletedMessages);
|
2014-08-06 01:17:40 +02:00
|
|
|
for (Integer id : deletedMessages) {
|
|
|
|
MessageObject obj = dialogMessage.get(id);
|
|
|
|
if (obj != null) {
|
|
|
|
obj.deleted = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (updateMask != 0) {
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateInterfaces, updateMask);
|
2014-03-22 23:31:55 +01:00
|
|
|
}
|
2014-07-30 09:49:39 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2014-03-22 23:31:55 +01:00
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
if (!markAsReadMessages.isEmpty() || !markAsReadEncrypted.isEmpty()) {
|
2014-02-28 23:28:25 +01:00
|
|
|
if (!markAsReadMessages.isEmpty()) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().updateDialogsWithReadedMessages(markAsReadMessages, true);
|
2014-02-28 23:28:25 +01:00
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().markMessagesAsRead(markAsReadMessages, markAsReadEncrypted, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
if (!deletedMessages.isEmpty()) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().markMessagesAsDeleted(deletedMessages, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
if (!deletedMessages.isEmpty()) {
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().updateDialogsWithDeletedMessages(deletedMessages, true);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
if (!tasks.isEmpty()) {
|
|
|
|
for (TLRPC.TL_updateEncryptedMessagesRead update : tasks) {
|
2014-10-09 17:55:05 +02:00
|
|
|
MessagesStorage.getInstance().createTaskForSecretChat(update.chat_id, update.max_date, update.date, 1, null);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean updatePrintingUsersWithNewMessages(long uid, ArrayList<MessageObject> messages) {
|
|
|
|
if (uid > 0) {
|
|
|
|
ArrayList<PrintingUser> arr = printingUsers.get(uid);
|
|
|
|
if (arr != null) {
|
|
|
|
printingUsers.remove(uid);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else if (uid < 0) {
|
|
|
|
ArrayList<Integer> messagesUsers = new ArrayList<Integer>();
|
|
|
|
for (MessageObject message : messages) {
|
|
|
|
if (!messagesUsers.contains(message.messageOwner.from_id)) {
|
|
|
|
messagesUsers.add(message.messageOwner.from_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayList<PrintingUser> arr = printingUsers.get(uid);
|
|
|
|
boolean changed = false;
|
|
|
|
if (arr != null) {
|
|
|
|
for (int a = 0; a < arr.size(); a++) {
|
|
|
|
PrintingUser user = arr.get(a);
|
|
|
|
if (messagesUsers.contains(user.userId)) {
|
|
|
|
arr.remove(a);
|
|
|
|
a--;
|
|
|
|
if (arr.isEmpty()) {
|
|
|
|
printingUsers.remove(uid);
|
|
|
|
}
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (changed) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
protected void updateInterfaceWithMessages(long uid, ArrayList<MessageObject> messages) {
|
2014-07-27 00:28:33 +02:00
|
|
|
updateInterfaceWithMessages(uid, messages, false);
|
|
|
|
}
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
protected void updateInterfaceWithMessages(final long uid, final ArrayList<MessageObject> messages, boolean isBroadcast) {
|
2013-10-25 17:19:00 +02:00
|
|
|
MessageObject lastMessage = null;
|
|
|
|
TLRPC.TL_dialog dialog = dialogs_dict.get(uid);
|
|
|
|
|
2014-03-05 17:42:10 +01:00
|
|
|
boolean isEncryptedChat = ((int)uid) == 0;
|
|
|
|
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.didReceivedNewMessages, uid, messages);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
for (MessageObject message : messages) {
|
2014-03-05 17:42:10 +01:00
|
|
|
if (lastMessage == null || (!isEncryptedChat && message.messageOwner.id > lastMessage.messageOwner.id || isEncryptedChat && message.messageOwner.id < lastMessage.messageOwner.id) || message.messageOwner.date > lastMessage.messageOwner.date) {
|
2013-10-25 17:19:00 +02:00
|
|
|
lastMessage = message;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-05 17:42:10 +01:00
|
|
|
boolean changed = false;
|
|
|
|
|
2013-10-25 17:19:00 +02:00
|
|
|
if (dialog == null) {
|
2014-07-27 00:28:33 +02:00
|
|
|
if (!isBroadcast) {
|
|
|
|
dialog = new TLRPC.TL_dialog();
|
|
|
|
dialog.id = uid;
|
|
|
|
dialog.unread_count = 0;
|
|
|
|
dialog.top_message = lastMessage.messageOwner.id;
|
|
|
|
dialog.last_message_date = lastMessage.messageOwner.date;
|
|
|
|
dialogs_dict.put(uid, dialog);
|
|
|
|
dialogs.add(dialog);
|
|
|
|
dialogMessage.put(lastMessage.messageOwner.id, lastMessage);
|
|
|
|
changed = true;
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2014-09-24 04:17:27 +02:00
|
|
|
boolean change = false;
|
2014-03-04 20:29:32 +01:00
|
|
|
if (dialog.top_message > 0 && lastMessage.messageOwner.id > 0 && lastMessage.messageOwner.id > dialog.top_message ||
|
2014-09-24 04:17:27 +02:00
|
|
|
dialog.top_message < 0 && lastMessage.messageOwner.id < 0 && lastMessage.messageOwner.id < dialog.top_message) {
|
|
|
|
change = true;
|
|
|
|
} else {
|
|
|
|
MessageObject currentDialogMessage = dialogMessage.get(dialog.top_message);
|
|
|
|
if (currentDialogMessage != null) {
|
2014-09-28 15:37:26 +02:00
|
|
|
if (currentDialogMessage.isSending() && lastMessage.isSending()) {
|
2014-09-24 04:17:27 +02:00
|
|
|
change = true;
|
2014-09-28 15:37:26 +02:00
|
|
|
} else if (dialog.last_message_date < lastMessage.messageOwner.date || dialog.last_message_date == lastMessage.messageOwner.date && lastMessage.isSending()) {
|
2014-09-24 04:17:27 +02:00
|
|
|
change = true;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
change = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (change) {
|
2014-03-05 17:42:10 +01:00
|
|
|
dialogMessage.remove(dialog.top_message);
|
2014-03-04 20:29:32 +01:00
|
|
|
dialog.top_message = lastMessage.messageOwner.id;
|
2014-07-27 00:28:33 +02:00
|
|
|
if (!isBroadcast) {
|
|
|
|
dialog.last_message_date = lastMessage.messageOwner.date;
|
|
|
|
changed = true;
|
|
|
|
}
|
2014-03-04 20:29:32 +01:00
|
|
|
dialogMessage.put(lastMessage.messageOwner.id, lastMessage);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-03-05 17:42:10 +01:00
|
|
|
if (changed) {
|
|
|
|
dialogsServerOnly.clear();
|
|
|
|
Collections.sort(dialogs, new Comparator<TLRPC.TL_dialog>() {
|
|
|
|
@Override
|
|
|
|
public int compare(TLRPC.TL_dialog tl_dialog, TLRPC.TL_dialog tl_dialog2) {
|
|
|
|
if (tl_dialog.last_message_date == tl_dialog2.last_message_date) {
|
|
|
|
return 0;
|
|
|
|
} else if (tl_dialog.last_message_date < tl_dialog2.last_message_date) {
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
for (TLRPC.TL_dialog d : dialogs) {
|
2014-07-30 09:49:39 +02:00
|
|
|
int high_id = (int)(d.id >> 32);
|
|
|
|
if ((int)d.id != 0 && high_id != 1) {
|
2014-03-05 17:42:10 +01:00
|
|
|
dialogsServerOnly.add(d);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-28 18:07:44 +01:00
|
|
|
public TLRPC.Message processDecryptedObject(final TLRPC.EncryptedChat chat, final TLRPC.EncryptedFile file, int date, long random_id, TLObject object) {
|
|
|
|
if (object != null) {
|
|
|
|
int from_id = chat.admin_id;
|
|
|
|
if (from_id == UserConfig.getClientUserId()) {
|
|
|
|
from_id = chat.participant_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (object instanceof TLRPC.TL_decryptedMessage) {
|
|
|
|
TLRPC.TL_decryptedMessage decryptedMessage = (TLRPC.TL_decryptedMessage)object;
|
|
|
|
TLRPC.TL_message newMessage = null;
|
|
|
|
if (AndroidUtilities.getPeerLayerVersion(chat.layer) >= 17) {
|
|
|
|
newMessage = new TLRPC.TL_message_secret();
|
|
|
|
newMessage.ttl = decryptedMessage.ttl;
|
|
|
|
} else {
|
|
|
|
newMessage = new TLRPC.TL_message();
|
|
|
|
newMessage.ttl = chat.ttl;
|
|
|
|
}
|
|
|
|
newMessage.message = decryptedMessage.message;
|
|
|
|
newMessage.date = date;
|
|
|
|
newMessage.local_id = newMessage.id = UserConfig.getNewMessageId();
|
|
|
|
UserConfig.saveConfig(false);
|
|
|
|
newMessage.from_id = from_id;
|
|
|
|
newMessage.to_id = new TLRPC.TL_peerUser();
|
|
|
|
newMessage.random_id = random_id;
|
|
|
|
newMessage.to_id.user_id = UserConfig.getClientUserId();
|
|
|
|
newMessage.flags = TLRPC.MESSAGE_FLAG_UNREAD;
|
|
|
|
newMessage.dialog_id = ((long)chat.id) << 32;
|
|
|
|
if (decryptedMessage.media instanceof TLRPC.TL_decryptedMessageMediaEmpty) {
|
|
|
|
newMessage.media = new TLRPC.TL_messageMediaEmpty();
|
|
|
|
} else if (decryptedMessage.media instanceof TLRPC.TL_decryptedMessageMediaContact) {
|
|
|
|
newMessage.media = new TLRPC.TL_messageMediaContact();
|
|
|
|
newMessage.media.last_name = decryptedMessage.media.last_name;
|
|
|
|
newMessage.media.first_name = decryptedMessage.media.first_name;
|
|
|
|
newMessage.media.phone_number = decryptedMessage.media.phone_number;
|
|
|
|
newMessage.media.user_id = decryptedMessage.media.user_id;
|
|
|
|
} else if (decryptedMessage.media instanceof TLRPC.TL_decryptedMessageMediaGeoPoint) {
|
|
|
|
newMessage.media = new TLRPC.TL_messageMediaGeo();
|
|
|
|
newMessage.media.geo = new TLRPC.TL_geoPoint();
|
|
|
|
newMessage.media.geo.lat = decryptedMessage.media.lat;
|
|
|
|
newMessage.media.geo._long = decryptedMessage.media._long;
|
|
|
|
} else if (decryptedMessage.media instanceof TLRPC.TL_decryptedMessageMediaPhoto) {
|
|
|
|
if (decryptedMessage.media.key == null || decryptedMessage.media.key.length != 32 || decryptedMessage.media.iv == null || decryptedMessage.media.iv.length != 32) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
newMessage.media = new TLRPC.TL_messageMediaPhoto();
|
|
|
|
newMessage.media.photo = new TLRPC.TL_photo();
|
|
|
|
newMessage.media.photo.user_id = newMessage.from_id;
|
|
|
|
newMessage.media.photo.date = newMessage.date;
|
|
|
|
newMessage.media.photo.caption = "";
|
|
|
|
newMessage.media.photo.geo = new TLRPC.TL_geoPointEmpty();
|
|
|
|
if (decryptedMessage.media.thumb.length != 0 && decryptedMessage.media.thumb.length <= 6000 && decryptedMessage.media.thumb_w <= 100 && decryptedMessage.media.thumb_h <= 100) {
|
|
|
|
TLRPC.TL_photoCachedSize small = new TLRPC.TL_photoCachedSize();
|
|
|
|
small.w = decryptedMessage.media.thumb_w;
|
|
|
|
small.h = decryptedMessage.media.thumb_h;
|
|
|
|
small.bytes = decryptedMessage.media.thumb;
|
|
|
|
small.type = "s";
|
|
|
|
small.location = new TLRPC.TL_fileLocationUnavailable();
|
|
|
|
newMessage.media.photo.sizes.add(small);
|
|
|
|
}
|
|
|
|
|
|
|
|
TLRPC.TL_photoSize big = new TLRPC.TL_photoSize();
|
|
|
|
big.w = decryptedMessage.media.w;
|
|
|
|
big.h = decryptedMessage.media.h;
|
|
|
|
big.type = "x";
|
|
|
|
big.size = file.size;
|
|
|
|
big.location = new TLRPC.TL_fileEncryptedLocation();
|
|
|
|
big.location.key = decryptedMessage.media.key;
|
|
|
|
big.location.iv = decryptedMessage.media.iv;
|
|
|
|
big.location.dc_id = file.dc_id;
|
|
|
|
big.location.volume_id = file.id;
|
|
|
|
big.location.secret = file.access_hash;
|
|
|
|
big.location.local_id = file.key_fingerprint;
|
|
|
|
newMessage.media.photo.sizes.add(big);
|
|
|
|
} else if (decryptedMessage.media instanceof TLRPC.TL_decryptedMessageMediaVideo) {
|
|
|
|
if (decryptedMessage.media.key == null || decryptedMessage.media.key.length != 32 || decryptedMessage.media.iv == null || decryptedMessage.media.iv.length != 32) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
newMessage.media = new TLRPC.TL_messageMediaVideo();
|
|
|
|
newMessage.media.video = new TLRPC.TL_videoEncrypted();
|
|
|
|
if (decryptedMessage.media.thumb.length != 0 && decryptedMessage.media.thumb.length <= 6000 && decryptedMessage.media.thumb_w <= 100 && decryptedMessage.media.thumb_h <= 100) {
|
|
|
|
newMessage.media.video.thumb = new TLRPC.TL_photoCachedSize();
|
|
|
|
newMessage.media.video.thumb.bytes = decryptedMessage.media.thumb;
|
|
|
|
newMessage.media.video.thumb.w = decryptedMessage.media.thumb_w;
|
|
|
|
newMessage.media.video.thumb.h = decryptedMessage.media.thumb_h;
|
|
|
|
newMessage.media.video.thumb.type = "s";
|
|
|
|
newMessage.media.video.thumb.location = new TLRPC.TL_fileLocationUnavailable();
|
|
|
|
} else {
|
|
|
|
newMessage.media.video.thumb = new TLRPC.TL_photoSizeEmpty();
|
|
|
|
newMessage.media.video.thumb.type = "s";
|
|
|
|
}
|
|
|
|
newMessage.media.video.duration = decryptedMessage.media.duration;
|
|
|
|
newMessage.media.video.dc_id = file.dc_id;
|
|
|
|
newMessage.media.video.w = decryptedMessage.media.w;
|
|
|
|
newMessage.media.video.h = decryptedMessage.media.h;
|
|
|
|
newMessage.media.video.date = date;
|
|
|
|
newMessage.media.video.caption = "";
|
|
|
|
newMessage.media.video.user_id = from_id;
|
|
|
|
newMessage.media.video.size = file.size;
|
|
|
|
newMessage.media.video.id = file.id;
|
|
|
|
newMessage.media.video.access_hash = file.access_hash;
|
|
|
|
newMessage.media.video.key = decryptedMessage.media.key;
|
|
|
|
newMessage.media.video.iv = decryptedMessage.media.iv;
|
|
|
|
newMessage.media.video.mime_type = decryptedMessage.media.mime_type;
|
|
|
|
if (newMessage.ttl != 0) {
|
|
|
|
newMessage.ttl = Math.max(newMessage.media.video.duration + 1, newMessage.ttl);
|
|
|
|
}
|
|
|
|
if (newMessage.media.video.mime_type == null) {
|
|
|
|
newMessage.media.video.mime_type = "video/mp4";
|
|
|
|
}
|
|
|
|
} else if (decryptedMessage.media instanceof TLRPC.TL_decryptedMessageMediaDocument) {
|
|
|
|
if (decryptedMessage.media.key == null || decryptedMessage.media.key.length != 32 || decryptedMessage.media.iv == null || decryptedMessage.media.iv.length != 32) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
newMessage.media = new TLRPC.TL_messageMediaDocument();
|
|
|
|
newMessage.media.document = new TLRPC.TL_documentEncrypted();
|
|
|
|
newMessage.media.document.id = file.id;
|
|
|
|
newMessage.media.document.access_hash = file.access_hash;
|
|
|
|
newMessage.media.document.user_id = decryptedMessage.media.user_id;
|
|
|
|
newMessage.media.document.date = date;
|
|
|
|
newMessage.media.document.file_name = decryptedMessage.media.file_name;
|
|
|
|
newMessage.media.document.mime_type = decryptedMessage.media.mime_type;
|
|
|
|
newMessage.media.document.size = file.size;
|
|
|
|
newMessage.media.document.key = decryptedMessage.media.key;
|
|
|
|
newMessage.media.document.iv = decryptedMessage.media.iv;
|
|
|
|
if (decryptedMessage.media.thumb.length != 0 && decryptedMessage.media.thumb.length <= 6000 && decryptedMessage.media.thumb_w <= 100 && decryptedMessage.media.thumb_h <= 100) {
|
|
|
|
newMessage.media.document.thumb = new TLRPC.TL_photoCachedSize();
|
|
|
|
newMessage.media.document.thumb.bytes = decryptedMessage.media.thumb;
|
|
|
|
newMessage.media.document.thumb.w = decryptedMessage.media.thumb_w;
|
|
|
|
newMessage.media.document.thumb.h = decryptedMessage.media.thumb_h;
|
|
|
|
newMessage.media.document.thumb.type = "s";
|
|
|
|
newMessage.media.document.thumb.location = new TLRPC.TL_fileLocationUnavailable();
|
|
|
|
} else {
|
|
|
|
newMessage.media.document.thumb = new TLRPC.TL_photoSizeEmpty();
|
|
|
|
newMessage.media.document.thumb.type = "s";
|
|
|
|
}
|
|
|
|
newMessage.media.document.dc_id = file.dc_id;
|
|
|
|
} else if (decryptedMessage.media instanceof TLRPC.TL_decryptedMessageMediaAudio) {
|
|
|
|
if (decryptedMessage.media.key == null || decryptedMessage.media.key.length != 32 || decryptedMessage.media.iv == null || decryptedMessage.media.iv.length != 32) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
newMessage.media = new TLRPC.TL_messageMediaAudio();
|
|
|
|
newMessage.media.audio = new TLRPC.TL_audioEncrypted();
|
|
|
|
newMessage.media.audio.id = file.id;
|
|
|
|
newMessage.media.audio.access_hash = file.access_hash;
|
|
|
|
newMessage.media.audio.user_id = from_id;
|
|
|
|
newMessage.media.audio.date = date;
|
|
|
|
newMessage.media.audio.size = file.size;
|
|
|
|
newMessage.media.audio.key = decryptedMessage.media.key;
|
|
|
|
newMessage.media.audio.iv = decryptedMessage.media.iv;
|
|
|
|
newMessage.media.audio.dc_id = file.dc_id;
|
|
|
|
newMessage.media.audio.duration = decryptedMessage.media.duration;
|
|
|
|
newMessage.media.audio.mime_type = decryptedMessage.media.mime_type;
|
|
|
|
if (newMessage.ttl != 0) {
|
|
|
|
newMessage.ttl = Math.max(newMessage.media.audio.duration + 1, newMessage.ttl);
|
|
|
|
}
|
|
|
|
if (newMessage.media.audio.mime_type == null) {
|
|
|
|
newMessage.media.audio.mime_type = "audio/ogg";
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
return newMessage;
|
|
|
|
} else if (object instanceof TLRPC.TL_decryptedMessageService) {
|
|
|
|
final TLRPC.TL_decryptedMessageService serviceMessage = (TLRPC.TL_decryptedMessageService)object;
|
|
|
|
if (serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionSetMessageTTL || serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionScreenshotMessages) {
|
|
|
|
TLRPC.TL_messageService newMessage = new TLRPC.TL_messageService();
|
|
|
|
if (serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionSetMessageTTL) {
|
|
|
|
newMessage.action = new TLRPC.TL_messageEncryptedAction();
|
|
|
|
if (serviceMessage.action.ttl_seconds < 0 || serviceMessage.action.ttl_seconds > 60 * 60 * 24 * 365) {
|
|
|
|
serviceMessage.action.ttl_seconds = 60 * 60 * 24 * 365;
|
|
|
|
}
|
|
|
|
chat.ttl = serviceMessage.action.ttl_seconds;
|
|
|
|
newMessage.action.encryptedAction = serviceMessage.action;
|
|
|
|
MessagesStorage.getInstance().updateEncryptedChatTTL(chat);
|
|
|
|
} else if (serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionScreenshotMessages) {
|
|
|
|
newMessage.action = new TLRPC.TL_messageEncryptedAction();
|
|
|
|
newMessage.action.encryptedAction = serviceMessage.action;
|
|
|
|
}
|
|
|
|
newMessage.local_id = newMessage.id = UserConfig.getNewMessageId();
|
|
|
|
UserConfig.saveConfig(false);
|
|
|
|
newMessage.flags = TLRPC.MESSAGE_FLAG_UNREAD;
|
|
|
|
newMessage.date = date;
|
|
|
|
newMessage.from_id = from_id;
|
|
|
|
newMessage.to_id = new TLRPC.TL_peerUser();
|
|
|
|
newMessage.to_id.user_id = UserConfig.getClientUserId();
|
|
|
|
newMessage.dialog_id = ((long)chat.id) << 32;
|
|
|
|
return newMessage;
|
|
|
|
} else if (serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionFlushHistory) {
|
|
|
|
final long did = ((long)chat.id) << 32;
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
TLRPC.TL_dialog dialog = dialogs_dict.get(did);
|
|
|
|
if (dialog != null) {
|
|
|
|
dialog.unread_count = 0;
|
|
|
|
dialogMessage.remove(dialog.top_message);
|
|
|
|
}
|
|
|
|
MessagesStorage.getInstance().storageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
NotificationsController.getInstance().processReadMessages(null, did, 0, Integer.MAX_VALUE, false);
|
|
|
|
HashMap<Long, Integer> dialogsToUpdate = new HashMap<Long, Integer>();
|
|
|
|
dialogsToUpdate.put(did, 0);
|
|
|
|
NotificationsController.getInstance().processDialogsUpdateRead(dialogsToUpdate);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
MessagesStorage.getInstance().deleteDialog(did, true);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.removeAllMessagesFromDialog, did);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
return null;
|
|
|
|
} else if (serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionDeleteMessages) {
|
|
|
|
if (!serviceMessage.action.random_ids.isEmpty()) {
|
|
|
|
pendingEncMessagesToDelete.addAll(serviceMessage.action.random_ids);
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
} else if (serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionReadMessages) {
|
|
|
|
if (!serviceMessage.action.random_ids.isEmpty()) {
|
|
|
|
MessagesStorage.getInstance().createTaskForSecretChat(chat.id, ConnectionsManager.getInstance().getCurrentTime(), ConnectionsManager.getInstance().getCurrentTime(), 1, serviceMessage.action.random_ids);
|
|
|
|
}
|
|
|
|
} else if (serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionNotifyLayer) {
|
|
|
|
int currentPeerLayer = AndroidUtilities.getPeerLayerVersion(chat.layer);
|
|
|
|
chat.layer = 0;
|
|
|
|
chat.layer = AndroidUtilities.setPeerLayerVersion(chat.layer, serviceMessage.action.layer);
|
|
|
|
MessagesStorage.getInstance().updateEncryptedChatLayer(chat);
|
|
|
|
if (currentPeerLayer < 17) {
|
|
|
|
SendMessagesHelper.getInstance().sendNotifyLayerMessage(chat, null);
|
|
|
|
}
|
|
|
|
} else if (serviceMessage.action instanceof TLRPC.TL_decryptedMessageActionResend) {
|
|
|
|
|
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
FileLog.e("tmessages", "unkown message " + object);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
FileLog.e("tmessages", "unkown TLObject");
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2014-10-28 22:27:44 +01:00
|
|
|
public void checkSecretHoles(TLRPC.EncryptedChat chat, ArrayList<TLRPC.Message> messages) {
|
|
|
|
ArrayList<TLRPC.TL_decryptedMessageHolder> holes = secretHolesQueue.get(chat.id);
|
2014-10-28 18:07:44 +01:00
|
|
|
if (holes == null) {
|
2014-10-28 22:27:44 +01:00
|
|
|
return;
|
2014-10-28 18:07:44 +01:00
|
|
|
}
|
|
|
|
Collections.sort(holes, new Comparator<TLRPC.TL_decryptedMessageHolder>() {
|
|
|
|
@Override
|
|
|
|
public int compare(TLRPC.TL_decryptedMessageHolder lhs, TLRPC.TL_decryptedMessageHolder rhs) {
|
2014-10-28 22:27:44 +01:00
|
|
|
if (lhs.layer.out_seq_no > rhs.layer.out_seq_no) {
|
2014-10-28 18:07:44 +01:00
|
|
|
return 1;
|
2014-10-28 22:27:44 +01:00
|
|
|
} else if (lhs.layer.out_seq_no < rhs.layer.out_seq_no) {
|
2014-10-28 18:07:44 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
boolean update = false;
|
|
|
|
for (int a = 0; a < holes.size(); a++) {
|
|
|
|
TLRPC.TL_decryptedMessageHolder holder = holes.get(a);
|
2014-10-28 22:27:44 +01:00
|
|
|
if (holder.layer.out_seq_no == chat.seq_in || chat.seq_in == holder.layer.out_seq_no - 2) {
|
2014-10-28 18:07:44 +01:00
|
|
|
chat.seq_in = holder.layer.out_seq_no;
|
|
|
|
holes.remove(a);
|
|
|
|
a--;
|
|
|
|
update = true;
|
|
|
|
|
|
|
|
TLRPC.Message message = processDecryptedObject(chat, holder.file, holder.date, holder.random_id, holder.layer.message);
|
|
|
|
if (message != null) {
|
2014-10-28 22:27:44 +01:00
|
|
|
messages.add(message);
|
2014-10-28 18:07:44 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (holes.isEmpty()) {
|
2014-10-28 22:27:44 +01:00
|
|
|
secretHolesQueue.remove(chat.id);
|
2014-10-28 18:07:44 +01:00
|
|
|
}
|
|
|
|
if (update) {
|
|
|
|
MessagesStorage.getInstance().updateEncryptedChatSeq(chat);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-28 22:27:44 +01:00
|
|
|
public ArrayList<TLRPC.Message> decryptMessage(TLRPC.EncryptedMessage message) {
|
2014-10-14 10:13:16 +02:00
|
|
|
final TLRPC.EncryptedChat chat = getEncryptedChatDB(message.chat_id);
|
2014-10-22 22:01:07 +02:00
|
|
|
if (chat == null || chat instanceof TLRPC.TL_encryptedChatDiscarded) {
|
2013-10-25 17:19:00 +02:00
|
|
|
return null;
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
ByteBufferDesc is = BuffersStorage.getInstance().getFreeBuffer(message.bytes.length);
|
|
|
|
is.writeRaw(message.bytes);
|
|
|
|
is.position(0);
|
2013-10-25 17:19:00 +02:00
|
|
|
long fingerprint = is.readInt64();
|
|
|
|
if (chat.key_fingerprint == fingerprint) {
|
|
|
|
byte[] messageKey = is.readData(16);
|
|
|
|
MessageKeyData keyData = Utilities.generateMessageKeyData(chat.auth_key, messageKey, false);
|
|
|
|
|
2014-07-03 00:39:05 +02:00
|
|
|
Utilities.aesIgeEncryption(is.buffer, keyData.aesKey, keyData.aesIv, false, false, 24, is.limit() - 24);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
int len = is.readInt32();
|
|
|
|
TLObject object = TLClassStore.Instance().TLdeserialize(is, is.readInt32());
|
2014-07-03 00:39:05 +02:00
|
|
|
BuffersStorage.getInstance().reuseFreeBuffer(is);
|
2014-10-28 18:07:44 +01:00
|
|
|
if (object instanceof TLRPC.TL_decryptedMessageLayer) {
|
|
|
|
final TLRPC.TL_decryptedMessageLayer layer = (TLRPC.TL_decryptedMessageLayer)object;
|
|
|
|
if (chat.seq_in == 0 && chat.seq_out == 0) {
|
|
|
|
if (chat.admin_id == UserConfig.getClientUserId()) {
|
|
|
|
chat.seq_out = 1;
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2014-10-28 18:07:44 +01:00
|
|
|
chat.seq_in = 1;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-10-28 18:07:44 +01:00
|
|
|
}
|
|
|
|
if (layer.out_seq_no < chat.seq_in) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
if (chat.seq_in != layer.out_seq_no && chat.seq_in != layer.out_seq_no - 2) {
|
2014-10-29 15:28:54 +01:00
|
|
|
ArrayList<TLRPC.TL_decryptedMessageHolder> arr = secretHolesQueue.get(chat.id);
|
|
|
|
if (arr == null) {
|
|
|
|
arr = new ArrayList<TLRPC.TL_decryptedMessageHolder>();
|
|
|
|
secretHolesQueue.put(chat.id, arr);
|
|
|
|
}
|
|
|
|
if (arr.size() >= 10) {
|
|
|
|
secretHolesQueue.remove(chat.id);
|
2014-10-28 18:07:44 +01:00
|
|
|
final TLRPC.TL_encryptedChatDiscarded newChat = new TLRPC.TL_encryptedChatDiscarded();
|
|
|
|
newChat.id = chat.id;
|
|
|
|
newChat.user_id = chat.user_id;
|
|
|
|
newChat.auth_key = chat.auth_key;
|
|
|
|
newChat.seq_in = chat.seq_in;
|
|
|
|
newChat.seq_out = chat.seq_out;
|
2014-10-14 10:13:16 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-10-28 18:07:44 +01:00
|
|
|
putEncryptedChat(newChat, false);
|
|
|
|
MessagesStorage.getInstance().updateEncryptedChat(newChat);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.encryptedChatUpdated, newChat);
|
2014-10-14 10:13:16 +02:00
|
|
|
}
|
|
|
|
});
|
2014-10-28 18:07:44 +01:00
|
|
|
declineSecretChat(chat.id);
|
2014-10-29 15:28:54 +01:00
|
|
|
return null;
|
2014-10-28 18:07:44 +01:00
|
|
|
}
|
2014-10-29 15:28:54 +01:00
|
|
|
|
2014-10-28 18:07:44 +01:00
|
|
|
TLRPC.TL_decryptedMessageHolder holder = new TLRPC.TL_decryptedMessageHolder();
|
|
|
|
holder.layer = layer;
|
|
|
|
holder.file = message.file;
|
|
|
|
holder.random_id = message.random_id;
|
|
|
|
holder.date = message.date;
|
|
|
|
arr.add(holder);
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
chat.seq_in = layer.out_seq_no;
|
|
|
|
MessagesStorage.getInstance().updateEncryptedChatSeq(chat);
|
|
|
|
object = layer.message;
|
|
|
|
}
|
2014-10-28 22:27:44 +01:00
|
|
|
ArrayList<TLRPC.Message> messages = new ArrayList<TLRPC.Message>();
|
|
|
|
TLRPC.Message decryptedMessage = processDecryptedObject(chat, message.file, message.date, message.random_id, object);
|
|
|
|
if (decryptedMessage != null) {
|
|
|
|
messages.add(decryptedMessage);
|
|
|
|
}
|
|
|
|
checkSecretHoles(chat, messages);
|
|
|
|
return messages;
|
2014-02-04 19:36:55 +01:00
|
|
|
} else {
|
2014-08-06 01:17:40 +02:00
|
|
|
BuffersStorage.getInstance().reuseFreeBuffer(is);
|
2014-02-04 19:36:55 +01:00
|
|
|
FileLog.e("tmessages", "fingerprint mismatch");
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
public void processAcceptedSecretChat(final TLRPC.EncryptedChat encryptedChat) {
|
2013-12-23 12:05:57 +01:00
|
|
|
BigInteger p = new BigInteger(1, MessagesStorage.secretPBytes);
|
2013-10-25 17:19:00 +02:00
|
|
|
BigInteger i_authKey = new BigInteger(1, encryptedChat.g_a_or_b);
|
2013-12-23 12:05:57 +01:00
|
|
|
|
2013-12-23 12:54:31 +01:00
|
|
|
if (!Utilities.isGoodGaAndGb(i_authKey, p)) {
|
2013-12-23 12:05:57 +01:00
|
|
|
declineSecretChat(encryptedChat.id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
i_authKey = i_authKey.modPow(new BigInteger(1, encryptedChat.a_or_b), p);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
|
|
|
byte[] authKey = i_authKey.toByteArray();
|
|
|
|
if (authKey.length > 256) {
|
|
|
|
byte[] correctedAuth = new byte[256];
|
|
|
|
System.arraycopy(authKey, authKey.length - 256, correctedAuth, 0, 256);
|
|
|
|
authKey = correctedAuth;
|
|
|
|
} else if (authKey.length < 256) {
|
|
|
|
byte[] correctedAuth = new byte[256];
|
|
|
|
System.arraycopy(authKey, 0, correctedAuth, 256 - authKey.length, authKey.length);
|
|
|
|
for (int a = 0; a < 256 - authKey.length; a++) {
|
|
|
|
authKey[a] = 0;
|
|
|
|
}
|
|
|
|
authKey = correctedAuth;
|
|
|
|
}
|
|
|
|
byte[] authKeyHash = Utilities.computeSHA1(authKey);
|
|
|
|
byte[] authKeyId = new byte[8];
|
|
|
|
System.arraycopy(authKeyHash, authKeyHash.length - 8, authKeyId, 0, 8);
|
|
|
|
long fingerprint = Utilities.bytesToLong(authKeyId);
|
|
|
|
if (encryptedChat.key_fingerprint == fingerprint) {
|
|
|
|
encryptedChat.auth_key = authKey;
|
2014-10-17 20:29:13 +02:00
|
|
|
encryptedChat.seq_in = 0;
|
|
|
|
encryptedChat.seq_out = 1;
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().updateEncryptedChat(encryptedChat);
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putEncryptedChat(encryptedChat, false);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.encryptedChatUpdated, encryptedChat);
|
2014-10-22 22:01:07 +02:00
|
|
|
SendMessagesHelper.getInstance().sendNotifyLayerMessage(encryptedChat, null);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
final TLRPC.TL_encryptedChatDiscarded newChat = new TLRPC.TL_encryptedChatDiscarded();
|
|
|
|
newChat.id = encryptedChat.id;
|
|
|
|
newChat.user_id = encryptedChat.user_id;
|
|
|
|
newChat.auth_key = encryptedChat.auth_key;
|
2014-10-17 20:29:13 +02:00
|
|
|
newChat.seq_in = encryptedChat.seq_in;
|
|
|
|
newChat.seq_out = encryptedChat.seq_out;
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().updateEncryptedChat(newChat);
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putEncryptedChat(newChat, false);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.encryptedChatUpdated, newChat);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
declineSecretChat(encryptedChat.id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void declineSecretChat(int chat_id) {
|
|
|
|
TLRPC.TL_messages_discardEncryption req = new TLRPC.TL_messages_discardEncryption();
|
|
|
|
req.chat_id = chat_id;
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void acceptSecretChat(final TLRPC.EncryptedChat encryptedChat) {
|
|
|
|
if (acceptingChats.get(encryptedChat.id) != null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
acceptingChats.put(encryptedChat.id, encryptedChat);
|
|
|
|
TLRPC.TL_messages_getDhConfig req = new TLRPC.TL_messages_getDhConfig();
|
|
|
|
req.random_length = 256;
|
2013-11-04 13:31:01 +01:00
|
|
|
req.version = MessagesStorage.lastSecretVersion;
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
TLRPC.messages_DhConfig res = (TLRPC.messages_DhConfig) response;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (response instanceof TLRPC.TL_messages_dhConfig) {
|
2013-12-23 12:05:57 +01:00
|
|
|
if (!Utilities.isGoodPrime(res.p, res.g)) {
|
2013-12-23 00:47:35 +01:00
|
|
|
acceptingChats.remove(encryptedChat.id);
|
|
|
|
declineSecretChat(encryptedChat.id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.secretPBytes = res.p;
|
|
|
|
MessagesStorage.secretG = res.g;
|
|
|
|
MessagesStorage.lastSecretVersion = res.version;
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().saveSecretParams(MessagesStorage.lastSecretVersion, MessagesStorage.secretG, MessagesStorage.secretPBytes);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
byte[] salt = new byte[256];
|
|
|
|
for (int a = 0; a < 256; a++) {
|
2014-05-17 01:05:49 +02:00
|
|
|
salt[a] = (byte) ((byte) (Utilities.random.nextDouble() * 256) ^ res.random[a]);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
encryptedChat.a_or_b = salt;
|
2014-10-16 22:02:44 +02:00
|
|
|
encryptedChat.seq_in = 1;
|
|
|
|
encryptedChat.seq_out = 0;
|
2013-12-23 12:05:57 +01:00
|
|
|
BigInteger p = new BigInteger(1, MessagesStorage.secretPBytes);
|
|
|
|
BigInteger g_b = BigInteger.valueOf(MessagesStorage.secretG);
|
|
|
|
g_b = g_b.modPow(new BigInteger(1, salt), p);
|
|
|
|
BigInteger g_a = new BigInteger(1, encryptedChat.g_a);
|
|
|
|
|
2013-12-23 12:54:31 +01:00
|
|
|
if (!Utilities.isGoodGaAndGb(g_a, p)) {
|
2013-12-23 12:05:57 +01:00
|
|
|
acceptingChats.remove(encryptedChat.id);
|
|
|
|
declineSecretChat(encryptedChat.id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
byte[] g_b_bytes = g_b.toByteArray();
|
|
|
|
if (g_b_bytes.length > 256) {
|
2013-10-25 17:19:00 +02:00
|
|
|
byte[] correctedAuth = new byte[256];
|
2013-12-23 12:05:57 +01:00
|
|
|
System.arraycopy(g_b_bytes, 1, correctedAuth, 0, 256);
|
|
|
|
g_b_bytes = correctedAuth;
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2013-12-23 12:05:57 +01:00
|
|
|
g_a = g_a.modPow(new BigInteger(1, salt), p);
|
2013-10-25 17:19:00 +02:00
|
|
|
|
2013-12-23 12:05:57 +01:00
|
|
|
byte[] authKey = g_a.toByteArray();
|
2013-10-25 17:19:00 +02:00
|
|
|
if (authKey.length > 256) {
|
|
|
|
byte[] correctedAuth = new byte[256];
|
|
|
|
System.arraycopy(authKey, authKey.length - 256, correctedAuth, 0, 256);
|
|
|
|
authKey = correctedAuth;
|
|
|
|
} else if (authKey.length < 256) {
|
|
|
|
byte[] correctedAuth = new byte[256];
|
|
|
|
System.arraycopy(authKey, 0, correctedAuth, 256 - authKey.length, authKey.length);
|
|
|
|
for (int a = 0; a < 256 - authKey.length; a++) {
|
|
|
|
authKey[a] = 0;
|
|
|
|
}
|
|
|
|
authKey = correctedAuth;
|
|
|
|
}
|
|
|
|
byte[] authKeyHash = Utilities.computeSHA1(authKey);
|
|
|
|
byte[] authKeyId = new byte[8];
|
|
|
|
System.arraycopy(authKeyHash, authKeyHash.length - 8, authKeyId, 0, 8);
|
|
|
|
encryptedChat.auth_key = authKey;
|
|
|
|
|
|
|
|
TLRPC.TL_messages_acceptEncryption req2 = new TLRPC.TL_messages_acceptEncryption();
|
2013-12-23 12:05:57 +01:00
|
|
|
req2.g_b = g_b_bytes;
|
2013-10-25 17:19:00 +02:00
|
|
|
req2.peer = new TLRPC.TL_inputEncryptedChat();
|
|
|
|
req2.peer.chat_id = encryptedChat.id;
|
|
|
|
req2.peer.access_hash = encryptedChat.access_hash;
|
|
|
|
req2.key_fingerprint = Utilities.bytesToLong(authKeyId);
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req2, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
acceptingChats.remove(encryptedChat.id);
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
final TLRPC.EncryptedChat newChat = (TLRPC.EncryptedChat) response;
|
2013-10-25 17:19:00 +02:00
|
|
|
newChat.auth_key = encryptedChat.auth_key;
|
|
|
|
newChat.user_id = encryptedChat.user_id;
|
2014-10-17 20:29:13 +02:00
|
|
|
newChat.seq_in = encryptedChat.seq_in;
|
|
|
|
newChat.seq_out = encryptedChat.seq_out;
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().updateEncryptedChat(newChat);
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-08-22 16:24:33 +02:00
|
|
|
putEncryptedChat(newChat, false);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.encryptedChatUpdated, newChat);
|
2014-10-22 22:01:07 +02:00
|
|
|
SendMessagesHelper.getInstance().sendNotifyLayerMessage(newChat, null);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
|
|
|
acceptingChats.remove(encryptedChat.id);
|
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
|
2014-02-04 19:36:55 +01:00
|
|
|
public void startSecretChat(final Context context, final TLRPC.User user) {
|
|
|
|
if (user == null) {
|
|
|
|
return;
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
startingSecretChat = true;
|
2013-10-25 17:19:00 +02:00
|
|
|
final ProgressDialog progressDialog = new ProgressDialog(context);
|
2014-03-22 23:31:55 +01:00
|
|
|
progressDialog.setMessage(LocaleController.getString("Loading", R.string.Loading));
|
2013-10-25 17:19:00 +02:00
|
|
|
progressDialog.setCanceledOnTouchOutside(false);
|
|
|
|
progressDialog.setCancelable(false);
|
|
|
|
TLRPC.TL_messages_getDhConfig req = new TLRPC.TL_messages_getDhConfig();
|
|
|
|
req.random_length = 256;
|
2013-11-04 13:31:01 +01:00
|
|
|
req.version = MessagesStorage.lastSecretVersion;
|
2014-03-22 23:31:55 +01:00
|
|
|
final long reqId = ConnectionsManager.getInstance().performRpc(req, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-03-22 23:31:55 +01:00
|
|
|
TLRPC.messages_DhConfig res = (TLRPC.messages_DhConfig) response;
|
2013-10-25 17:19:00 +02:00
|
|
|
if (response instanceof TLRPC.TL_messages_dhConfig) {
|
2013-12-23 12:05:57 +01:00
|
|
|
if (!Utilities.isGoodPrime(res.p, res.g)) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-12-23 00:47:35 +01:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-02-04 19:36:55 +01:00
|
|
|
try {
|
2014-06-04 18:02:46 +02:00
|
|
|
if (!((Activity) context).isFinishing()) {
|
2014-02-04 19:36:55 +01:00
|
|
|
progressDialog.dismiss();
|
|
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
|
|
FileLog.e("tmessages", e);
|
2013-12-23 00:47:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
2013-11-04 13:31:01 +01:00
|
|
|
MessagesStorage.secretPBytes = res.p;
|
|
|
|
MessagesStorage.secretG = res.g;
|
|
|
|
MessagesStorage.lastSecretVersion = res.version;
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().saveSecretParams(MessagesStorage.lastSecretVersion, MessagesStorage.secretG, MessagesStorage.secretPBytes);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
final byte[] salt = new byte[256];
|
|
|
|
for (int a = 0; a < 256; a++) {
|
2014-05-17 01:05:49 +02:00
|
|
|
salt[a] = (byte) ((byte) (Utilities.random.nextDouble() * 256) ^ res.random[a]);
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2013-12-23 12:05:57 +01:00
|
|
|
|
2013-11-04 13:31:01 +01:00
|
|
|
BigInteger i_g_a = BigInteger.valueOf(MessagesStorage.secretG);
|
|
|
|
i_g_a = i_g_a.modPow(new BigInteger(1, salt), new BigInteger(1, MessagesStorage.secretPBytes));
|
2013-10-25 17:19:00 +02:00
|
|
|
byte[] g_a = i_g_a.toByteArray();
|
|
|
|
if (g_a.length > 256) {
|
|
|
|
byte[] correctedAuth = new byte[256];
|
|
|
|
System.arraycopy(g_a, 1, correctedAuth, 0, 256);
|
|
|
|
g_a = correctedAuth;
|
|
|
|
}
|
|
|
|
|
|
|
|
TLRPC.TL_messages_requestEncryption req2 = new TLRPC.TL_messages_requestEncryption();
|
|
|
|
req2.g_a = g_a;
|
2014-02-04 19:36:55 +01:00
|
|
|
req2.user_id = getInputUser(user);
|
2014-05-17 01:05:49 +02:00
|
|
|
req2.random_id = Utilities.random.nextInt();
|
2014-03-22 23:31:55 +01:00
|
|
|
ConnectionsManager.getInstance().performRpc(req2, new RPCRequest.RPCRequestDelegate() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run(final TLObject response, TLRPC.TL_error error) {
|
|
|
|
if (error == null) {
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-03-22 23:31:55 +01:00
|
|
|
startingSecretChat = false;
|
2014-06-04 18:02:46 +02:00
|
|
|
if (!((Activity) context).isFinishing()) {
|
2014-02-04 19:36:55 +01:00
|
|
|
try {
|
|
|
|
progressDialog.dismiss();
|
|
|
|
} catch (Exception e) {
|
|
|
|
FileLog.e("tmessages", e);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
TLRPC.EncryptedChat chat = (TLRPC.EncryptedChat) response;
|
2013-10-25 17:19:00 +02:00
|
|
|
chat.user_id = chat.participant_id;
|
2014-10-16 22:02:44 +02:00
|
|
|
chat.seq_in = 0;
|
|
|
|
chat.seq_out = 1;
|
2013-10-25 17:19:00 +02:00
|
|
|
chat.a_or_b = salt;
|
2014-10-16 22:02:44 +02:00
|
|
|
putEncryptedChat(chat, false);
|
2013-10-25 17:19:00 +02:00
|
|
|
TLRPC.TL_dialog dialog = new TLRPC.TL_dialog();
|
2014-03-22 23:31:55 +01:00
|
|
|
dialog.id = ((long) chat.id) << 32;
|
2013-10-25 17:19:00 +02:00
|
|
|
dialog.unread_count = 0;
|
|
|
|
dialog.top_message = 0;
|
2014-03-22 23:31:55 +01:00
|
|
|
dialog.last_message_date = ConnectionsManager.getInstance().getCurrentTime();
|
2013-10-25 17:19:00 +02:00
|
|
|
dialogs_dict.put(dialog.id, dialog);
|
|
|
|
dialogs.add(dialog);
|
|
|
|
dialogsServerOnly.clear();
|
|
|
|
Collections.sort(dialogs, new Comparator<TLRPC.TL_dialog>() {
|
|
|
|
@Override
|
|
|
|
public int compare(TLRPC.TL_dialog tl_dialog, TLRPC.TL_dialog tl_dialog2) {
|
|
|
|
if (tl_dialog.last_message_date == tl_dialog2.last_message_date) {
|
|
|
|
return 0;
|
|
|
|
} else if (tl_dialog.last_message_date < tl_dialog2.last_message_date) {
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
for (TLRPC.TL_dialog d : dialogs) {
|
2014-07-30 09:49:39 +02:00
|
|
|
int high_id = (int)(d.id >> 32);
|
|
|
|
if ((int)d.id != 0 && high_id != 1) {
|
2013-10-25 17:19:00 +02:00
|
|
|
dialogsServerOnly.add(d);
|
|
|
|
}
|
|
|
|
}
|
2014-03-22 23:31:55 +01:00
|
|
|
MessagesStorage.getInstance().putEncryptedChat(chat, user, dialog);
|
2014-08-22 16:24:33 +02:00
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.dialogsNeedReload);
|
|
|
|
NotificationCenter.getInstance().postNotificationName(NotificationCenter.encryptedChatCreated, chat);
|
2014-03-22 23:31:55 +01:00
|
|
|
Utilities.stageQueue.postRunnable(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
if (!delayedEncryptedChatUpdates.isEmpty()) {
|
|
|
|
processUpdateArray(delayedEncryptedChatUpdates, null, null);
|
|
|
|
delayedEncryptedChatUpdates.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
2014-03-22 23:31:55 +01:00
|
|
|
delayedEncryptedChatUpdates.clear();
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-06-04 18:02:46 +02:00
|
|
|
if (!((Activity) context).isFinishing()) {
|
2014-03-22 23:31:55 +01:00
|
|
|
startingSecretChat = false;
|
2014-02-04 19:36:55 +01:00
|
|
|
try {
|
|
|
|
progressDialog.dismiss();
|
|
|
|
} catch (Exception e) {
|
|
|
|
FileLog.e("tmessages", e);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(context);
|
2014-03-22 23:31:55 +01:00
|
|
|
builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
|
2014-10-22 12:11:47 +02:00
|
|
|
builder.setMessage(LocaleController.getString("CreateEncryptedChatError", R.string.CreateEncryptedChatError));
|
2014-03-22 23:31:55 +01:00
|
|
|
builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), null);
|
2013-10-25 17:19:00 +02:00
|
|
|
builder.show().setCanceledOnTouchOutside(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
}, true, RPCRequest.RPCRequestClassGeneric | RPCRequest.RPCRequestClassFailOnServerErrors);
|
2013-10-25 17:19:00 +02:00
|
|
|
} else {
|
2014-03-22 23:31:55 +01:00
|
|
|
delayedEncryptedChatUpdates.clear();
|
2014-08-22 16:24:33 +02:00
|
|
|
AndroidUtilities.RunOnUIThread(new Runnable() {
|
2013-10-25 17:19:00 +02:00
|
|
|
@Override
|
|
|
|
public void run() {
|
2014-03-22 23:31:55 +01:00
|
|
|
startingSecretChat = false;
|
2014-06-04 18:02:46 +02:00
|
|
|
if (!((Activity) context).isFinishing()) {
|
2014-02-04 19:36:55 +01:00
|
|
|
try {
|
|
|
|
progressDialog.dismiss();
|
|
|
|
} catch (Exception e) {
|
|
|
|
FileLog.e("tmessages", e);
|
|
|
|
}
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
2014-07-03 00:39:05 +02:00
|
|
|
}, true, RPCRequest.RPCRequestClassGeneric | RPCRequest.RPCRequestClassFailOnServerErrors);
|
2014-03-22 23:31:55 +01:00
|
|
|
progressDialog.setButton(DialogInterface.BUTTON_NEGATIVE, LocaleController.getString("Cancel", R.string.Cancel), new DialogInterface.OnClickListener() {
|
|
|
|
@Override
|
|
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
|
|
ConnectionsManager.getInstance().cancelRpc(reqId, true);
|
|
|
|
try {
|
|
|
|
dialog.dismiss();
|
|
|
|
} catch (Exception e) {
|
|
|
|
FileLog.e("tmessages", e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
progressDialog.show();
|
2013-10-25 17:19:00 +02:00
|
|
|
}
|
|
|
|
}
|