diff options
Diffstat (limited to 'protocols/Telegram/tdlib/td/example/java')
6 files changed, 527 insertions, 409 deletions
diff --git a/protocols/Telegram/tdlib/td/example/java/CMakeLists.txt b/protocols/Telegram/tdlib/td/example/java/CMakeLists.txt index e8313a68b7..576eee2cfc 100644 --- a/protocols/Telegram/tdlib/td/example/java/CMakeLists.txt +++ b/protocols/Telegram/tdlib/td/example/java/CMakeLists.txt @@ -1,7 +1,26 @@ -cmake_minimum_required(VERSION 3.1 FATAL_ERROR) +cmake_minimum_required(VERSION 3.0.2 FATAL_ERROR) + +if (POLICY CMP0065) + # do not export symbols from executables + # affects compiler checks in project(), so must be set before it + cmake_policy(SET CMP0065 NEW) +endif() project(TdJavaExample VERSION 1.0 LANGUAGES CXX) +if (POLICY CMP0054) + # do not expand quoted arguments + cmake_policy(SET CMP0054 NEW) +endif() +if (POLICY CMP0060) + # link libraries by full path + cmake_policy(SET CMP0060 NEW) +endif() +if (POLICY CMP0074) + # use environment variables to find libraries + cmake_policy(SET CMP0074 NEW) +endif() + find_package(Td REQUIRED) if (NOT JNI_FOUND) @@ -10,12 +29,15 @@ endif() message(STATUS "Found JNI: ${JNI_INCLUDE_DIRS} ${JNI_LIBRARIES}") if (NOT Java_FOUND) - find_package(Java 1.6 REQUIRED) + find_package(Java REQUIRED) endif() message(STATUS "Found Java: ${Java_JAVAC_EXECUTABLE} ${Java_JAVADOC_EXECUTABLE}") # Generating TdApi.java find_program(PHP_EXECUTABLE php) +if ((CMAKE_SYSTEM_NAME MATCHES "FreeBSD") AND (CMAKE_SYSTEM_VERSION MATCHES "HBSD")) + set(PHP_EXECUTABLE "PHP_EXECUTABLE-NOTFOUND") +endif() set(TD_API_JAVA_PACKAGE "org/drinkless/tdlib") set(TD_API_JAVA_PATH ${CMAKE_CURRENT_SOURCE_DIR}) @@ -37,14 +59,13 @@ set(JAVA_SOURCE_PATH "${TD_API_JAVA_PATH}/${TD_API_JAVA_PACKAGE}") get_filename_component(JAVA_OUTPUT_DIRECTORY ${CMAKE_INSTALL_PREFIX}/bin REALPATH BASE_DIR "${CMAKE_CURRENT_BINARY_DIR}") file(MAKE_DIRECTORY ${JAVA_OUTPUT_DIRECTORY}) add_custom_target(build_java - COMMAND ${Java_JAVAC_EXECUTABLE} -d ${JAVA_OUTPUT_DIRECTORY} ${JAVA_SOURCE_PATH}/example/Example.java ${JAVA_SOURCE_PATH}/Client.java ${JAVA_SOURCE_PATH}/Log.java ${JAVA_SOURCE_PATH}/TdApi.java + COMMAND ${Java_JAVAC_EXECUTABLE} -encoding UTF-8 -d ${JAVA_OUTPUT_DIRECTORY} ${JAVA_SOURCE_PATH}/example/Example.java ${JAVA_SOURCE_PATH}/Client.java ${JAVA_SOURCE_PATH}/TdApi.java COMMENT "Building Java code" DEPENDS td_generate_java_api ) -set(JAVA_SOURCE_PATH "${TD_API_JAVA_PATH}/${TD_API_JAVA_PACKAGE}") add_custom_target(generate_javadoc - COMMAND ${Java_JAVADOC_EXECUTABLE} -d ${JAVA_OUTPUT_DIRECTORY}/../docs org.drinkless.tdlib + COMMAND ${Java_JAVADOC_EXECUTABLE} -encoding UTF-8 -charset UTF-8 -d ${JAVA_OUTPUT_DIRECTORY}/../docs org.drinkless.tdlib WORKING_DIRECTORY ${TD_API_JAVA_PATH} COMMENT "Generating Javadoc documentation" DEPENDS td_generate_java_api @@ -58,7 +79,39 @@ target_include_directories(tdjni PRIVATE ${JAVA_INCLUDE_PATH} ${JAVA_INCLUDE_PAT target_link_libraries(tdjni PRIVATE Td::TdStatic ${JAVA_JVM_LIBRARY}) target_compile_definitions(tdjni PRIVATE PACKAGE_NAME="${TD_API_JAVA_PACKAGE}") -set_property(TARGET tdjni PROPERTY CXX_STANDARD 14) +if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + set(GCC 1) +elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set(CLANG 1) +elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel") + set(INTEL 1) +elseif (NOT MSVC) + message(FATAL_ERROR "Compiler isn't supported") +endif() + +include(CheckCXXCompilerFlag) + +if (GCC OR CLANG OR INTEL) + if (WIN32 AND INTEL) + set(STD14_FLAG /Qstd=c++14) + else() + set(STD14_FLAG -std=c++14) + endif() + check_cxx_compiler_flag(${STD14_FLAG} HAVE_STD14) + if (NOT HAVE_STD14) + string(REPLACE "c++14" "c++1y" STD14_FLAG "${STD14_FLAG}") + check_cxx_compiler_flag(${STD14_FLAG} HAVE_STD1Y) + set(HAVE_STD14 ${HAVE_STD1Y}) + endif() + + target_compile_options(tdjni PRIVATE "${STD14_FLAG}") +elseif (MSVC) + set(HAVE_STD14 MSVC_VERSION>=1900) +endif() + +if (NOT HAVE_STD14) + message(FATAL_ERROR "No C++14 support in the compiler. Please upgrade the compiler.") +endif() add_dependencies(tdjni td_generate_java_api build_java generate_javadoc) @@ -66,3 +119,6 @@ install(TARGETS tdjni LIBRARY DESTINATION bin RUNTIME DESTINATION bin ) +if (MSVC AND VCPKG_TOOLCHAIN) + install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/" DESTINATION bin FILES_MATCHING PATTERN "*.dll" PATTERN "*.pdb") +endif() diff --git a/protocols/Telegram/tdlib/td/example/java/README.md b/protocols/Telegram/tdlib/td/example/java/README.md index c2b5c43171..4c7df1916d 100644 --- a/protocols/Telegram/tdlib/td/example/java/README.md +++ b/protocols/Telegram/tdlib/td/example/java/README.md @@ -3,7 +3,11 @@ To run this example, you will need installed JDK >= 1.6. For Javadoc documentation generation PHP is needed. -TDLib should be prebuilt for using with Java and installed to local subdirectory `td/` as follows: +You can find complete build instructions for your operating system at https://tdlib.github.io/td/build.html?language=Java. + +In general, the build process looks as follows. + +TDLib should be prebuilt with JNI bindings and installed to local subdirectory `td/` as follows: ``` cd <path to TDLib sources> mkdir jnibuild @@ -11,9 +15,9 @@ cd jnibuild cmake -DCMAKE_BUILD_TYPE=Release -DTD_ENABLE_JNI=ON -DCMAKE_INSTALL_PREFIX:PATH=../example/java/td .. cmake --build . --target install ``` -If you want to compile TDLib for 64-bit Java on Windows using MSVC, you will also need to add `-A x64` option to CMake. +If you want to compile TDLib for 32-bit/64-bit Java on Windows using MSVC, you will also need to add `-A Win32`/`-A x64` option to CMake. -In Windows, use Vcpkg toolchain file by adding parameter -DCMAKE_TOOLCHAIN_FILE=<VCPKG_DIR>/scripts/buildsystems/vcpkg.cmake +In Windows, use vcpkg toolchain file by adding parameter -DCMAKE_TOOLCHAIN_FILE=<VCPKG_DIR>/scripts/buildsystems/vcpkg.cmake Then you can build this example: ``` @@ -32,8 +36,8 @@ cd <path to TDLib sources>/example/java/bin java '-Djava.library.path=.' org/drinkless/tdlib/example/Example ``` -If you get "Could NOT find JNI ..." error from CMake, you need to specify to CMake path to the installed JDK, for example, "-DJAVA_HOME=/usr/lib/jvm/java-8-oracle/". +If you receive "Could NOT find JNI ..." error from CMake, you need to specify to CMake path to the installed JDK, for example, "-DJAVA_HOME=/usr/lib/jvm/java-8-oracle/". -If you get java.lang.UnsatisfiedLinkError with "Can't find dependent libraries", you may also need to copy some dependent shared libraries to `bin/`. +If you receive java.lang.UnsatisfiedLinkError with "Can't find dependent libraries", you may also need to copy some dependent shared OpenSSL and zlib libraries to `bin/`. -In case you compiled the example as 32-bit version, you may need to give -d32 parameter to Java. +Make sure that you compiled the example for the same architecture as your JVM. 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 index efb38e9c5a..0a58bb45a7 100644 --- a/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Client.java +++ b/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Client.java @@ -1,5 +1,5 @@ // -// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018 +// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2022 // // 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) @@ -8,14 +8,19 @@ 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 { +public final class Client { + static { + try { + System.loadLibrary("tdjni"); + } catch (UnsatisfiedLinkError e) { + e.printStackTrace(); + } + } + /** * Interface for handler for results of queries to TDLib and incoming updates from TDLib. */ @@ -43,6 +48,21 @@ public final class Client implements Runnable { } /** + * Interface for handler of messages that are added to the internal TDLib log. + */ + public interface LogMessageHandler { + /** + * Callback called on messages that are added to the internal TDLib log. + * + * @param verbosityLevel Log verbosity level with which the message was added from -1 up to 1024. + * If 0, then TDLib will crash as soon as the callback returns. + * None of the TDLib methods can be called from the callback. + * @param message The message added to the internal TDLib log. + */ + void onLogMessage(int verbosityLevel, String message); + } + + /** * Sends a request to the TDLib. * * @param query Object representing a query to the TDLib. @@ -55,25 +75,11 @@ public final class Client implements Runnable { * @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(); + long queryId = currentQueryId.incrementAndGet(); + if (resultHandler != null) { handlers.put(queryId, new Handler(resultHandler, exceptionHandler)); - nativeClientSend(nativeClientId, queryId, query); - } finally { - readLock.unlock(); } + nativeClientSend(nativeClientId, queryId, query); } /** @@ -97,108 +103,105 @@ public final class Client implements Runnable { * @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. + * Creates new Client. * - * @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. + * @param updateHandler Handler for incoming updates. + * @param updateExceptionHandler Handler for exceptions thrown from updateHandler. 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 void setUpdatesHandler(ResultHandler updatesHandler, ExceptionHandler exceptionHandler) { - handlers.put(0L, new Handler(updatesHandler, exceptionHandler)); + public static Client create(ResultHandler updateHandler, ExceptionHandler updateExceptionHandler, ExceptionHandler defaultExceptionHandler) { + Client client = new Client(updateHandler, updateExceptionHandler, defaultExceptionHandler); + synchronized (responseReceiver) { + if (!responseReceiver.isRun) { + responseReceiver.isRun = true; + + Thread receiverThread = new Thread(responseReceiver, "TDLib thread"); + receiverThread.setDaemon(true); + receiverThread.start(); + } + } + return client; } /** - * Replaces handler for incoming updates from the TDLib. Sets empty ExceptionHandler. + * Sets the handler for messages that are added to the internal TDLib log. + * None of the TDLib methods can be called from the callback. * - * @param updatesHandler Handler with onResult method which will be called for every incoming - * update from the TDLib. + * @param maxVerbosityLevel The maximum verbosity level of messages for which the callback will be called. + * @param logMessageHandler Handler for messages that are added to the internal TDLib log. Pass null to remove the handler. */ - public void setUpdatesHandler(ResultHandler updatesHandler) { - setUpdatesHandler(updatesHandler, null); + public static void setLogMessageHandler(int maxVerbosityLevel, Client.LogMessageHandler logMessageHandler) { + nativeClientSetLogMessageHandler(maxVerbosityLevel, logMessageHandler); } - /** - * 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; - } + private static class ResponseReceiver implements Runnable { + public boolean isRun = false; - /** - * Overridden method from Runnable, do not call it directly. - */ - @Override - public void run() { - while (!stopFlag) { - receiveQueries(300.0 /*seconds*/); + @Override + public void run() { + while (true) { + int resultN = nativeClientReceive(clientIds, eventIds, events, 100000.0 /*seconds*/); + for (int i = 0; i < resultN; i++) { + processResult(clientIds[i], eventIds[i], events[i]); + events[i] = null; + } + } } - } - - /** - * 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); + private void processResult(int clientId, long id, TdApi.Object object) { + boolean isClosed = false; + if (id == 0 && object instanceof TdApi.UpdateAuthorizationState) { + TdApi.AuthorizationState authorizationState = ((TdApi.UpdateAuthorizationState) object).authorizationState; + if (authorizationState instanceof TdApi.AuthorizationStateClosed) { + isClosed = true; + } } - isClientDestroyed = true; - while (!stopFlag) { - Thread.yield(); + + Handler handler = id == 0 ? updateHandlers.get(clientId) : handlers.remove(id); + if (handler != null) { + try { + handler.resultHandler.onResult(object); + } catch (Throwable cause) { + ExceptionHandler exceptionHandler = handler.exceptionHandler; + if (exceptionHandler == null) { + exceptionHandler = defaultExceptionHandlers.get(clientId); + } + if (exceptionHandler != null) { + try { + exceptionHandler.onException(cause); + } catch (Throwable ignored) { + } + } + } } - while (handlers.size() != 1) { - receiveQueries(300.0); + + if (isClosed) { + updateHandlers.remove(clientId); // there will be no more updates + defaultExceptionHandlers.remove(clientId); // ignore further exceptions + clientCount.decrementAndGet(); } - 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 static final int MAX_EVENTS = 1000; + private final int[] clientIds = new int[MAX_EVENTS]; + private final long[] eventIds = new long[MAX_EVENTS]; + private final TdApi.Object[] events = new TdApi.Object[MAX_EVENTS]; + } - private final ConcurrentHashMap<Long, Handler> handlers = new ConcurrentHashMap<Long, Handler>(); - private final AtomicLong currentQueryId = new AtomicLong(); + private final int nativeClientId; - private volatile ExceptionHandler defaultExceptionHandler = null; + private static final ConcurrentHashMap<Integer, ExceptionHandler> defaultExceptionHandlers = new ConcurrentHashMap<Integer, ExceptionHandler>(); + private static final ConcurrentHashMap<Integer, Handler> updateHandlers = new ConcurrentHashMap<Integer, Handler>(); + private static final ConcurrentHashMap<Long, Handler> handlers = new ConcurrentHashMap<Long, Handler>(); + private static final AtomicLong currentQueryId = new AtomicLong(); + private static final AtomicLong clientCount = new AtomicLong(); - 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 final ResponseReceiver responseReceiver = new ResponseReceiver(); private static class Handler { final ResultHandler resultHandler; @@ -210,76 +213,30 @@ public final class Client implements Runnable { } } - private Client(ResultHandler updatesHandler, ExceptionHandler updateExceptionHandler, ExceptionHandler defaultExceptionHandler) { + private Client(ResultHandler updateHandler, ExceptionHandler updateExceptionHandler, ExceptionHandler defaultExceptionHandler) { + clientCount.incrementAndGet(); 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; + if (updateHandler != null) { + updateHandlers.put(nativeClientId, new Handler(updateHandler, updateExceptionHandler)); } - - try { - resultHandler.onResult(object); - } catch (Throwable cause) { - if (exceptionHandler == null) { - exceptionHandler = defaultExceptionHandler; - } - if (exceptionHandler != null) { - try { - exceptionHandler.onException(cause); - } catch (Throwable ignored) { - } - } + if (defaultExceptionHandler != null) { + defaultExceptionHandlers.put(nativeClientId, defaultExceptionHandler); } + send(new TdApi.GetOption("version"), null, null); } - 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; - } + @Override + protected void finalize() throws Throwable { + send(new TdApi.Close(), null, null); } - private static native long createNativeClient(); + private static native int createNativeClient(); - private static native void nativeClientSend(long nativeClientId, long eventId, TdApi.Function function); + private static native void nativeClientSend(int nativeClientId, long eventId, TdApi.Function function); - private static native int nativeClientReceive(long nativeClientId, long[] eventIds, TdApi.Object[] events, double timeout); + private static native int nativeClientReceive(int[] clientIds, long[] eventIds, TdApi.Object[] events, double timeout); private static native TdApi.Object nativeClientExecute(TdApi.Function function); - private static native void destroyNativeClient(long nativeClientId); + private static native void nativeClientSetLogMessageHandler(int maxVerbosityLevel, LogMessageHandler logMessageHandler); } 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 deleted file mode 100644 index c81ffbeeb7..0000000000 --- a/protocols/Telegram/tdlib/td/example/java/org/drinkless/tdlib/Log.java +++ /dev/null @@ -1,75 +0,0 @@ -// -// 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 index 831de88f1d..7e76b42276 100644 --- 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 @@ -1,5 +1,5 @@ // -// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018 +// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2022 // // 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) @@ -7,17 +7,17 @@ package org.drinkless.tdlib.example; import org.drinkless.tdlib.Client; -import org.drinkless.tdlib.Log; import org.drinkless.tdlib.TdApi; +import java.io.BufferedReader; 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.atomic.AtomicLong; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; @@ -30,34 +30,31 @@ public final class Example { private static TdApi.AuthorizationState authorizationState = null; private static volatile boolean haveAuthorization = false; - private static volatile boolean quiting = false; + private static volatile boolean needQuit = false; + private static volatile boolean canQuit = 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<Long, TdApi.User> users = new ConcurrentHashMap<Long, TdApi.User>(); + private static final ConcurrentMap<Long, TdApi.BasicGroup> basicGroups = new ConcurrentHashMap<Long, TdApi.BasicGroup>(); + private static final ConcurrentMap<Long, TdApi.Supergroup> supergroups = new ConcurrentHashMap<Long, 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 NavigableSet<OrderedChat> mainChatList = new TreeSet<OrderedChat>(); + private static boolean haveFullMainChatList = 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 ConcurrentMap<Long, TdApi.UserFullInfo> usersFullInfo = new ConcurrentHashMap<Long, TdApi.UserFullInfo>(); + private static final ConcurrentMap<Long, TdApi.BasicGroupFullInfo> basicGroupsFullInfo = new ConcurrentHashMap<Long, TdApi.BasicGroupFullInfo>(); + private static final ConcurrentMap<Long, TdApi.SupergroupFullInfo> supergroupsFullInfo = new ConcurrentHashMap<Long, 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(""); @@ -68,18 +65,24 @@ public final class Example { } } - 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; - } + private static void setChatPositions(TdApi.Chat chat, TdApi.ChatPosition[] positions) { + synchronized (mainChatList) { + synchronized (chat) { + for (TdApi.ChatPosition position : chat.positions) { + if (position.list.getConstructor() == TdApi.ChatListMain.CONSTRUCTOR) { + boolean isRemoved = mainChatList.remove(new OrderedChat(chat.id, position)); + assert isRemoved; + } + } - chat.order = order; + chat.positions = positions; - if (chat.order != 0) { - boolean isAdded = chatList.add(new OrderedChat(chat.order, chat.id)); - assert isAdded; + for (TdApi.ChatPosition position : chat.positions) { + if (position.list.getConstructor() == TdApi.ChatListMain.CONSTRUCTOR) { + boolean isAdded = mainChatList.add(new OrderedChat(chat.id, position)); + assert isAdded; + } + } } } } @@ -90,31 +93,48 @@ public final class Example { } 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()); + TdApi.SetTdlibParameters request = new TdApi.SetTdlibParameters(); + request.databaseDirectory = "tdlib"; + request.useMessageDatabase = true; + request.useSecretChats = true; + request.apiId = 94575; + request.apiHash = "a3406de8d171bb422bb6ddf3bbd800e2"; + request.systemLanguageCode = "en"; + request.deviceModel = "Desktop"; + request.applicationVersion = "1.0"; + request.enableStorageOptimizer = true; + + client.send(request, new AuthorizationRequestHandler()); break; case TdApi.AuthorizationStateWaitPhoneNumber.CONSTRUCTOR: { String phoneNumber = promptString("Please enter phone number: "); - client.send(new TdApi.SetAuthenticationPhoneNumber(phoneNumber, false, false), new AuthorizationRequestHandler()); + client.send(new TdApi.SetAuthenticationPhoneNumber(phoneNumber, null), new AuthorizationRequestHandler()); + break; + } + case TdApi.AuthorizationStateWaitOtherDeviceConfirmation.CONSTRUCTOR: { + String link = ((TdApi.AuthorizationStateWaitOtherDeviceConfirmation) Example.authorizationState).link; + System.out.println("Please confirm this login link on another device: " + link); + break; + } + case TdApi.AuthorizationStateWaitEmailAddress.CONSTRUCTOR: { + String emailAddress = promptString("Please enter email address: "); + client.send(new TdApi.SetAuthenticationEmailAddress(emailAddress), new AuthorizationRequestHandler()); + break; + } + case TdApi.AuthorizationStateWaitEmailCode.CONSTRUCTOR: { + String code = promptString("Please enter email authentication code: "); + client.send(new TdApi.CheckAuthenticationEmailCode(new TdApi.EmailAddressAuthenticationCode(code)), new AuthorizationRequestHandler()); break; } case TdApi.AuthorizationStateWaitCode.CONSTRUCTOR: { String code = promptString("Please enter authentication code: "); - client.send(new TdApi.CheckAuthenticationCode(code, "", ""), new AuthorizationRequestHandler()); + client.send(new TdApi.CheckAuthenticationCode(code), new AuthorizationRequestHandler()); + break; + } + case TdApi.AuthorizationStateWaitRegistration.CONSTRUCTOR: { + String firstName = promptString("Please enter your first name: "); + String lastName = promptString("Please enter your last name: "); + client.send(new TdApi.RegisterUser(firstName, lastName), new AuthorizationRequestHandler()); break; } case TdApi.AuthorizationStateWaitPassword.CONSTRUCTOR: { @@ -141,8 +161,10 @@ public final class Example { break; case TdApi.AuthorizationStateClosed.CONSTRUCTOR: print("Closed"); - if (!quiting) { - client = Client.create(new UpdatesHandler(), null, null); // recreate client after previous has closed + if (!needQuit) { + client = Client.create(new UpdateHandler(), null, null); // recreate client after previous has closed + } else { + canQuit = true; } break; default: @@ -192,7 +214,7 @@ public final class Example { if (commands.length > 1) { limit = toInt(commands[1]); } - getChatList(limit); + getMainChatList(limit); break; } case "gc": @@ -211,7 +233,7 @@ public final class Example { client.send(new TdApi.LogOut(), defaultHandler); break; case "q": - quiting = true; + needQuit = true; haveAuthorization = false; client.send(new TdApi.Close(), defaultHandler); break; @@ -223,33 +245,26 @@ public final class Example { } } - 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() { + private static void getMainChatList(final int limit) { + synchronized (mainChatList) { + if (!haveFullMainChatList && limit > mainChatList.size()) { + // send LoadChats request if there are some unknown chats and have not enough known chats + client.send(new TdApi.LoadChats(new TdApi.ChatListMain(), limit - mainChatList.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; + if (((TdApi.Error) object).code == 404) { + synchronized (mainChatList) { + haveFullMainChatList = true; } + } else { + System.err.println("Receive an error for LoadChats:" + newLine + object); } + break; + case TdApi.Ok.CONSTRUCTOR: // chats had already been received through updates, let's retry request - getChatList(limit); + getMainChatList(limit); break; default: System.err.println("Receive wrong response from TDLib:" + newLine + object); @@ -259,11 +274,10 @@ public final class Example { return; } - // have enough chats in the chat list to answer request - java.util.Iterator<OrderedChat> iter = chatList.iterator(); + java.util.Iterator<OrderedChat> iter = mainChatList.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++) { + System.out.println("First " + limit + " chat(s) out of " + mainChatList.size() + " known chat(s):"); + for (int i = 0; i < limit && i < mainChatList.size(); i++) { long chatId = iter.next().chatId; TdApi.Chat chat = chats.get(chatId); synchronized (chat) { @@ -280,24 +294,27 @@ public final class Example { 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); + client.send(new TdApi.SendMessage(chatId, 0, 0, null, replyMarkup, content), defaultHandler); } public static void main(String[] args) throws InterruptedException { - // disable TDLib log - Log.setVerbosityLevel(0); - if (!Log.setFilePath("tdlib.log")) { + // set log message handler to handle only fatal errors (0) and plain log messages (-1) + Client.setLogMessageHandler(0, new LogMessageHandler()); + + // disable TDLib log and redirect fatal errors and plain log messages to a file + Client.execute(new TdApi.SetLogVerbosityLevel(0)); + if (Client.execute(new TdApi.SetLogStream(new TdApi.LogStreamFile("tdlib.log", 1 << 27, false))) instanceof TdApi.Error) { throw new IOError(new IOException("Write access to the current directory is required")); } // create client - client = Client.create(new UpdatesHandler(), null, null); + client = Client.create(new UpdateHandler(), 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) { + while (!needQuit) { // await authorization authorizationLock.lock(); try { @@ -312,21 +329,24 @@ public final class Example { getCommand(); } } + while (!canQuit) { + Thread.sleep(1); + } } private static class OrderedChat implements Comparable<OrderedChat> { - final long order; final long chatId; + final TdApi.ChatPosition position; - OrderedChat(long order, long chatId) { - this.order = order; + OrderedChat(long chatId, TdApi.ChatPosition position) { this.chatId = chatId; + this.position = position; } @Override public int compareTo(OrderedChat o) { - if (this.order != o.order) { - return o.order < this.order ? -1 : 1; + if (this.position.order != o.position.order) { + return o.position.order < this.position.order ? -1 : 1; } if (this.chatId != o.chatId) { return o.chatId < this.chatId ? -1 : 1; @@ -337,7 +357,7 @@ public final class Example { @Override public boolean equals(Object obj) { OrderedChat o = (OrderedChat) obj; - return this.order == o.order && this.chatId == o.chatId; + return this.chatId == o.chatId && this.position.order == o.position.order; } } @@ -348,7 +368,7 @@ public final class Example { } } - private static class UpdatesHandler implements Client.ResultHandler { + private static class UpdateHandler implements Client.ResultHandler { @Override public void onResult(TdApi.Object object) { switch (object.getConstructor()) { @@ -360,7 +380,7 @@ public final class Example { TdApi.UpdateUser updateUser = (TdApi.UpdateUser) object; users.put(updateUser.user.id, updateUser.user); break; - case TdApi.UpdateUserStatus.CONSTRUCTOR: { + case TdApi.UpdateUserStatus.CONSTRUCTOR: { TdApi.UpdateUserStatus updateUserStatus = (TdApi.UpdateUserStatus) object; TdApi.User user = users.get(updateUserStatus.userId); synchronized (user) { @@ -387,9 +407,9 @@ public final class Example { synchronized (chat) { chats.put(chat.id, chat); - long order = chat.order; - chat.order = 0; - setChatOrder(chat, order); + TdApi.ChatPosition[] positions = chat.positions; + chat.positions = new TdApi.ChatPosition[0]; + setChatPositions(chat, positions); } break; } @@ -414,24 +434,37 @@ public final class Example { TdApi.Chat chat = chats.get(updateChat.chatId); synchronized (chat) { chat.lastMessage = updateChat.lastMessage; - setChatOrder(chat, updateChat.order); + setChatPositions(chat, updateChat.positions); } break; } - case TdApi.UpdateChatOrder.CONSTRUCTOR: { - TdApi.UpdateChatOrder updateChat = (TdApi.UpdateChatOrder) object; - TdApi.Chat chat = chats.get(updateChat.chatId); - synchronized (chat) { - setChatOrder(chat, updateChat.order); + case TdApi.UpdateChatPosition.CONSTRUCTOR: { + TdApi.UpdateChatPosition updateChat = (TdApi.UpdateChatPosition) object; + if (updateChat.position.list.getConstructor() != TdApi.ChatListMain.CONSTRUCTOR) { + break; } - 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); + int i; + for (i = 0; i < chat.positions.length; i++) { + if (chat.positions[i].list.getConstructor() == TdApi.ChatListMain.CONSTRUCTOR) { + break; + } + } + TdApi.ChatPosition[] new_positions = new TdApi.ChatPosition[chat.positions.length + (updateChat.position.order == 0 ? 0 : 1) - (i < chat.positions.length ? 1 : 0)]; + int pos = 0; + if (updateChat.position.order != 0) { + new_positions[pos++] = updateChat.position; + } + for (int j = 0; j < chat.positions.length; j++) { + if (j != i) { + new_positions[pos++] = chat.positions[j]; + } + } + assert pos == new_positions.length; + + setChatPositions(chat, new_positions); } break; } @@ -481,17 +514,55 @@ public final class Example { TdApi.Chat chat = chats.get(updateChat.chatId); synchronized (chat) { chat.draftMessage = updateChat.draftMessage; - setChatOrder(chat, updateChat.order); + setChatPositions(chat, updateChat.positions); } 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; - } + case TdApi.UpdateChatPermissions.CONSTRUCTOR: { + TdApi.UpdateChatPermissions update = (TdApi.UpdateChatPermissions) object; + TdApi.Chat chat = chats.get(update.chatId); + synchronized (chat) { + chat.permissions = update.permissions; + } + break; + } + case TdApi.UpdateChatNotificationSettings.CONSTRUCTOR: { + TdApi.UpdateChatNotificationSettings update = (TdApi.UpdateChatNotificationSettings) object; + TdApi.Chat chat = chats.get(update.chatId); + synchronized (chat) { + chat.notificationSettings = update.notificationSettings; + } + break; + } + case TdApi.UpdateChatDefaultDisableNotification.CONSTRUCTOR: { + TdApi.UpdateChatDefaultDisableNotification update = (TdApi.UpdateChatDefaultDisableNotification) object; + TdApi.Chat chat = chats.get(update.chatId); + synchronized (chat) { + chat.defaultDisableNotification = update.defaultDisableNotification; + } + break; + } + case TdApi.UpdateChatIsMarkedAsUnread.CONSTRUCTOR: { + TdApi.UpdateChatIsMarkedAsUnread update = (TdApi.UpdateChatIsMarkedAsUnread) object; + TdApi.Chat chat = chats.get(update.chatId); + synchronized (chat) { + chat.isMarkedAsUnread = update.isMarkedAsUnread; + } + break; + } + case TdApi.UpdateChatIsBlocked.CONSTRUCTOR: { + TdApi.UpdateChatIsBlocked update = (TdApi.UpdateChatIsBlocked) object; + TdApi.Chat chat = chats.get(update.chatId); + synchronized (chat) { + chat.isBlocked = update.isBlocked; + } + break; + } + case TdApi.UpdateChatHasScheduledMessages.CONSTRUCTOR: { + TdApi.UpdateChatHasScheduledMessages update = (TdApi.UpdateChatHasScheduledMessages) object; + TdApi.Chat chat = chats.get(update.chatId); + synchronized (chat) { + chat.hasScheduledMessages = update.hasScheduledMessages; } break; } @@ -530,4 +601,85 @@ public final class Example { } } } -}
\ No newline at end of file + + private static class LogMessageHandler implements Client.LogMessageHandler { + @Override + public void onLogMessage(int verbosityLevel, String message) { + if (verbosityLevel == 0) { + onFatalError(message); + return; + } + System.err.println(message); + } + } + + private static void onFatalError(String errorMessage) { + final class ThrowError implements Runnable { + private final String errorMessage; + private final AtomicLong errorThrowTime; + + private ThrowError(String errorMessage, AtomicLong errorThrowTime) { + this.errorMessage = errorMessage; + this.errorThrowTime = errorThrowTime; + } + + @Override + public void run() { + if (isDatabaseBrokenError(errorMessage) || isDiskFullError(errorMessage) || isDiskError(errorMessage)) { + processExternalError(); + return; + } + + errorThrowTime.set(System.currentTimeMillis()); + throw new ClientError("TDLib fatal error: " + errorMessage); + } + + private void processExternalError() { + errorThrowTime.set(System.currentTimeMillis()); + throw new ExternalClientError("Fatal error: " + errorMessage); + } + + final class ClientError extends Error { + private ClientError(String message) { + super(message); + } + } + + final class ExternalClientError extends Error { + public ExternalClientError(String message) { + super(message); + } + } + + private boolean isDatabaseBrokenError(String message) { + return message.contains("Wrong key or database is corrupted") || + message.contains("SQL logic error or missing database") || + message.contains("database disk image is malformed") || + message.contains("file is encrypted or is not a database") || + message.contains("unsupported file format") || + message.contains("Database was corrupted and deleted during execution and can't be recreated"); + } + + private boolean isDiskFullError(String message) { + return message.contains("PosixError : No space left on device") || + message.contains("database or disk is full"); + } + + private boolean isDiskError(String message) { + return message.contains("I/O error") || message.contains("Structure needs cleaning"); + } + } + + final AtomicLong errorThrowTime = new AtomicLong(Long.MAX_VALUE); + new Thread(new ThrowError(errorMessage, errorThrowTime), "TDLib fatal error thread").start(); + + // wait at least 10 seconds after the error is thrown + while (errorThrowTime.get() >= System.currentTimeMillis() - 10000) { + try { + Thread.sleep(1000 /* milliseconds */); + } catch (InterruptedException ignore) { + Thread.currentThread().interrupt(); + } + } + } +} diff --git a/protocols/Telegram/tdlib/td/example/java/td_jni.cpp b/protocols/Telegram/tdlib/td/example/java/td_jni.cpp index b9ba74a402..15c60a9545 100644 --- a/protocols/Telegram/tdlib/td/example/java/td_jni.cpp +++ b/protocols/Telegram/tdlib/td/example/java/td_jni.cpp @@ -1,11 +1,10 @@ // -// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018 +// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2022 // // 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) // #include <td/telegram/Client.h> -#include <td/telegram/Log.h> #include <td/telegram/td_api.h> #include <td/tl/tl_jni_object.h> @@ -26,28 +25,35 @@ static td::td_api::object_ptr<td::td_api::Function> fetch_function(JNIEnv *env, return result; } -static td::Client *get_client(jlong client_id) { - return reinterpret_cast<td::Client *>(static_cast<std::uintptr_t>(client_id)); +static td::ClientManager *get_manager() { + return td::ClientManager::get_manager_singleton(); } -static jlong Client_createNativeClient(JNIEnv *env, jclass clazz) { - return static_cast<jlong>(reinterpret_cast<std::uintptr_t>(new td::Client())); +static jint Client_createNativeClient(JNIEnv *env, jclass clazz) { + return static_cast<jint>(get_manager()->create_client_id()); } -static void Client_nativeClientSend(JNIEnv *env, jclass clazz, jlong client_id, jlong id, jobject function) { - get_client(client_id)->send({static_cast<std::uint64_t>(id), fetch_function(env, function)}); +static void Client_nativeClientSend(JNIEnv *env, jclass clazz, jint client_id, jlong id, jobject function) { + get_manager()->send(static_cast<std::int32_t>(client_id), static_cast<std::uint64_t>(id), + fetch_function(env, function)); } -static jint Client_nativeClientReceive(JNIEnv *env, jclass clazz, jlong client_id, jlongArray ids, jobjectArray events, - jdouble timeout) { - auto client = get_client(client_id); - jsize events_size = env->GetArrayLength(ids); // ids and events size must be of equal size +static jint Client_nativeClientReceive(JNIEnv *env, jclass clazz, jintArray client_ids, jlongArray ids, + jobjectArray events, jdouble timeout) { + jsize events_size = env->GetArrayLength(ids); // client_ids, ids and events must be of equal size + if (events_size == 0) { + return 0; + } jsize result_size = 0; - auto response = client->receive(timeout); - while (response.object && result_size < events_size) { - jlong result_id = static_cast<jlong>(response.id); - env->SetLongArrayRegion(ids, result_size, 1, &result_id); + auto *manager = get_manager(); + auto response = manager->receive(timeout); + while (response.object) { + auto client_id = static_cast<jint>(response.client_id); + env->SetIntArrayRegion(client_ids, result_size, 1, &client_id); + + auto request_id = static_cast<jlong>(response.request_id); + env->SetLongArrayRegion(ids, result_size, 1, &request_id); jobject object; response.object->store(env, object); @@ -55,33 +61,21 @@ static jint Client_nativeClientReceive(JNIEnv *env, jclass clazz, jlong client_i env->DeleteLocalRef(object); result_size++; - response = client->receive(0); + if (result_size == events_size) { + break; + } + + response = manager->receive(0); } return result_size; } static jobject Client_nativeClientExecute(JNIEnv *env, jclass clazz, jobject function) { jobject result; - td::Client::execute({0, fetch_function(env, function)}).object->store(env, result); + td::ClientManager::execute(fetch_function(env, function))->store(env, result); return result; } -static void Client_destroyNativeClient(JNIEnv *env, jclass clazz, jlong client_id) { - delete get_client(client_id); -} - -static void Log_setVerbosityLevel(JNIEnv *env, jclass clazz, jint new_log_verbosity_level) { - td::Log::set_verbosity_level(static_cast<int>(new_log_verbosity_level)); -} - -static jboolean Log_setFilePath(JNIEnv *env, jclass clazz, jstring file_path) { - return td::Log::set_file_path(td::jni::from_jstring(env, file_path)) ? JNI_TRUE : JNI_FALSE; -} - -static void Log_setMaxFileSize(JNIEnv *env, jclass clazz, jlong max_file_size) { - td::Log::set_max_file_size(max_file_size); -} - static jstring Object_toString(JNIEnv *env, jobject object) { return td::jni::to_jstring(env, to_string(td::td_api::Object::fetch(env, object))); } @@ -92,17 +86,52 @@ static jstring Function_toString(JNIEnv *env, jobject object) { static constexpr jint JAVA_VERSION = JNI_VERSION_1_6; static JavaVM *java_vm; -static jclass log_class; +static jobject log_message_handler; -static void on_fatal_error(const char *error_message) { +static void on_log_message(int verbosity_level, const char *log_message) { auto env = td::jni::get_jni_env(java_vm, JAVA_VERSION); - jmethodID on_fatal_error_method = env->GetStaticMethodID(log_class, "onFatalError", "(Ljava/lang/String;)V"); - if (env && on_fatal_error_method) { - jstring error_str = td::jni::to_jstring(env.get(), error_message); - env->CallStaticVoidMethod(log_class, on_fatal_error_method, error_str); - if (error_str) { - env->DeleteLocalRef(error_str); + if (env == nullptr) { + return; + } + + jobject handler = env->NewLocalRef(log_message_handler); + if (!handler) { + return; + } + + jclass handler_class = env->GetObjectClass(handler); + if (handler_class) { + jmethodID on_log_message_method = env->GetMethodID(handler_class, "onLogMessage", "(ILjava/lang/String;)V"); + if (on_log_message_method) { + jstring log_message_str = td::jni::to_jstring(env.get(), log_message); + if (log_message_str) { + env->CallVoidMethod(handler, on_log_message_method, static_cast<jint>(verbosity_level), log_message_str); + env->DeleteLocalRef((jobject)log_message_str); + } + } + env->DeleteLocalRef((jobject)handler_class); + } + + env->DeleteLocalRef(handler); +} + +static void Client_nativeClientSetLogMessageHandler(JNIEnv *env, jclass clazz, jint max_verbosity_level, + jobject new_log_message_handler) { + if (log_message_handler) { + td::ClientManager::set_log_message_callback(0, nullptr); + jobject old_log_message_handler = log_message_handler; + log_message_handler = jobject(); + env->DeleteGlobalRef(old_log_message_handler); + } + + if (new_log_message_handler) { + log_message_handler = env->NewGlobalRef(new_log_message_handler); + if (!log_message_handler) { + // out of memory + return; } + + td::ClientManager::set_log_message_callback(static_cast<int>(max_verbosity_level), on_log_message); } } @@ -120,21 +149,17 @@ static jint register_native(JavaVM *vm) { }; auto client_class = td::jni::get_jclass(env, PACKAGE_NAME "/Client"); - log_class = td::jni::get_jclass(env, PACKAGE_NAME "/Log"); auto object_class = td::jni::get_jclass(env, PACKAGE_NAME "/TdApi$Object"); auto function_class = td::jni::get_jclass(env, PACKAGE_NAME "/TdApi$Function"); #define TD_OBJECT "L" PACKAGE_NAME "/TdApi$Object;" #define TD_FUNCTION "L" PACKAGE_NAME "/TdApi$Function;" - register_method(client_class, "createNativeClient", "()J", Client_createNativeClient); - register_method(client_class, "nativeClientSend", "(JJ" TD_FUNCTION ")V", Client_nativeClientSend); - register_method(client_class, "nativeClientReceive", "(J[J[" TD_OBJECT "D)I", Client_nativeClientReceive); + register_method(client_class, "createNativeClient", "()I", Client_createNativeClient); + register_method(client_class, "nativeClientSend", "(IJ" TD_FUNCTION ")V", Client_nativeClientSend); + register_method(client_class, "nativeClientReceive", "([I[J[" TD_OBJECT "D)I", Client_nativeClientReceive); register_method(client_class, "nativeClientExecute", "(" TD_FUNCTION ")" TD_OBJECT, Client_nativeClientExecute); - register_method(client_class, "destroyNativeClient", "(J)V", Client_destroyNativeClient); - - register_method(log_class, "setVerbosityLevel", "(I)V", Log_setVerbosityLevel); - register_method(log_class, "setFilePath", "(Ljava/lang/String;)Z", Log_setFilePath); - register_method(log_class, "setMaxFileSize", "(J)V", Log_setMaxFileSize); + register_method(client_class, "nativeClientSetLogMessageHandler", "(IL" PACKAGE_NAME "/Client$LogMessageHandler;)V", + Client_nativeClientSetLogMessageHandler); register_method(object_class, "toString", "()Ljava/lang/String;", Object_toString); @@ -145,7 +170,6 @@ static jint register_native(JavaVM *vm) { td::jni::init_vars(env, PACKAGE_NAME); td::td_api::Object::init_jni_vars(env, PACKAGE_NAME); td::td_api::Function::init_jni_vars(env, PACKAGE_NAME); - td::Log::set_fatal_error_callback(on_fatal_error); return JAVA_VERSION; } |