diff options
Diffstat (limited to 'protocols/Telegram/tdlib/td/example/java/org')
3 files changed, 893 insertions, 0 deletions
diff --git a/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Client.java b/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Client.java new file mode 100644 index 0000000000..efb38e9c5a --- /dev/null +++ b/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Client.java @@ -0,0 +1,285 @@ +// +// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018 +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +package org.drinkless.tdlib; + +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +/** + * Main class for interaction with the TDLib. + */ +public final class Client implements Runnable { + /** + * Interface for handler for results of queries to TDLib and incoming updates from TDLib. + */ + public interface ResultHandler { + /** + * Callback called on result of query to TDLib or incoming update from TDLib. + * + * @param object Result of query or update of type TdApi.Update about new events. + */ + void onResult(TdApi.Object object); + } + + /** + * Interface for handler of exceptions thrown while invoking ResultHandler. + * By default, all such exceptions are ignored. + * All exceptions thrown from ExceptionHandler are ignored. + */ + public interface ExceptionHandler { + /** + * Callback called on exceptions thrown while invoking ResultHandler. + * + * @param e Exception thrown by ResultHandler. + */ + void onException(Throwable e); + } + + /** + * Sends a request to the TDLib. + * + * @param query Object representing a query to the TDLib. + * @param resultHandler Result handler with onResult method which will be called with result + * of the query or with TdApi.Error as parameter. If it is null, nothing + * will be called. + * @param exceptionHandler Exception handler with onException method which will be called on + * exception thrown from resultHandler. If it is null, then + * defaultExceptionHandler will be called. + * @throws NullPointerException if query is null. + */ + public void send(TdApi.Function query, ResultHandler resultHandler, ExceptionHandler exceptionHandler) { + if (query == null) { + throw new NullPointerException("query is null"); + } + + readLock.lock(); + try { + if (isClientDestroyed) { + if (resultHandler != null) { + handleResult(new TdApi.Error(500, "Client is closed"), resultHandler, exceptionHandler); + } + return; + } + + long queryId = currentQueryId.incrementAndGet(); + handlers.put(queryId, new Handler(resultHandler, exceptionHandler)); + nativeClientSend(nativeClientId, queryId, query); + } finally { + readLock.unlock(); + } + } + + /** + * Sends a request to the TDLib with an empty ExceptionHandler. + * + * @param query Object representing a query to the TDLib. + * @param resultHandler Result handler with onResult method which will be called with result + * of the query or with TdApi.Error as parameter. If it is null, then + * defaultExceptionHandler will be called. + * @throws NullPointerException if query is null. + */ + public void send(TdApi.Function query, ResultHandler resultHandler) { + send(query, resultHandler, null); + } + + /** + * Synchronously executes a TDLib request. Only a few marked accordingly requests can be executed synchronously. + * + * @param query Object representing a query to the TDLib. + * @return request result. + * @throws NullPointerException if query is null. + */ + public static TdApi.Object execute(TdApi.Function query) { + if (query == null) { + throw new NullPointerException("query is null"); + } + return nativeClientExecute(query); + } + + /** + * Replaces handler for incoming updates from the TDLib. + * + * @param updatesHandler Handler with onResult method which will be called for every incoming + * update from the TDLib. + * @param exceptionHandler Exception handler with onException method which will be called on + * exception thrown from updatesHandler, if it is null, defaultExceptionHandler will be invoked. + */ + public void setUpdatesHandler(ResultHandler updatesHandler, ExceptionHandler exceptionHandler) { + handlers.put(0L, new Handler(updatesHandler, exceptionHandler)); + } + + /** + * Replaces handler for incoming updates from the TDLib. Sets empty ExceptionHandler. + * + * @param updatesHandler Handler with onResult method which will be called for every incoming + * update from the TDLib. + */ + public void setUpdatesHandler(ResultHandler updatesHandler) { + setUpdatesHandler(updatesHandler, null); + } + + /** + * Replaces default exception handler to be invoked on exceptions thrown from updatesHandler and all other ResultHandler. + * + * @param defaultExceptionHandler Default exception handler. If null Exceptions are ignored. + */ + public void setDefaultExceptionHandler(Client.ExceptionHandler defaultExceptionHandler) { + this.defaultExceptionHandler = defaultExceptionHandler; + } + + /** + * Overridden method from Runnable, do not call it directly. + */ + @Override + public void run() { + while (!stopFlag) { + receiveQueries(300.0 /*seconds*/); + } + } + + /** + * Creates new Client. + * + * @param updatesHandler Handler for incoming updates. + * @param updatesExceptionHandler Handler for exceptions thrown from updatesHandler. If it is null, exceptions will be iggnored. + * @param defaultExceptionHandler Default handler for exceptions thrown from all ResultHandler. If it is null, exceptions will be iggnored. + * @return created Client + */ + public static Client create(ResultHandler updatesHandler, ExceptionHandler updatesExceptionHandler, ExceptionHandler defaultExceptionHandler) { + Client client = new Client(updatesHandler, updatesExceptionHandler, defaultExceptionHandler); + new Thread(client, "TDLib thread").start(); + return client; + } + + /** + * Closes Client. + */ + public void close() { + writeLock.lock(); + try { + if (isClientDestroyed) { + return; + } + if (!stopFlag) { + send(new TdApi.Close(), null); + } + isClientDestroyed = true; + while (!stopFlag) { + Thread.yield(); + } + while (handlers.size() != 1) { + receiveQueries(300.0); + } + destroyNativeClient(nativeClientId); + } finally { + writeLock.unlock(); + } + } + + private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); + private final Lock readLock = readWriteLock.readLock(); + private final Lock writeLock = readWriteLock.writeLock(); + + private volatile boolean stopFlag = false; + private volatile boolean isClientDestroyed = false; + private final long nativeClientId; + + private final ConcurrentHashMap<Long, Handler> handlers = new ConcurrentHashMap<Long, Handler>(); + private final AtomicLong currentQueryId = new AtomicLong(); + + private volatile ExceptionHandler defaultExceptionHandler = null; + + private static final int MAX_EVENTS = 1000; + private final long[] eventIds = new long[MAX_EVENTS]; + private final TdApi.Object[] events = new TdApi.Object[MAX_EVENTS]; + + private static class Handler { + final ResultHandler resultHandler; + final ExceptionHandler exceptionHandler; + + Handler(ResultHandler resultHandler, ExceptionHandler exceptionHandler) { + this.resultHandler = resultHandler; + this.exceptionHandler = exceptionHandler; + } + } + + private Client(ResultHandler updatesHandler, ExceptionHandler updateExceptionHandler, ExceptionHandler defaultExceptionHandler) { + nativeClientId = createNativeClient(); + handlers.put(0L, new Handler(updatesHandler, updateExceptionHandler)); + this.defaultExceptionHandler = defaultExceptionHandler; + } + + @Override + protected void finalize() throws Throwable { + try { + close(); + } finally { + super.finalize(); + } + } + + private void processResult(long id, TdApi.Object object) { + if (object instanceof TdApi.UpdateAuthorizationState) { + if (((TdApi.UpdateAuthorizationState) object).authorizationState instanceof TdApi.AuthorizationStateClosed) { + stopFlag = true; + } + } + Handler handler; + if (id == 0) { + // update handler stays forever + handler = handlers.get(id); + } else { + handler = handlers.remove(id); + } + if (handler == null) { + return; + } + + handleResult(object, handler.resultHandler, handler.exceptionHandler); + } + + private void handleResult(TdApi.Object object, ResultHandler resultHandler, ExceptionHandler exceptionHandler) { + if (resultHandler == null) { + return; + } + + try { + resultHandler.onResult(object); + } catch (Throwable cause) { + if (exceptionHandler == null) { + exceptionHandler = defaultExceptionHandler; + } + if (exceptionHandler != null) { + try { + exceptionHandler.onException(cause); + } catch (Throwable ignored) { + } + } + } + } + + private void receiveQueries(double timeout) { + int resultN = nativeClientReceive(nativeClientId, eventIds, events, timeout); + for (int i = 0; i < resultN; i++) { + processResult(eventIds[i], events[i]); + events[i] = null; + } + } + + private static native long createNativeClient(); + + private static native void nativeClientSend(long nativeClientId, long eventId, TdApi.Function function); + + private static native int nativeClientReceive(long nativeClientId, long[] eventIds, TdApi.Object[] events, double timeout); + + private static native TdApi.Object nativeClientExecute(TdApi.Function function); + + private static native void destroyNativeClient(long nativeClientId); +} diff --git a/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Log.java b/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Log.java new file mode 100644 index 0000000000..c81ffbeeb7 --- /dev/null +++ b/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Log.java @@ -0,0 +1,75 @@ +// +// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018 +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +package org.drinkless.tdlib; + +/** + * Class for managing internal TDLib logging. + */ +public final class Log { + /** + * Changes TDLib log verbosity. + * + * @param verbosityLevel New value of log verbosity level. Must be non-negative. + * Value 0 corresponds to fatal errors, + * value 1 corresponds to java.util.logging.Level.SEVERE, + * value 2 corresponds to java.util.logging.Level.WARNING, + * value 3 corresponds to java.util.logging.Level.INFO, + * value 4 corresponds to java.util.logging.Level.FINE, + * value 5 corresponds to java.util.logging.Level.FINER, + * value greater than 5 can be used to enable even more logging. + * Default value of the log verbosity level is 5. + */ + public static native void setVerbosityLevel(int verbosityLevel); + + /** + * Sets file path for writing TDLib internal log. By default TDLib writes logs to the System.err. + * Use this method to write the log to a file instead. + * + * @param filePath Path to a file for writing TDLib internal log. Use an empty path to + * switch back to logging to the System.err. + * @return whether opening the log file succeeded. + */ + public static native boolean setFilePath(String filePath); + + /** + * Changes maximum size of TDLib log file. + * + * @param maxFileSize Maximum size of the file to where the internal TDLib log is written + * before the file will be auto-rotated. Must be positive. Defaults to 10 MB. + */ + public static native void setMaxFileSize(long maxFileSize); + + /** + * This function is called from the JNI when a fatal error happens to provide a better error message. + * The function does not return. + * + * @param errorMessage Error message. + */ + private static void onFatalError(String errorMessage) { + class ThrowError implements Runnable { + private ThrowError(String errorMessage) { + this.errorMessage = errorMessage; + } + + @Override + public void run() { + throw new RuntimeException("TDLib fatal error: " + errorMessage); + } + + private final String errorMessage; + } + + new Thread(new ThrowError(errorMessage), "TDLib fatal error thread").start(); + while (true) { + try { + Thread.sleep(1000); // milliseconds + } catch (InterruptedException ex) { + Thread.currentThread().interrupt(); + } + } + } +} diff --git a/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/example/Example.java b/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/example/Example.java new file mode 100644 index 0000000000..831de88f1d --- /dev/null +++ b/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/example/Example.java @@ -0,0 +1,533 @@ +// +// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018 +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// +package org.drinkless.tdlib.example; + +import org.drinkless.tdlib.Client; +import org.drinkless.tdlib.Log; +import org.drinkless.tdlib.TdApi; + +import java.io.IOError; +import java.io.IOException; +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.util.NavigableSet; +import java.util.TreeSet; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +/** + * Example class for TDLib usage from Java. + */ +public final class Example { + private static Client client = null; + + private static TdApi.AuthorizationState authorizationState = null; + private static volatile boolean haveAuthorization = false; + private static volatile boolean quiting = false; + + private static final Client.ResultHandler defaultHandler = new DefaultHandler(); + + private static final Lock authorizationLock = new ReentrantLock(); + private static final Condition gotAuthorization = authorizationLock.newCondition(); + + private static final ConcurrentMap<Integer, TdApi.User> users = new ConcurrentHashMap<Integer, TdApi.User>(); + private static final ConcurrentMap<Integer, TdApi.BasicGroup> basicGroups = new ConcurrentHashMap<Integer, TdApi.BasicGroup>(); + private static final ConcurrentMap<Integer, TdApi.Supergroup> supergroups = new ConcurrentHashMap<Integer, TdApi.Supergroup>(); + private static final ConcurrentMap<Integer, TdApi.SecretChat> secretChats = new ConcurrentHashMap<Integer, TdApi.SecretChat>(); + + private static final ConcurrentMap<Long, TdApi.Chat> chats = new ConcurrentHashMap<Long, TdApi.Chat>(); + private static final NavigableSet<OrderedChat> chatList = new TreeSet<OrderedChat>(); + private static boolean haveFullChatList = false; + + private static final ConcurrentMap<Integer, TdApi.UserFullInfo> usersFullInfo = new ConcurrentHashMap<Integer, TdApi.UserFullInfo>(); + private static final ConcurrentMap<Integer, TdApi.BasicGroupFullInfo> basicGroupsFullInfo = new ConcurrentHashMap<Integer, TdApi.BasicGroupFullInfo>(); + private static final ConcurrentMap<Integer, TdApi.SupergroupFullInfo> supergroupsFullInfo = new ConcurrentHashMap<Integer, TdApi.SupergroupFullInfo>(); + + private static final String newLine = System.getProperty("line.separator"); + private static final String commandsLine = "Enter command (gcs - GetChats, gc <chatId> - GetChat, me - GetMe, sm <chatId> <message> - SendMessage, lo - LogOut, q - Quit): "; + private static volatile String currentPrompt = null; + + static { + System.loadLibrary("tdjni"); + } + + private static void print(String str) { + if (currentPrompt != null) { + System.out.println(""); + } + System.out.println(str); + if (currentPrompt != null) { + System.out.print(currentPrompt); + } + } + + private static void setChatOrder(TdApi.Chat chat, long order) { + synchronized (chatList) { + if (chat.order != 0) { + boolean isRemoved = chatList.remove(new OrderedChat(chat.order, chat.id)); + assert isRemoved; + } + + chat.order = order; + + if (chat.order != 0) { + boolean isAdded = chatList.add(new OrderedChat(chat.order, chat.id)); + assert isAdded; + } + } + } + + private static void onAuthorizationStateUpdated(TdApi.AuthorizationState authorizationState) { + if (authorizationState != null) { + Example.authorizationState = authorizationState; + } + switch (Example.authorizationState.getConstructor()) { + case TdApi.AuthorizationStateWaitTdlibParameters.CONSTRUCTOR: + TdApi.TdlibParameters parameters = new TdApi.TdlibParameters(); + parameters.databaseDirectory = "tdlib"; + parameters.useMessageDatabase = true; + parameters.useSecretChats = true; + parameters.apiId = 94575; + parameters.apiHash = "a3406de8d171bb422bb6ddf3bbd800e2"; + parameters.systemLanguageCode = "en"; + parameters.deviceModel = "Desktop"; + parameters.systemVersion = "Unknown"; + parameters.applicationVersion = "1.0"; + parameters.enableStorageOptimizer = true; + + client.send(new TdApi.SetTdlibParameters(parameters), new AuthorizationRequestHandler()); + break; + case TdApi.AuthorizationStateWaitEncryptionKey.CONSTRUCTOR: + client.send(new TdApi.CheckDatabaseEncryptionKey(), new AuthorizationRequestHandler()); + break; + case TdApi.AuthorizationStateWaitPhoneNumber.CONSTRUCTOR: { + String phoneNumber = promptString("Please enter phone number: "); + client.send(new TdApi.SetAuthenticationPhoneNumber(phoneNumber, false, false), new AuthorizationRequestHandler()); + break; + } + case TdApi.AuthorizationStateWaitCode.CONSTRUCTOR: { + String code = promptString("Please enter authentication code: "); + client.send(new TdApi.CheckAuthenticationCode(code, "", ""), new AuthorizationRequestHandler()); + break; + } + case TdApi.AuthorizationStateWaitPassword.CONSTRUCTOR: { + String password = promptString("Please enter password: "); + client.send(new TdApi.CheckAuthenticationPassword(password), new AuthorizationRequestHandler()); + break; + } + case TdApi.AuthorizationStateReady.CONSTRUCTOR: + haveAuthorization = true; + authorizationLock.lock(); + try { + gotAuthorization.signal(); + } finally { + authorizationLock.unlock(); + } + break; + case TdApi.AuthorizationStateLoggingOut.CONSTRUCTOR: + haveAuthorization = false; + print("Logging out"); + break; + case TdApi.AuthorizationStateClosing.CONSTRUCTOR: + haveAuthorization = false; + print("Closing"); + break; + case TdApi.AuthorizationStateClosed.CONSTRUCTOR: + print("Closed"); + if (!quiting) { + client = Client.create(new UpdatesHandler(), null, null); // recreate client after previous has closed + } + break; + default: + System.err.println("Unsupported authorization state:" + newLine + Example.authorizationState); + } + } + + private static int toInt(String arg) { + int result = 0; + try { + result = Integer.parseInt(arg); + } catch (NumberFormatException ignored) { + } + return result; + } + + private static long getChatId(String arg) { + long chatId = 0; + try { + chatId = Long.parseLong(arg); + } catch (NumberFormatException ignored) { + } + return chatId; + } + + private static String promptString(String prompt) { + System.out.print(prompt); + currentPrompt = prompt; + BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); + String str = ""; + try { + str = reader.readLine(); + } catch (IOException e) { + e.printStackTrace(); + } + currentPrompt = null; + return str; + } + + private static void getCommand() { + String command = promptString(commandsLine); + String[] commands = command.split(" ", 2); + try { + switch (commands[0]) { + case "gcs": { + int limit = 20; + if (commands.length > 1) { + limit = toInt(commands[1]); + } + getChatList(limit); + break; + } + case "gc": + client.send(new TdApi.GetChat(getChatId(commands[1])), defaultHandler); + break; + case "me": + client.send(new TdApi.GetMe(), defaultHandler); + break; + case "sm": { + String[] args = commands[1].split(" ", 2); + sendMessage(getChatId(args[0]), args[1]); + break; + } + case "lo": + haveAuthorization = false; + client.send(new TdApi.LogOut(), defaultHandler); + break; + case "q": + quiting = true; + haveAuthorization = false; + client.send(new TdApi.Close(), defaultHandler); + break; + default: + System.err.println("Unsupported command: " + command); + } + } catch (ArrayIndexOutOfBoundsException e) { + print("Not enough arguments"); + } + } + + private static void getChatList(final int limit) { + synchronized (chatList) { + if (!haveFullChatList && limit > chatList.size()) { + // have enough chats in the chat list or chat list is too small + long offsetOrder = Long.MAX_VALUE; + long offsetChatId = 0; + if (!chatList.isEmpty()) { + OrderedChat last = chatList.last(); + offsetOrder = last.order; + offsetChatId = last.chatId; + } + client.send(new TdApi.GetChats(offsetOrder, offsetChatId, limit - chatList.size()), new Client.ResultHandler() { + @Override + public void onResult(TdApi.Object object) { + switch (object.getConstructor()) { + case TdApi.Error.CONSTRUCTOR: + System.err.println("Receive an error for GetChats:" + newLine + object); + break; + case TdApi.Chats.CONSTRUCTOR: + long[] chatIds = ((TdApi.Chats) object).chatIds; + if (chatIds.length == 0) { + synchronized (chatList) { + haveFullChatList = true; + } + } + // chats had already been received through updates, let's retry request + getChatList(limit); + break; + default: + System.err.println("Receive wrong response from TDLib:" + newLine + object); + } + } + }); + return; + } + + // have enough chats in the chat list to answer request + java.util.Iterator<OrderedChat> iter = chatList.iterator(); + System.out.println(); + System.out.println("First " + limit + " chat(s) out of " + chatList.size() + " known chat(s):"); + for (int i = 0; i < limit; i++) { + long chatId = iter.next().chatId; + TdApi.Chat chat = chats.get(chatId); + synchronized (chat) { + System.out.println(chatId + ": " + chat.title); + } + } + print(""); + } + } + + private static void sendMessage(long chatId, String message) { + // initialize reply markup just for testing + TdApi.InlineKeyboardButton[] row = {new TdApi.InlineKeyboardButton("https://telegram.org?1", new TdApi.InlineKeyboardButtonTypeUrl()), new TdApi.InlineKeyboardButton("https://telegram.org?2", new TdApi.InlineKeyboardButtonTypeUrl()), new TdApi.InlineKeyboardButton("https://telegram.org?3", new TdApi.InlineKeyboardButtonTypeUrl())}; + TdApi.ReplyMarkup replyMarkup = new TdApi.ReplyMarkupInlineKeyboard(new TdApi.InlineKeyboardButton[][]{row, row, row}); + + TdApi.InputMessageContent content = new TdApi.InputMessageText(new TdApi.FormattedText(message, null), false, true); + client.send(new TdApi.SendMessage(chatId, 0, false, false, replyMarkup, content), defaultHandler); + } + + public static void main(String[] args) throws InterruptedException { + // disable TDLib log + Log.setVerbosityLevel(0); + if (!Log.setFilePath("tdlib.log")) { + throw new IOError(new IOException("Write access to the current directory is required")); + } + + // create client + client = Client.create(new UpdatesHandler(), null, null); + + // test Client.execute + defaultHandler.onResult(Client.execute(new TdApi.GetTextEntities("@telegram /test_command https://telegram.org telegram.me @gif @test"))); + + // main loop + while (!quiting) { + // await authorization + authorizationLock.lock(); + try { + while (!haveAuthorization) { + gotAuthorization.await(); + } + } finally { + authorizationLock.unlock(); + } + + while (haveAuthorization) { + getCommand(); + } + } + } + + private static class OrderedChat implements Comparable<OrderedChat> { + final long order; + final long chatId; + + OrderedChat(long order, long chatId) { + this.order = order; + this.chatId = chatId; + } + + @Override + public int compareTo(OrderedChat o) { + if (this.order != o.order) { + return o.order < this.order ? -1 : 1; + } + if (this.chatId != o.chatId) { + return o.chatId < this.chatId ? -1 : 1; + } + return 0; + } + + @Override + public boolean equals(Object obj) { + OrderedChat o = (OrderedChat) obj; + return this.order == o.order && this.chatId == o.chatId; + } + } + + private static class DefaultHandler implements Client.ResultHandler { + @Override + public void onResult(TdApi.Object object) { + print(object.toString()); + } + } + + private static class UpdatesHandler implements Client.ResultHandler { + @Override + public void onResult(TdApi.Object object) { + switch (object.getConstructor()) { + case TdApi.UpdateAuthorizationState.CONSTRUCTOR: + onAuthorizationStateUpdated(((TdApi.UpdateAuthorizationState) object).authorizationState); + break; + + case TdApi.UpdateUser.CONSTRUCTOR: + TdApi.UpdateUser updateUser = (TdApi.UpdateUser) object; + users.put(updateUser.user.id, updateUser.user); + break; + case TdApi.UpdateUserStatus.CONSTRUCTOR: { + TdApi.UpdateUserStatus updateUserStatus = (TdApi.UpdateUserStatus) object; + TdApi.User user = users.get(updateUserStatus.userId); + synchronized (user) { + user.status = updateUserStatus.status; + } + break; + } + case TdApi.UpdateBasicGroup.CONSTRUCTOR: + TdApi.UpdateBasicGroup updateBasicGroup = (TdApi.UpdateBasicGroup) object; + basicGroups.put(updateBasicGroup.basicGroup.id, updateBasicGroup.basicGroup); + break; + case TdApi.UpdateSupergroup.CONSTRUCTOR: + TdApi.UpdateSupergroup updateSupergroup = (TdApi.UpdateSupergroup) object; + supergroups.put(updateSupergroup.supergroup.id, updateSupergroup.supergroup); + break; + case TdApi.UpdateSecretChat.CONSTRUCTOR: + TdApi.UpdateSecretChat updateSecretChat = (TdApi.UpdateSecretChat) object; + secretChats.put(updateSecretChat.secretChat.id, updateSecretChat.secretChat); + break; + + case TdApi.UpdateNewChat.CONSTRUCTOR: { + TdApi.UpdateNewChat updateNewChat = (TdApi.UpdateNewChat) object; + TdApi.Chat chat = updateNewChat.chat; + synchronized (chat) { + chats.put(chat.id, chat); + + long order = chat.order; + chat.order = 0; + setChatOrder(chat, order); + } + break; + } + case TdApi.UpdateChatTitle.CONSTRUCTOR: { + TdApi.UpdateChatTitle updateChat = (TdApi.UpdateChatTitle) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.title = updateChat.title; + } + break; + } + case TdApi.UpdateChatPhoto.CONSTRUCTOR: { + TdApi.UpdateChatPhoto updateChat = (TdApi.UpdateChatPhoto) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.photo = updateChat.photo; + } + break; + } + case TdApi.UpdateChatLastMessage.CONSTRUCTOR: { + TdApi.UpdateChatLastMessage updateChat = (TdApi.UpdateChatLastMessage) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.lastMessage = updateChat.lastMessage; + setChatOrder(chat, updateChat.order); + } + break; + } + case TdApi.UpdateChatOrder.CONSTRUCTOR: { + TdApi.UpdateChatOrder updateChat = (TdApi.UpdateChatOrder) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + setChatOrder(chat, updateChat.order); + } + break; + } + case TdApi.UpdateChatIsPinned.CONSTRUCTOR: { + TdApi.UpdateChatIsPinned updateChat = (TdApi.UpdateChatIsPinned) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.isPinned = updateChat.isPinned; + setChatOrder(chat, updateChat.order); + } + break; + } + case TdApi.UpdateChatReadInbox.CONSTRUCTOR: { + TdApi.UpdateChatReadInbox updateChat = (TdApi.UpdateChatReadInbox) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.lastReadInboxMessageId = updateChat.lastReadInboxMessageId; + chat.unreadCount = updateChat.unreadCount; + } + break; + } + case TdApi.UpdateChatReadOutbox.CONSTRUCTOR: { + TdApi.UpdateChatReadOutbox updateChat = (TdApi.UpdateChatReadOutbox) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.lastReadOutboxMessageId = updateChat.lastReadOutboxMessageId; + } + break; + } + case TdApi.UpdateChatUnreadMentionCount.CONSTRUCTOR: { + TdApi.UpdateChatUnreadMentionCount updateChat = (TdApi.UpdateChatUnreadMentionCount) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.unreadMentionCount = updateChat.unreadMentionCount; + } + break; + } + case TdApi.UpdateMessageMentionRead.CONSTRUCTOR: { + TdApi.UpdateMessageMentionRead updateChat = (TdApi.UpdateMessageMentionRead) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.unreadMentionCount = updateChat.unreadMentionCount; + } + break; + } + case TdApi.UpdateChatReplyMarkup.CONSTRUCTOR: { + TdApi.UpdateChatReplyMarkup updateChat = (TdApi.UpdateChatReplyMarkup) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.replyMarkupMessageId = updateChat.replyMarkupMessageId; + } + break; + } + case TdApi.UpdateChatDraftMessage.CONSTRUCTOR: { + TdApi.UpdateChatDraftMessage updateChat = (TdApi.UpdateChatDraftMessage) object; + TdApi.Chat chat = chats.get(updateChat.chatId); + synchronized (chat) { + chat.draftMessage = updateChat.draftMessage; + setChatOrder(chat, updateChat.order); + } + break; + } + case TdApi.UpdateNotificationSettings.CONSTRUCTOR: { + TdApi.UpdateNotificationSettings update = (TdApi.UpdateNotificationSettings) object; + if (update.scope instanceof TdApi.NotificationSettingsScopeChat) { + TdApi.Chat chat = chats.get(((TdApi.NotificationSettingsScopeChat) update.scope).chatId); + synchronized (chat) { + chat.notificationSettings = update.notificationSettings; + } + } + break; + } + + case TdApi.UpdateUserFullInfo.CONSTRUCTOR: + TdApi.UpdateUserFullInfo updateUserFullInfo = (TdApi.UpdateUserFullInfo) object; + usersFullInfo.put(updateUserFullInfo.userId, updateUserFullInfo.userFullInfo); + break; + case TdApi.UpdateBasicGroupFullInfo.CONSTRUCTOR: + TdApi.UpdateBasicGroupFullInfo updateBasicGroupFullInfo = (TdApi.UpdateBasicGroupFullInfo) object; + basicGroupsFullInfo.put(updateBasicGroupFullInfo.basicGroupId, updateBasicGroupFullInfo.basicGroupFullInfo); + break; + case TdApi.UpdateSupergroupFullInfo.CONSTRUCTOR: + TdApi.UpdateSupergroupFullInfo updateSupergroupFullInfo = (TdApi.UpdateSupergroupFullInfo) object; + supergroupsFullInfo.put(updateSupergroupFullInfo.supergroupId, updateSupergroupFullInfo.supergroupFullInfo); + break; + default: + // print("Unsupported update:" + newLine + object); + } + } + } + + private static class AuthorizationRequestHandler implements Client.ResultHandler { + @Override + public void onResult(TdApi.Object object) { + switch (object.getConstructor()) { + case TdApi.Error.CONSTRUCTOR: + System.err.println("Receive an error:" + newLine + object); + onAuthorizationStateUpdated(null); // repeat last action + break; + case TdApi.Ok.CONSTRUCTOR: + // result is already received through UpdateAuthorizationState, nothing to do + break; + default: + System.err.println("Receive wrong response from TDLib:" + newLine + object); + } + } + } +}
\ No newline at end of file |