update to 10.10.0 (4571)

.gitignore

@@ -4,3 +4,12 @@ build/
 obj/
 *.iml
 local.properties
+TMessagesProj/.cxx/
+TMessagesProj/jniLibs/
+TMessagesProj/jniRes/
+**/.DS_Store
+TMessagesProj/afat/
+TMessagesProj_App/afat/
+TMessagesProj_AppHockeyApp/afat/
+TMessagesProj_AppStandalone/afat/
+TMessagesProj_AppHuawei/afat/

TMessagesProj/build.gradle

@@ -25,6 +25,7 @@ dependencies {
     implementation 'androidx.multidex:multidex:2.0.1'
     implementation "androidx.sharetarget:sharetarget:1.2.0"
     implementation 'androidx.interpolator:interpolator:1.0.0'
+    implementation 'androidx.biometric:biometric:1.1.0'
 
     compileOnly 'org.checkerframework:checker-qual:2.5.2'
     compileOnly 'org.checkerframework:checker-compat-qual:2.5.0'

TMessagesProj/jni/CMakeLists.txt

@@ -425,12 +425,13 @@ target_include_directories(breakpad PUBLIC
 #voip
 include(${CMAKE_HOME_DIRECTORY}/voip/CMakeLists.txt)
 
-set(NATIVE_LIB "tmessages.48")
+set(NATIVE_LIB "tmessages.49")
 
 #tmessages
 add_library(${NATIVE_LIB} SHARED
         jni.c
         audio.c
+        webm_encoder.c
         image.cpp
         video.c
         intro/IntroRenderer.c

TMessagesProj/jni/TgNetWrapper.cpp

@@ -30,6 +30,7 @@ jmethodID jclass_ConnectionsManager_onRequestNewServerIpAndPort;
 jmethodID jclass_ConnectionsManager_onProxyError;
 jmethodID jclass_ConnectionsManager_getHostByName;
 jmethodID jclass_ConnectionsManager_getInitFlags;
+jmethodID jclass_ConnectionsManager_onPremiumFloodWait;
 
 bool check_utf8(const char *data, size_t len);
 
@@ -319,6 +320,10 @@ class Delegate : public ConnectiosManagerDelegate {
     int32_t getInitFlags(int32_t instanceNum) {
         return (int32_t) jniEnv[instanceNum]->CallStaticIntMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_getInitFlags);
     }
+
+    void onPremiumFloodWait(int32_t instanceNum, int32_t requestToken, bool isUpload) {
+        jniEnv[instanceNum]->CallStaticVoidMethod(jclass_ConnectionsManager, jclass_ConnectionsManager_onPremiumFloodWait, instanceNum, requestToken, isUpload);
+    }
 };
 
 void onHostNameResolved(JNIEnv *env, jclass c, jstring host, jlong address, jstring ip) {
@@ -568,6 +573,10 @@ extern "C" int registerNativeTgNetFunctions(JavaVM *vm, JNIEnv *env) {
     if (jclass_ConnectionsManager_getInitFlags == 0) {
         return JNI_FALSE;
     }
+    jclass_ConnectionsManager_onPremiumFloodWait = env->GetStaticMethodID(jclass_ConnectionsManager, "onPremiumFloodWait", "(IIZ)V");
+    if (jclass_ConnectionsManager_onPremiumFloodWait == 0) {
+        return JNI_FALSE;
+    }
 
     return JNI_TRUE;
 }

TMessagesProj/jni/audio.c

@@ -63,6 +63,7 @@ typedef struct {
     ogg_int64_t last_granulepos;
     opus_int32 min_bytes;
     int max_frame_bytes;
+    int serialno;
 } resume_data;
 
 static int write_uint32(Packet *p, ogg_uint32_t val) {
@@ -261,6 +262,7 @@ ogg_int64_t enc_granulepos;
 ogg_int64_t last_granulepos;
 int size_segments;
 int last_segments;
+int serialno;
 
 void cleanupRecorder() {
 
@@ -381,7 +383,7 @@ int initRecorder(const char *path, opus_int32 sampleRate) {
     header.preskip = (int)(inopt.skip * (48000.0 / coding_rate));
     inopt.extraout = (int)(header.preskip * (rate / 48000.0));
 
-    if (ogg_stream_init(&os, rand()) == -1) {
+    if (ogg_stream_init(&os, serialno = rand()) == -1) {
         LOGE("Error: stream init failed");
         return 0;
     }
@@ -465,6 +467,7 @@ void saveResumeData() {
     data.last_granulepos = last_granulepos;
     data.min_bytes = min_bytes;
     data.max_frame_bytes = max_frame_bytes;
+    data.serialno = serialno;
 
     if (fwrite(&data, sizeof(resume_data), 1, resumeFile) != 1) {
         LOGE("error writing resume data to file: %s", _resumeFilePath);
@@ -527,6 +530,7 @@ int resumeRecorder(const char *path, opus_int32 sampleRate) {
     last_granulepos = resumeData.last_granulepos;
     min_bytes = resumeData.min_bytes;
     max_frame_bytes = resumeData.max_frame_bytes;
+    serialno = resumeData.serialno;
 
     _fileOs = fopen(path, "a");
     if (!_fileOs) {
@@ -557,7 +561,7 @@ int resumeRecorder(const char *path, opus_int32 sampleRate) {
     }
 #endif
 
-    if (ogg_stream_init(&os, rand()) == -1) {
+    if (ogg_stream_init(&os, serialno) == -1) {
         LOGE("Error: stream init failed");
         return 0;
     }

TMessagesProj/jni/ffmpeg/build_ffmpeg/build_ffmpeg.sh

@@ -76,6 +76,10 @@ LIBS=" -L${PREFIX}/lib"
 \
 --enable-libvpx \
 --enable-decoder=libvpx_vp9 \
+--enable-encoder=libvpx_vp9 \
+--enable-muxer=matroska \
+--enable-bsf=vp9_superframe \
+--enable-bsf=vp9_raw_reorder \
 --enable-runtime-cpudetect \
 --enable-pthreads \
 --enable-avresample \

TMessagesProj/jni/ffmpeg/build_ffmpeg/vpx-android/build-vpx.sh

@@ -68,6 +68,8 @@ fi
     --disable-examples \
     --disable-tools \
     --disable-debug \
+    --disable-neon-asm \
+    --disable-neon-dotprod \
     --disable-unit-tests || exit 1
 
   make -j${HOST_NUM_CORES} install

TMessagesProj/jni/tgnet/ConnectionsManager.cpp

@@ -1324,12 +1324,24 @@ void ConnectionsManager::processServerResponse(TLObject *message, int64_t messag
                                 request->startTime = 0;
                                 request->startTimeMillis = 0;
                                 request->minStartTime = (int32_t) (getCurrentTimeMonotonicMillis() / 1000 + 2);
-                            } else if (error->error_code == 420 && (request->requestFlags & RequestFlagIgnoreFloodWait) == 0 && error->error_message.find("STORY_SEND_FLOOD") == std::string::npos) {
+                            } else if (
+                                error->error_code == 420 && (request->requestFlags & RequestFlagIgnoreFloodWait) == 0 &&
+                                error->error_message.find("STORY_SEND_FLOOD") == std::string::npos
+                            ) {
                                 int32_t waitTime = 2;
                                 static std::string floodWait = "FLOOD_WAIT_";
+                                static std::string premiumFloodWait = "FLOOD_PREMIUM_WAIT_";
                                 static std::string slowmodeWait = "SLOWMODE_WAIT_";
+                                bool isPremiumFloodWait = false;
                                 discardResponse = true;
-                                if (error->error_message.find(floodWait) != std::string::npos) {
+                                if (error->error_message.find(premiumFloodWait) != std::string::npos) {
+                                    isPremiumFloodWait = true;
+                                    std::string num = error->error_message.substr(premiumFloodWait.size(), error->error_message.size() - premiumFloodWait.size());
+                                    waitTime = atoi(num.c_str());
+                                    if (waitTime <= 0) {
+                                        waitTime = 2;
+                                    }
+                                } else if (error->error_message.find(floodWait) != std::string::npos) {
                                     std::string num = error->error_message.substr(floodWait.size(), error->error_message.size() - floodWait.size());
                                     waitTime = atoi(num.c_str());
                                     if (waitTime <= 0) {
@@ -1343,10 +1355,14 @@ void ConnectionsManager::processServerResponse(TLObject *message, int64_t messag
                                     }
                                     discardResponse = false;
                                 }
+                                request->premiumFloodWait = isPremiumFloodWait;
                                 request->failedByFloodWait = waitTime;
                                 request->startTime = 0;
                                 request->startTimeMillis = 0;
                                 request->minStartTime = (int32_t) (getCurrentTimeMonotonicMillis() / 1000 + waitTime);
+                                if (isPremiumFloodWait && delegate != nullptr) {
+                                    delegate->onPremiumFloodWait(instanceNum, request->requestToken, (request->connectionType & ConnectionTypeUpload) != 0);
+                                }
                             } else if (error->error_code == 400) {
                                 static std::string waitFailed = "MSG_WAIT_FAILED";
                                 static std::string bindFailed = "ENCRYPTED_MESSAGE_INVALID";
@@ -2496,7 +2512,7 @@ void ConnectionsManager::processRequestQueue(uint32_t connectionTypes, uint32_t
                             retryMax = 6;
                         }
                     }
-                    if (request->retryCount >= retryMax) {
+                    if (request->retryCount >= retryMax && !request->premiumFloodWait) {
                         if (LOGS_ENABLED) DEBUG_E("timed out %s, message_id = 0x%" PRIx64, typeInfo.name(), request->messageId);
                         auto error = new TL_error();
                         error->code = -123;

TMessagesProj/jni/tgnet/Defines.h

@@ -153,6 +153,7 @@ typedef struct ConnectiosManagerDelegate {
     virtual void onProxyError(int32_t instanceNum) = 0;
     virtual void getHostByName(std::string domain, int32_t instanceNum, ConnectionSocket *socket) = 0;
     virtual int32_t getInitFlags(int32_t instanceNum) = 0;
+    virtual void onPremiumFloodWait(int32_t instanceNum, int32_t requestToken, bool isUpload) = 0;
 } ConnectiosManagerDelegate;
 
 typedef struct HandshakeDelegate {

TMessagesProj/jni/tgnet/Request.h

@@ -35,6 +35,7 @@ class Request {
     uint32_t retryCount = 0;
     bool failedBySalt = false;
     int32_t failedByFloodWait = 0;
+    bool premiumFloodWait = false;
     ConnectionType connectionType;
     uint32_t requestFlags;
     bool completedSent = false;