Merged in uat (pull request #227)

Stroy - MRN-907 and bug-fixes, task - MRN-945

Approved-by: vanitha.g

Author: karthikeyan-se-contus

android/app/build.gradle

@@ -4,6 +4,8 @@ apply plugin: "com.facebook.react"
 
 /** Add this Firebase intialize */
 apply plugin: 'com.google.gms.google-services'
+/** Add this for Firebase crashlytics */
+apply plugin: 'com.google.firebase.crashlytics'
 
 apply plugin: "kotlin-android"
 
@@ -78,7 +80,15 @@ def enableProguardInReleaseBuilds = false
 def jscFlavor = 'org.webkit:android-jsc:+'
 
 android {
-    ndkVersion rootProject.ext.ndkVersion
+
+   ndkVersion "21.4.7075529"
+//    ndkVersion rootProject.ext.ndkVersion
+
+    externalNativeBuild {
+        cmake {
+            path 'jni/CMakeLists.txt'
+        }
+    }
     buildToolsVersion rootProject.ext.buildToolsVersion
     compileSdk rootProject.ext.compileSdkVersion
 
@@ -88,7 +98,7 @@ android {
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
         versionCode 1
-        versionName "3.0.16"
+        versionName "3.2.7"
         /** Add this for react-native-camera */
         missingDimensionStrategy 'react-native-camera', 'general'
         multiDexEnabled true
@@ -118,10 +128,26 @@ android {
             signingConfig signingConfigs.release
             minifyEnabled enableProguardInReleaseBuilds
             proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+
+            /* Add the firebaseCrashlytics extension (by default,
+            * it's disabled to improve build speeds) and set
+            * nativeSymbolUploadEnabled to true along with a pointer to native libs. */
+            firebaseCrashlytics {
+                nativeSymbolUploadEnabled true
+                unstrippedNativeLibsDir 'build/intermediates/merged_native_libs/release/out/lib'
+            }
         }
     }
 }
 
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+        maven { url "https://repo.mirrorfly.com/snapshot" }
+    }
+}
+
 dependencies {
     // The version of react-native is set by the React Native Gradle Plugin
     implementation("com.facebook.react:react-android")
@@ -131,6 +157,16 @@ dependencies {
     implementation 'com.squareup.retrofit2:converter-gson:2.1.0'
     implementation 'com.squareup.okhttp3:logging-interceptor:3.4.1'
 
+    configurations {
+        all {
+            exclude group: 'org.json', module: 'json'
+            exclude group: 'xpp3', module: 'xpp3'
+        }
+    }
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
+
+    api 'com.mirrorfly.sdk:mirrorfly-utilities:0.0.1'
+
     // exclude group:'com.squareup.okhttp3', module:'okhttp'
 
     if (hermesEnabled.toBoolean()) {

android/app/jni/BuffersStorage.cpp

@@ -0,0 +1,116 @@
+
+#include "BuffersStorage.h"
+#include "FileLog.h"
+#include "NativeByteBuffer.h"
+
+BuffersStorage &BuffersStorage::getInstance() {
+    static BuffersStorage instance(true);
+    return instance;
+}
+
+BuffersStorage::BuffersStorage(bool threadSafe) {
+    isThreadSafe = threadSafe;
+    if (isThreadSafe) {
+        pthread_mutex_init(&mutex, NULL);
+    }
+    for (uint32_t a = 0; a < 4; a++) {
+        freeBuffers8.push_back(new NativeByteBuffer((uint32_t) 8));
+    }
+    for (uint32_t a = 0; a < 5; a++) {
+        freeBuffers128.push_back(new NativeByteBuffer((uint32_t) 128));
+    }
+}
+
+NativeByteBuffer *BuffersStorage::getFreeBuffer(uint32_t size) {
+    uint32_t byteCount = 0;
+    std::vector<NativeByteBuffer *> *arrayToGetFrom = nullptr;
+    NativeByteBuffer *buffer = nullptr;
+    if (size <= 8) {
+        arrayToGetFrom = &freeBuffers8;
+        byteCount = 8;
+    } else if (size <= 128) {
+        arrayToGetFrom = &freeBuffers128;
+        byteCount = 128;
+    } else if (size <= 1024 + 200) {
+        arrayToGetFrom = &freeBuffers1024;
+        byteCount = 1024 + 200;
+    } else if (size <= 4096 + 200) {
+        arrayToGetFrom = &freeBuffers4096;
+        byteCount = 4096 + 200;
+    } else if (size <= 16384 + 200) {
+        arrayToGetFrom = &freeBuffers16384;
+        byteCount = 16384 + 200;
+    } else if (size <= 40000) {
+        arrayToGetFrom = &freeBuffers32768;
+        byteCount = 40000;
+    } else if (size <= 160000) {
+        arrayToGetFrom = &freeBuffersBig;
+        byteCount = 160000;
+    } else {
+        buffer = new NativeByteBuffer(size);
+    }
+
+    if (arrayToGetFrom != nullptr) {
+        if (isThreadSafe) {
+            pthread_mutex_lock(&mutex);
+        }
+        if (arrayToGetFrom->size() > 0) {
+            buffer = (*arrayToGetFrom)[0];
+            arrayToGetFrom->erase(arrayToGetFrom->begin());
+        }
+        if (isThreadSafe) {
+            pthread_mutex_unlock(&mutex);
+        }
+        if (buffer == nullptr) {
+            buffer = new NativeByteBuffer(byteCount);
+            if (LOGS_ENABLED) DEBUG_D("create new %u buffer", byteCount);
+        }
+    }
+    if (buffer != nullptr) {
+        buffer->limit(size);
+        buffer->rewind();
+    }
+    return buffer;
+}
+
+void BuffersStorage::reuseFreeBuffer(NativeByteBuffer *buffer) {
+    if (buffer == nullptr) {
+        return;
+    }
+    std::vector<NativeByteBuffer *> *arrayToReuse = nullptr;
+    uint32_t capacity = buffer->capacity();
+    uint32_t maxCount = 10;
+    if (capacity == 8) {
+        arrayToReuse = &freeBuffers8;
+        maxCount = 80;
+    } else if (capacity == 128) {
+        arrayToReuse = &freeBuffers128;
+        maxCount = 80;
+    } else if (capacity == 1024 + 200) {
+        arrayToReuse = &freeBuffers1024;
+    } else if (capacity == 4096 + 200) {
+        arrayToReuse = &freeBuffers4096;
+    } else if (capacity == 16384 + 200) {
+        arrayToReuse = &freeBuffers16384;
+    } else if (capacity == 40000) {
+        arrayToReuse = &freeBuffers32768;
+    } else if (capacity == 160000) {
+        arrayToReuse = &freeBuffersBig;
+    }
+    if (arrayToReuse != nullptr) {
+        if (isThreadSafe) {
+            pthread_mutex_lock(&mutex);
+        }
+        if (arrayToReuse->size() < maxCount) {
+            arrayToReuse->push_back(buffer);
+        } else {
+           // if (LOGS_ENABLED) DEBUG_D("too much %d buffers", capacity);
+            delete buffer;
+        }
+        if (isThreadSafe) {
+            pthread_mutex_unlock(&mutex);
+        }
+    } else {
+        delete buffer;
+    }
+}

android/app/jni/BuffersStorage.h

@@ -0,0 +1,38 @@
+/*
+ * This is the source code of tgnet library v. 1.1
+ * It is licensed under GNU GPL v. 2 or later.
+ * You should have received a copy of the license in this archive (see LICENSE).
+ *
+ * Copyright Nikolai Kudashov, 2015-2018.
+ */
+
+#ifndef BUFFERSSTORAGE_H
+#define BUFFERSSTORAGE_H
+
+#include <vector>
+#include <pthread.h>
+#include <stdint.h>
+
+class NativeByteBuffer;
+
+class BuffersStorage {
+
+public:
+    BuffersStorage(bool threadSafe);
+    NativeByteBuffer *getFreeBuffer(uint32_t size);
+    void reuseFreeBuffer(NativeByteBuffer *buffer);
+    static BuffersStorage &getInstance();
+
+private:
+    std::vector<NativeByteBuffer *> freeBuffers8;
+    std::vector<NativeByteBuffer *> freeBuffers128;
+    std::vector<NativeByteBuffer *> freeBuffers1024;
+    std::vector<NativeByteBuffer *> freeBuffers4096;
+    std::vector<NativeByteBuffer *> freeBuffers16384;
+    std::vector<NativeByteBuffer *> freeBuffers32768;
+    std::vector<NativeByteBuffer *> freeBuffersBig;
+    bool isThreadSafe = true;
+    pthread_mutex_t mutex;
+};
+
+#endif

android/app/jni/ByteArray.cpp

@@ -0,0 +1,64 @@
+
+#include <stdlib.h>
+#include <memory.h>
+#include "ByteArray.h"
+#include "FileLog.h"
+
+ByteArray::ByteArray() {
+    bytes = nullptr;
+    length = 0;
+}
+
+ByteArray::ByteArray(uint32_t len) {
+    bytes = new uint8_t[len];
+    if (bytes == nullptr) {
+        if (LOGS_ENABLED) DEBUG_E("unable to allocate byte buffer %u", len);
+        exit(1);
+    }
+    length = len;
+}
+
+
+ByteArray::ByteArray(ByteArray *byteArray) {
+    bytes = new uint8_t[byteArray->length];
+    if (bytes == nullptr) {
+        if (LOGS_ENABLED) DEBUG_E("unable to allocate byte buffer %u", byteArray->length);
+        exit(1);
+    }
+    length = byteArray->length;
+    memcpy(bytes, byteArray->bytes, length);
+}
+
+ByteArray::ByteArray(uint8_t *buffer, uint32_t len) {
+    bytes = new uint8_t[len];
+    if (bytes == nullptr) {
+        if (LOGS_ENABLED) DEBUG_E("unable to allocate byte buffer %u", len);
+        exit(1);
+    }
+    length = len;
+    memcpy(bytes, buffer, length);
+}
+
+ByteArray::~ByteArray() {
+    if (bytes != nullptr) {
+        delete[] bytes;
+        bytes = nullptr;
+    }
+}
+
+void ByteArray::alloc(uint32_t len) {
+    if (bytes != nullptr) {
+        delete[] bytes;
+        bytes = nullptr;
+    }
+    bytes = new uint8_t[len];
+    if (bytes == nullptr) {
+        if (LOGS_ENABLED) DEBUG_E("unable to allocate byte buffer %u", len);
+        exit(1);
+    }
+    length = len;
+}
+
+bool ByteArray::isEqualTo(ByteArray *byteArray) {
+    return byteArray->length == length && !memcmp(byteArray->bytes, bytes, length);
+}

android/app/jni/ByteArray.h

@@ -0,0 +1,31 @@
+/*
+ * This is the source code of tgnet library v. 1.1
+ * It is licensed under GNU GPL v. 2 or later.
+ * You should have received a copy of the license in this archive (see LICENSE).
+ *
+ * Copyright Nikolai Kudashov, 2015-2018.
+ */
+
+#ifndef BYTEARRAY_H
+#define BYTEARRAY_H
+
+#include <stdint.h>
+
+class ByteArray {
+
+public:
+    ByteArray();
+    ByteArray(uint32_t len);
+    ByteArray(ByteArray *byteArray);
+    ByteArray(uint8_t *buffer, uint32_t len);
+    ~ByteArray();
+    void alloc(uint32_t len);
+
+    uint32_t length;
+    uint8_t *bytes;
+
+    bool isEqualTo(ByteArray *byteArray);
+
+};
+
+#endif