feature：调整zap模块cmake，引入common的动态库

demo/src/main/java/com/suyghur/dolin/DemoActivity.kt

@@ -8,7 +8,6 @@ import android.view.View
 import android.widget.Button
 import android.widget.LinearLayout
 import android.widget.TextView
-import com.suyghur.dolin.common.util.DeviceInfoUtils
 import com.suyghur.dolin.zap.Zap
 import kotlin.system.exitProcess
 
@@ -29,7 +28,8 @@ class DemoActivity : Activity(), View.OnClickListener {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         initView()
-        initDeviceInfo()
+//        initDeviceInfo()
+//        Zap.d("test : ${Common.testLib()}")
     }
 
     private fun initView() {
@@ -48,18 +48,18 @@ class DemoActivity : Activity(), View.OnClickListener {
         setContentView(layout)
     }
 
-    private fun initDeviceInfo() {
-        val sb = StringBuilder()
-        sb.append("Android ID：").append(DeviceInfoUtils.getAndroidDeviceId(this)).append("\n")
-        sb.append("厂商：").append(DeviceInfoUtils.getDeviceBrand()).append("\n")
-        sb.append("型号：").append(DeviceInfoUtils.getModel()).append("\n")
-        sb.append("系统版本：").append(DeviceInfoUtils.getDeviceSoftWareVersion()).append("\n")
-        sb.append("cpu核数：").append(DeviceInfoUtils.getCpuCount()).append("\n")
-        sb.append("cpu架构：").append(DeviceInfoUtils.getCpuABI()).append("\n")
-        sb.append("本机内存：").append(DeviceInfoUtils.getRAM()).append("\n")
-        sb.append("本机剩余内存：").append(DeviceInfoUtils.getAvailMem(this)).append("M")
-        textView.text = sb.toString()
-    }
+//    private fun initDeviceInfo() {
+//        val sb = StringBuilder()
+//        sb.append("Android ID：").append(DeviceInfoUtils.getAndroidDeviceId(this)).append("\n")
+//        sb.append("厂商：").append(DeviceInfoUtils.getDeviceBrand()).append("\n")
+//        sb.append("型号：").append(DeviceInfoUtils.getModel()).append("\n")
+//        sb.append("系统版本：").append(DeviceInfoUtils.getDeviceSoftWareVersion()).append("\n")
+//        sb.append("cpu核数：").append(DeviceInfoUtils.getCpuCount()).append("\n")
+//        sb.append("cpu架构：").append(DeviceInfoUtils.getCpuABI()).append("\n")
+//        sb.append("本机内存：").append(DeviceInfoUtils.getRAM()).append("\n")
+//        sb.append("本机剩余内存：").append(DeviceInfoUtils.getAvailMem(this)).append("M")
+//        textView.text = sb.toString()
+//    }
 
     override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
         if (keyCode == KeyEvent.KEYCODE_BACK) {

demo/src/main/java/com/suyghur/dolin/ZapActivity.kt

@@ -6,7 +6,6 @@ import android.os.Bundle
 import android.view.View
 import android.widget.Button
 import android.widget.LinearLayout
-import com.suyghur.dolin.common.util.DeviceInfoUtils
 import com.suyghur.dolin.zap.Zap
 
 /**
@@ -35,7 +34,6 @@ class ZapActivity : Activity(), View.OnClickListener {
             }
         }
         setContentView(layout)
-        Zap.d("free RAM : ${DeviceInfoUtils.getAvailMem(this)}M")
     }
 
     override fun onClick(v: View?) {

library_common/.gitignore

@@ -1 +1,2 @@
-/build
+/build
+.cxx

library_common/CMakeLists.txt

@@ -0,0 +1,43 @@
+# For more information about using CMake with Android Studio, read the
+# documentation: https://d.android.com/studio/projects/add-native-code.html
+
+# Sets the minimum version of CMake required to build the native library.
+
+cmake_minimum_required(VERSION 3.4.1)
+
+# Creates and names a library, sets it as either STATIC
+# or SHARED, and provides the relative paths to its source code.
+# You can define multiple libraries, and CMake builds them for you.
+# Gradle automatically packages shared libraries with your APK.
+
+include_directories(src/main/cpp/include)
+aux_source_directory(src/main/cpp/ DIR_SOURCE)
+#add_subdirectory(common)
+#include_directories(src/main/cpp/common)
+add_library(
+        dolin-common
+        SHARED
+        ${DIR_SOURCE}
+)
+
+# Searches for a specified prebuilt library and stores the path as a
+# variable. Because CMake includes system libraries in the search path by
+# default, you only need to specify the name of the public NDK library
+# you want to add. CMake verifies that the library exists before
+# completing its build.
+
+find_library( # Sets the name of the path variable.
+        log-lib
+        # Specifies the name of the NDK library that
+        # you want CMake to locate.
+        log)
+
+# Specifies libraries CMake should link to your target library. You
+# can link multiple libraries, such as libraries you define in this
+# build script, prebuilt third-party libraries, or system libraries.
+
+target_link_libraries( # Specifies the target library.
+        dolin-common
+        # Links the target library to the log library
+        # included in the NDK.
+        ${log-lib})

library_common/build.gradle

@@ -7,10 +7,16 @@ android {
     compileSdkVersion COMPILE_SDK_VERSION
     buildToolsVersion BUILD_TOOLS_VERSION
 
-
     defaultConfig {
         minSdkVersion MIN_SDK_VERSION
         targetSdkVersion TARGET_SDK_VERSION
+
+//        externalNativeBuild {
+//            cmake {
+//                cppFlags '-std=c++11 -frtti -fexceptions -lz'
+//                abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
+//            }
+//        }
     }
 
     buildTypes {
@@ -20,6 +26,8 @@ android {
         }
     }
 
+    ndkVersion NDK_VERSION
+
     buildFeatures {
         buildConfig = false
     }
@@ -37,6 +45,12 @@ android {
     dexOptions {
         preDexLibraries = false
     }
+
+//    externalNativeBuild {
+//        cmake {
+//            path "CMakeLists.txt"
+//        }
+//    }
 }
 
 dependencies {

library_common/src/main/cpp/common.cpp

@@ -0,0 +1,31 @@
+//
+// Created by #Suyghur, on 4/13/21.
+//
+
+#include <jni.h>
+#include "common.h"
+
+std::string Common::TestFunc() {
+    return "test func";
+}
+
+//static jstring TestLib(JNIEnv *env, jobject thiz) {
+//    return env->NewStringUTF(Common::TestFunc().c_str());
+//}
+//
+//static JNINativeMethod gMethods[] = {
+//        {"testLib", "()Ljava/lang/String;", (void *) TestLib}
+//
+//};
+//
+//extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
+//    JNIEnv *env = nullptr;
+//    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
+//        return JNI_ERR;
+//    }
+//    jclass clz = env->FindClass("com/suyghur/dolin/common/Common");
+//    if (env->RegisterNatives(clz, gMethods, sizeof(gMethods) / sizeof(gMethods[0])) < 0) {
+//        return JNI_ERR;
+//    }
+//    return JNI_VERSION_1_6;
+//}

library_common/src/main/cpp/common.h

@@ -0,0 +1,17 @@
+//
+// Created by #Suyghur, on 4/13/21.
+//
+
+#ifndef DOLIN_COMMON_H
+#define DOLIN_COMMON_H
+
+
+#include <string>
+
+class Common {
+public:
+    static std::string TestFunc();
+};
+
+
+#endif //DOLIN_COMMON_H

library_common/src/main/java/com/suyghur/dolin/common/Common.kt

@@ -4,5 +4,11 @@ package com.suyghur.dolin.common
  * @author #Suyghur.
  * Created on 4/12/21
  */
-class Common {
+object Common {
+
+    init {
+        System.loadLibrary("dolin-common")
+    }
+
+    external fun testLib(): String
 }

library_zap/CMakeLists.txt

@@ -10,14 +10,25 @@ cmake_minimum_required(VERSION 3.4.1)
 # You can define multiple libraries, and CMake builds them for you.
 # Gradle automatically packages shared libraries with your APK.
 
+include_directories(src/main/cpp/include)
 aux_source_directory(src/main/cpp/ DIR_SOURCE)
-include_directories(src/main/cpp/includes)
 add_library(
-        zap
+        dolin-zap
         SHARED
         ${DIR_SOURCE}
 )
 
+#动态方式加载 STATIC：表示静态的.a的库 SHARED：表示.so的库
+add_library(dolin-common SHARED IMPORTED)
+
+#设置要连接的so的相对路径
+#${CMAKE_SOURCE_DIR}：表示CMake.txt的当前文件夹路径
+#${ANDROID_ABI}：编译时会自动根据CPU架构去选择相应的库
+set_target_properties(dolin-common PROPERTIES IMPORTED_LOCATION ${CMAKE_SOURCE_DIR}/src/main/cpp/libs/${ANDROID_ABI}/libdolin-common.so)
+
+##添加第三方头文件
+target_include_directories(dolin-zap PRIVATE ${CMAKE_SOURCE_DIR}/src/main/cpp/third_part)
+
 # Searches for a specified prebuilt library and stores the path as a
 # variable. Because CMake includes system libraries in the search path by
 # default, you only need to specify the name of the public NDK library
@@ -35,7 +46,8 @@ find_library( # Sets the name of the path variable.
 # build script, prebuilt third-party libraries, or system libraries.
 
 target_link_libraries( # Specifies the target library.
-        zap
+        dolin-zap
+        dolin-common
         # Links the target library to the log library
         # included in the NDK.
         ${log-lib})

library_zap/build.gradle

@@ -51,6 +51,13 @@ android {
             path "CMakeLists.txt"
         }
     }
+
+//    sourceSets {
+//        main {
+//            // let gradle pack the shared library into apk
+//            jniLibs.srcDirs = ['src/main/jniLibs']
+//        }
+//    }
 }
 
 dependencies {

library_zap/src/main/cpp/buffer.cpp

@@ -2,49 +2,49 @@
 // Created by #Suyghur, on 4/7/21.
 //
 
-#include "includes/buffer.h"
+#include "include/buffer.h"
 
 Buffer::Buffer(char *ptr, size_t buffer_size) : buffer_ptr(ptr), buffer_size(buffer_size), buffer_header(buffer_ptr, buffer_size) {}
 
 Buffer::~Buffer() {
-    release();
+    Release();
 }
 
-void Buffer::initData(char *log_path, size_t log_path_len, bool compress) {
+void Buffer::InitData(char *log_path, size_t log_path_len, bool _compress) {
     std::lock_guard<std::recursive_mutex> lck_release(log_mtx);
     memset(buffer_ptr, '\0', buffer_size);
 
-    buffer_header::Header header{};
+    zap::Header header{};
     header.magic = kMagicHeader;
     header.log_path_len = log_path_len;
     header.log_path = log_path;
     header.log_len = 0;
-    header.compress = compress;
+    header.compress = _compress;
 
-    buffer_header.initHeader(header);
-    initCompress(compress);
+    buffer_header.InitHeader(header);
+    InitCompress(_compress);
 
-    data_ptr = (char *) buffer_header.getPtr();
-    write_ptr = (char *) buffer_header.getWritePtr();
+    data_ptr = (char *) buffer_header.GetPtr();
+    write_ptr = (char *) buffer_header.GetWritePtr();
 
-    openLogFile(log_path);
+    OpenLogFile(log_path);
 }
 
-void Buffer::setLength(size_t len) {
-    buffer_header.setLogLen(len);
+void Buffer::SetLength(size_t len) {
+    buffer_header.SetLogLen(len);
 }
 
-size_t Buffer::getLength() {
+size_t Buffer::GetLength() {
     return write_ptr - data_ptr;
 }
 
-size_t Buffer::append(const char *log, size_t len) {
+size_t Buffer::Append(const char *log, size_t len) {
     std::lock_guard<std::recursive_mutex> lck_append(log_mtx);
-    if (getLength() == 0) {
-        initCompress(compress);
+    if (GetLength() == 0) {
+        InitCompress(compress);
     }
 
-    size_t free_size = emptySize();
+    size_t free_size = EmptySize();
     size_t write_size;
     if (compress) {
         zStream.avail_in = (uInt) len;
@@ -63,11 +63,11 @@ size_t Buffer::append(const char *log, size_t len) {
         memcpy(write_ptr, log, write_size);
     }
     write_ptr += write_size;
-    setLength(getLength());
+    SetLength(GetLength());
     return write_size;
 }
 
-void Buffer::release() {
+void Buffer::Release() {
     std::lock_guard<std::recursive_mutex> lck_release(log_mtx);
     if (compress && Z_NULL != zStream.state) {
         deflateEnd(&zStream);
@@ -82,27 +82,27 @@ void Buffer::release() {
     }
 }
 
-size_t Buffer::emptySize() {
+size_t Buffer::EmptySize() {
     return buffer_size - (write_ptr - buffer_ptr);
 }
 
-char *Buffer::getLogPath() {
-    return buffer_header.getLogPath();
+char *Buffer::GetLogPath() {
+    return buffer_header.GetLogPath();
 }
 
-void Buffer::setFileFlush(FileFlush *flush) {
+void Buffer::SetFileFlush(FileFlush *flush) {
     file_flush_ptr = flush;
 }
 
-void Buffer::callFileFlush() {
-    callFileFlush(file_flush_ptr);
+void Buffer::CallFileFlush() {
+    CallFileFlush(file_flush_ptr);
 }
 
-void Buffer::callFileFlush(FileFlush *flush) {
-    callFileFlush(flush, nullptr);
+void Buffer::CallFileFlush(FileFlush *flush) {
+    CallFileFlush(flush, nullptr);
 }
 
-void Buffer::callFileFlush(FileFlush *flush, Buffer *buffer) {
+void Buffer::CallFileFlush(FileFlush *flush, Buffer *buffer) {
     if (flush == nullptr) {
         if (buffer != nullptr) {
             delete buffer;
@@ -111,36 +111,36 @@ void Buffer::callFileFlush(FileFlush *flush, Buffer *buffer) {
     }
 
     std::lock_guard<std::recursive_mutex> lck_flush(log_mtx);
-    if (getLength() > 0) {
+    if (GetLength() > 0) {
         if (compress && Z_NULL != zStream.state) {
             deflateEnd(&zStream);
         }
         auto *buffer_flush = new BufferFlush(log_file_ptr);
-        buffer_flush->write(data_ptr, getLength());
-        buffer_flush->releaseThiz(buffer);
-        clear();
-        flush->asyncFlush(buffer_flush);
+        buffer_flush->Write(data_ptr, GetLength());
+        buffer_flush->ReleaseThiz(buffer);
+        Clear();
+        flush->AsyncFlush(buffer_flush);
     } else {
         delete buffer;
     }
 }
 
-void Buffer::changeLogPath(char *path) {
+void Buffer::ChangeLogPath(char *path) {
     if (log_file_ptr != nullptr) {
-        callFileFlush();
+        CallFileFlush();
     }
-    initData(path, strlen(path), compress);
+    InitData(path, strlen(path), compress);
 }
 
-void Buffer::clear() {
+void Buffer::Clear() {
     std::lock_guard<std::recursive_mutex> lck_clear(log_mtx);
     write_ptr = data_ptr;
-    memset(write_ptr, '\0', emptySize());
-    setLength(getLength());
+    memset(write_ptr, '\0', EmptySize());
+    SetLength(GetLength());
 }
 
-bool Buffer::initCompress(bool is_compress) {
-    compress = is_compress;
+bool Buffer::InitCompress(bool is_compress) {
+    compress = compress;
     if (compress) {
         zStream.zalloc = Z_NULL;
         zStream.zfree = Z_NULL;
@@ -150,7 +150,7 @@ bool Buffer::initCompress(bool is_compress) {
     return false;
 }
 
-bool Buffer::openLogFile(const char *path) {
+bool Buffer::OpenLogFile(const char *path) {
     if (path != nullptr) {
         FILE *file = fopen(path, "ab+");
         if (file != nullptr) {

library_zap/src/main/cpp/buffer_flush.cpp

@@ -4,7 +4,7 @@
 
 #include <cmath>
 #include <cstring>
-#include "includes/buffer_flush.h"
+#include "include/buffer_flush.h"
 
 BufferFlush::BufferFlush(FILE *log_file, size_t size) : capacity(size), log_file_ptr(log_file) {}
 
@@ -22,19 +22,19 @@ BufferFlush::~BufferFlush() {
 /**
  * 填充缓存
  */
-void BufferFlush::write(void *data, size_t len) {
+void BufferFlush::Write(void *data, size_t len) {
     if (data_ptr == nullptr) {
         capacity = (size_t) fmax(capacity, len);
         data_ptr = new char[capacity]{0};
         write_ptr = data_ptr;
     }
 
-    size_t empty_size = emptySize();
+    size_t empty_size = EmptySize();
     if (len < empty_size) {
         memcpy(write_ptr, data, len);
         write_ptr += len;
     } else {
-        size_t now_len = getLength();
+        size_t now_len = GetLength();
         size_t new_capacity = now_len + len;
         char *data_tmp = new char[new_capacity]{0};
         memcpy(data_tmp, data_ptr, now_len);
@@ -46,32 +46,32 @@ void BufferFlush::write(void *data, size_t len) {
     }
 }
 
-void BufferFlush::reset() {
+void BufferFlush::Reset() {
     if (data_ptr != nullptr) {
         memset(data_ptr, 0, capacity);
         write_ptr = data_ptr;
     }
 }
 
-size_t BufferFlush::getLength() {
+size_t BufferFlush::GetLength() {
     if (data_ptr != nullptr && write_ptr != nullptr) {
         return write_ptr - data_ptr;
     }
     return 0;
 }
 
-void *BufferFlush::getPtr() {
+void *BufferFlush::GetPtr() {
     return data_ptr;
 }
 
-FILE *BufferFlush::getLogFile() {
+FILE *BufferFlush::GetLogFile() {
     return log_file_ptr;
 }
 
-void BufferFlush::releaseThiz(void *buffer) {
+void BufferFlush::ReleaseThiz(void *buffer) {
     this->release_ptr = buffer;
 }
 
-size_t BufferFlush::emptySize() {
-    return capacity - getLength();
+size_t BufferFlush::EmptySize() {
+    return capacity - GetLength();
 }

library_zap/src/main/cpp/buffer_header.cpp

@@ -2,13 +2,13 @@
 // Created by #Suyghur, on 4/7/21.
 //
 
-#include "includes/buffer_header.h"
+#include "include/buffer_header.h"
 
-buffer_header::BufferHeader::BufferHeader(void *data, size_t size) : data_ptr((char *) data), data_size(size) {}
+zap::BufferHeader::BufferHeader(void *data, size_t size) : data_ptr((char *) data), data_size(size) {}
 
-buffer_header::BufferHeader::~BufferHeader() = default;
+zap::BufferHeader::~BufferHeader() = default;
 
-void buffer_header::BufferHeader::initHeader(buffer_header::Header &header) {
+void zap::BufferHeader::InitHeader(zap::Header &header) {
     if ((sizeof(char) + sizeof(size_t) + sizeof(size_t) + header.log_path_len) > data_size) {
         return;
     }
@@ -26,27 +26,27 @@ void buffer_header::BufferHeader::initHeader(buffer_header::Header &header) {
 /**
  * 获取原始的锚点
  */
-void *buffer_header::BufferHeader::getOriginPtr() {
+void *zap::BufferHeader::GetOriginPtr() {
     return data_ptr;
 }
 
 /**
  * 获取当前锚点
  */
-void *buffer_header::BufferHeader::getPtr() {
-    return data_ptr + getHeaderLen();
+void *zap::BufferHeader::GetPtr() {
+    return data_ptr + GetHeaderLen();
 }
 
 /**
  * 获取写入的锚点
  */
-void *buffer_header::BufferHeader::getWritePtr() {
-    return data_ptr + getHeaderLen() + getLogLen();
+void *zap::BufferHeader::GetWritePtr() {
+    return data_ptr + GetHeaderLen() + GetLogLen();
 }
 
-buffer_header::Header *buffer_header::BufferHeader::getHeader() {
+zap::Header *zap::BufferHeader::GetHeader() {
     auto *header = new Header();
-    if (isAvailable()) {
+    if (IsAvailable()) {
         header->magic = kMagicHeader;
 
         size_t log_len = 0;
@@ -68,46 +68,46 @@ buffer_header::Header *buffer_header::BufferHeader::getHeader() {
     return header;
 }
 
-size_t buffer_header::BufferHeader::getHeaderLen() {
-    if (isAvailable()) {
-        return calculateHeaderLen(getLogPathLen());
+size_t zap::BufferHeader::GetHeaderLen() {
+    if (IsAvailable()) {
+        return CalculateHeaderLen(GetLogPathLen());
     }
     return 0;
 }
 
-void buffer_header::BufferHeader::setLogLen(size_t len) {
-    if (isAvailable()) {
+void zap::BufferHeader::SetLogLen(size_t len) {
+    if (IsAvailable()) {
         memcpy(data_ptr + sizeof(char), &len, sizeof(size_t));
     }
 }
 
-size_t buffer_header::BufferHeader::getLogLen() {
-    if (isAvailable()) {
+size_t zap::BufferHeader::GetLogLen() {
+    if (IsAvailable()) {
         size_t len = 0;
         memcpy(&len, data_ptr + sizeof(char), sizeof(size_t));
         //log长度总是大于0并小于buffer_size减去header长度的
-        if (len > 0 && len < (data_size - getHeaderLen())) {
+        if (len > 0 && len < (data_size - GetHeaderLen())) {
             return len;
         }
     }
     return 0;
 }
 
-size_t buffer_header::BufferHeader::getLogPathLen() {
-    if (isAvailable()) {
+size_t zap::BufferHeader::GetLogPathLen() {
+    if (IsAvailable()) {
         size_t len = 0;
         memcpy(&len, data_ptr + sizeof(char) + sizeof(size_t), sizeof(size_t));
         //log path 的长度不能大于整个buffer减去header中其他数据的长度
-        if (len > 0 && len < data_size - calculateHeaderLen(0)) {
+        if (len > 0 && len < data_size - CalculateHeaderLen(0)) {
             return len;
         }
     }
     return 0;
 }
 
-char *buffer_header::BufferHeader::getLogPath() {
-    if (isAvailable()) {
-        size_t log_path_len = getLogPathLen();
+char *zap::BufferHeader::GetLogPath() {
+    if (IsAvailable()) {
+        size_t log_path_len = GetLogPathLen();
         if (log_path_len > 0) {
             char *log_path = new char[log_path_len + 1];
             memset(log_path, 0, log_path_len + 1);
@@ -119,18 +119,18 @@ char *buffer_header::BufferHeader::getLogPath() {
 }
 
 
-bool buffer_header::BufferHeader::isCompress() {
-    if (isAvailable()) {
-        return ((data_ptr + sizeof(char) + sizeof(size_t) + sizeof(size_t) + getLogPathLen())[0]) == 1;
+bool zap::BufferHeader::IsCompress() {
+    if (IsAvailable()) {
+        return ((data_ptr + sizeof(char) + sizeof(size_t) + sizeof(size_t) + GetLogPathLen())[0]) == 1;
     }
     return false;
 }
 
-bool buffer_header::BufferHeader::isAvailable() {
+bool zap::BufferHeader::IsAvailable() {
     return data_ptr[0] == kMagicHeader;
 }
 
-size_t buffer_header::BufferHeader::calculateHeaderLen(size_t path_len) {
+size_t zap::BufferHeader::CalculateHeaderLen(size_t path_len) {
     return sizeof(char) + sizeof(size_t) + sizeof(size_t) + path_len + sizeof(char);
 }
 

library_zap/src/main/cpp/file_flush.cpp

@@ -2,17 +2,17 @@
 // Created by #Suyghur, on 4/7/21.
 //
 
-#include "includes/file_flush.h"
+#include "include/file_flush.h"
 
 FileFlush::FileFlush() {
-    async_thread = std::thread(&FileFlush::asyncLogThread, this);
+    async_thread = std::thread(&FileFlush::AsyncLogThread, this);
 }
 
 FileFlush::~FileFlush() {
-    stopFlush();
+    StopFlush();
 }
 
-bool FileFlush::asyncFlush(BufferFlush *buffer) {
+bool FileFlush::AsyncFlush(BufferFlush *buffer) {
     std::unique_lock<std::mutex> lck_async_flush(async_mtx);
     if (exit) {
         delete buffer;
@@ -23,19 +23,19 @@ bool FileFlush::asyncFlush(BufferFlush *buffer) {
     return true;
 }
 
-void FileFlush::stopFlush() {
+void FileFlush::StopFlush() {
     exit = true;
     async_condition.notify_all();
     async_thread.join();
 }
 
-void FileFlush::asyncLogThread() {
+void FileFlush::AsyncLogThread() {
     while (true) {
         std::unique_lock<std::mutex> lck_async_log_thread(async_mtx);
         while (!async_buffer.empty()) {
             BufferFlush *data = async_buffer.back();
             async_buffer.pop_back();
-            flush(data);
+            Flush(data);
         }
         if (exit) {
             return;
@@ -47,11 +47,11 @@ void FileFlush::asyncLogThread() {
 /**
  * 写文件
  */
-ssize_t FileFlush::flush(BufferFlush *buffer) {
+ssize_t FileFlush::Flush(BufferFlush *buffer) {
     ssize_t written = 0;
-    FILE *log_file = buffer->getLogFile();
-    if (log_file != nullptr && buffer->getLength() > 0) {
-        written = fwrite(buffer->getPtr(), buffer->getLength(), 1, log_file);
+    FILE *log_file = buffer->GetLogFile();
+    if (log_file != nullptr && buffer->GetLength() > 0) {
+        written = fwrite(buffer->GetPtr(), buffer->GetLength(), 1, log_file);
         fflush(log_file);
     }
     delete buffer;

library_zap/src/main/cpp/includes/buffer.h → library_zap/src/main/cpp/include/buffer.h

@@ -12,7 +12,7 @@
 #include "buffer_header.h"
 #include "file_flush.h"
 
-using namespace buffer_header;
+using namespace zap;
 
 class Buffer {
 public:
@@ -23,27 +23,27 @@ public:
 
     ~Buffer();
 
-    void initData(char *log_path, size_t log_path_len, bool compress);
+    void InitData(char *log_path, size_t log_path_len, bool _compress);
 
-    size_t getLength();
+    size_t GetLength();
 
-    size_t append(const char *log, size_t len);
+    size_t Append(const char *log, size_t len);
 
-    void release();
+    void Release();
 
-    size_t emptySize();
+    size_t EmptySize();
 
-    char *getLogPath();
+    char *GetLogPath();
 
-    void setFileFlush(FileFlush *flush);
+    void SetFileFlush(FileFlush *flush);
 
-    void callFileFlush();
+    void CallFileFlush();
 
-    void callFileFlush(FileFlush *flush);
+    void CallFileFlush(FileFlush *flush);
 
-    void callFileFlush(FileFlush *flush, Buffer *buffer);
+    void CallFileFlush(FileFlush *flush, Buffer *buffer);
 
-    void changeLogPath(char *path);
+    void ChangeLogPath(char *path);
 
 private:
     FILE *log_file_ptr = nullptr;
@@ -59,13 +59,13 @@ private:
     z_stream zStream{};
     bool compress = false;
 
-    void clear();
+    void Clear();
 
-    void setLength(size_t len);
+    void SetLength(size_t len);
 
-    bool initCompress(bool compress);
+    bool InitCompress(bool compress);
 
-    bool openLogFile(const char *path);
+    bool OpenLogFile(const char *path);
 
 
 };

library_zap/src/main/cpp/includes/buffer_flush.h → library_zap/src/main/cpp/include/buffer_flush.h

@@ -15,17 +15,17 @@ public:
 
     ~BufferFlush();
 
-    void write(void *data, size_t len);
+    void Write(void *data, size_t len);
 
-    void reset();
+    void Reset();
 
-    size_t getLength();
+    size_t GetLength();
 
-    void *getPtr();
+    void *GetPtr();
 
-    FILE *getLogFile();
+    FILE *GetLogFile();
 
-    void releaseThiz(void *buffer);
+    void ReleaseThiz(void *buffer);
 
 private:
     FILE *log_file_ptr = nullptr;
@@ -34,7 +34,7 @@ private:
     char *write_ptr = nullptr;
     size_t capacity;
 
-    size_t emptySize();
+    size_t EmptySize();
 };
 
 

library_zap/src/main/cpp/includes/buffer_header.h → library_zap/src/main/cpp/include/buffer_header.h

@@ -7,7 +7,7 @@
 
 #include <string>
 
-namespace buffer_header {
+namespace zap {
     static const char kMagicHeader = '\x11';
 
     struct Header {
@@ -24,31 +24,31 @@ namespace buffer_header {
 
         ~BufferHeader();
 
-        void initHeader(Header &header);
+        void InitHeader(Header &header);
 
-        void *getOriginPtr();
+        void *GetOriginPtr();
 
-        void *getPtr();
+        void *GetPtr();
 
-        void *getWritePtr();
+        void *GetWritePtr();
 
-        Header *getHeader();
+        Header *GetHeader();
 
-        size_t getHeaderLen();
+        size_t GetHeaderLen();
 
-        void setLogLen(size_t len);
+        void SetLogLen(size_t len);
 
-        size_t getLogLen();
+        size_t GetLogLen();
 
-        size_t getLogPathLen();
+        size_t GetLogPathLen();
 
-        char *getLogPath();
+        char *GetLogPath();
 
-        bool isCompress();
+        bool IsCompress();
 
-        bool isAvailable();
+        bool IsAvailable();
 
-        static size_t calculateHeaderLen(size_t path_len);
+        static size_t CalculateHeaderLen(size_t path_len);
 
     private:
         char *data_ptr;

library_zap/src/main/cpp/includes/file_flush.h → library_zap/src/main/cpp/include/file_flush.h

@@ -16,14 +16,14 @@ public:
 
     ~FileFlush();
 
-    bool asyncFlush(BufferFlush *buffer);
+    bool AsyncFlush(BufferFlush *buffer);
 
-    void stopFlush();
+    void StopFlush();
 
 private:
-    void asyncLogThread();
+    void AsyncLogThread();
 
-    static ssize_t flush(BufferFlush *buffer);
+    static ssize_t Flush(BufferFlush *buffer);
 
     bool exit = false;
     std::vector<BufferFlush *> async_buffer;

library_zap/src/main/cpp/third_part/common.h

@@ -0,0 +1,17 @@
+//
+// Created by #Suyghur, on 4/13/21.
+//
+
+#ifndef DOLIN_COMMON_H
+#define DOLIN_COMMON_H
+
+
+#include <string>
+
+class Common {
+public:
+    static std::string TestFunc();
+};
+
+
+#endif //DOLIN_COMMON_H

library_zap/src/main/cpp/zap.cpp

@@ -6,24 +6,25 @@
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sstream>
-#include "includes/buffer.h"
-#include "includes/file_flush.h"
-#include "includes/buffer_header.h"
+#include "include/buffer.h"
+#include "include/file_flush.h"
+#include "include/buffer_header.h"
+#include "third_part/common.h"
 
-static FileFlush *p_file_flush = nullptr;
+static FileFlush *pFileFlush = nullptr;
 
-static void writeDirty2File(int buffer_fd) {
+static void WriteDirty2File(int buffer_fd) {
     struct stat file_stat{};
     if (fstat(buffer_fd, &file_stat) >= 0) {
         auto buffer_size = static_cast<size_t>(file_stat.st_size);
         //buffer size必须大于文件头长度，否则下标溢出
-        if (buffer_size > buffer_header::BufferHeader::calculateHeaderLen(0)) {
+        if (buffer_size > zap::BufferHeader::CalculateHeaderLen(0)) {
             char *buffer_ptr_tmp = (char *) mmap(0, buffer_size, PROT_WRITE | PROT_READ, MAP_SHARED, buffer_fd, 0);
             if (buffer_ptr_tmp != MAP_FAILED) {
                 auto *tmp = new Buffer(buffer_ptr_tmp, buffer_size);
-                size_t data_size = tmp->getLength();
+                size_t data_size = tmp->GetLength();
                 if (data_size > 0) {
-                    tmp->callFileFlush(p_file_flush, tmp);
+                    tmp->CallFileFlush(pFileFlush, tmp);
                 } else {
                     delete tmp;
                 }
@@ -32,11 +33,11 @@ static void writeDirty2File(int buffer_fd) {
     }
 }
 
-static char *openMMap(int buffer_fd, size_t buffer_size) {
+static char *OpenMMap(int buffer_fd, size_t buffer_size) {
     char *map_ptr = nullptr;
     if (buffer_fd != -1) {
         //写脏数据
-        writeDirty2File(buffer_fd);
+        WriteDirty2File(buffer_fd);
         //根据buffer size 调整 buffer 大小
         ftruncate(buffer_fd, static_cast<int >(buffer_size));
         lseek(buffer_fd, 0, SEEK_SET);
@@ -49,19 +50,19 @@ static char *openMMap(int buffer_fd, size_t buffer_size) {
 }
 
 
-static jlong initNative(JNIEnv *env, jobject thiz, jstring buffer_path, jint capacity,
+static jlong InitNative(JNIEnv *env, jclass thiz, jstring buffer_path, jint capacity,
                         jstring log_path, jboolean compress) {
     const char *_buffer_path = env->GetStringUTFChars(buffer_path, JNI_FALSE);
     const char *_log_path = env->GetStringUTFChars(log_path, JNI_FALSE);
     auto buffer_size = static_cast<size_t>(capacity);
     int buffer_fd = open(_buffer_path, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
     //buffer ["路径的长度","路径","内容"], 参考mmkv格式
-    if (p_file_flush == nullptr) {
-        p_file_flush = new FileFlush();
+    if (pFileFlush == nullptr) {
+        pFileFlush = new FileFlush();
     }
     //加上头信息占用的大小
-    buffer_size = buffer_size + BufferHeader::calculateHeaderLen(strlen(_log_path));
-    char *buffer_ptr = openMMap(buffer_fd, buffer_size);
+    buffer_size = buffer_size + BufferHeader::CalculateHeaderLen(strlen(_log_path));
+    char *buffer_ptr = OpenMMap(buffer_fd, buffer_size);
 
     bool map_buffer = true;
     //如果打开 mmap 失败，则降级使用内存缓存
@@ -71,9 +72,9 @@ static jlong initNative(JNIEnv *env, jobject thiz, jstring buffer_path, jint cap
     }
 
     auto *buffer = new Buffer(buffer_ptr, buffer_size);
-    buffer->callFileFlush(p_file_flush);
+    buffer->CallFileFlush(pFileFlush);
     //将 buffer 中的数据清空，并写入日志文件信息
-    buffer->initData((char *) _log_path, strlen(_log_path), compress);
+    buffer->InitData((char *) _log_path, strlen(_log_path), compress);
     buffer->map_buffer = map_buffer;
 
     env->ReleaseStringUTFChars(buffer_path, _buffer_path);
@@ -81,51 +82,56 @@ static jlong initNative(JNIEnv *env, jobject thiz, jstring buffer_path, jint cap
     return reinterpret_cast<long >(buffer);
 }
 
-static void writeNative(JNIEnv *env, jobject thiz, jlong ptr, jstring msg) {
+static void WriteNative(JNIEnv *env, jobject thiz, jlong ptr, jstring msg) {
     const char *_msg = env->GetStringUTFChars(msg, JNI_FALSE);
     jsize msg_len = env->GetStringUTFLength(msg);
     auto *buffer = reinterpret_cast<Buffer *>(ptr);
     //缓存写满时异步刷新
-    if (msg_len >= buffer->emptySize()) {
-        if (p_file_flush != nullptr) {
-            buffer->callFileFlush(p_file_flush);
+    if (msg_len >= buffer->EmptySize()) {
+        if (pFileFlush != nullptr) {
+            buffer->CallFileFlush(pFileFlush);
         }
     }
-    buffer->append(_msg, (size_t) msg_len);
+    buffer->Append(_msg, (size_t) msg_len);
     env->ReleaseStringUTFChars(msg, _msg);
 }
 
-static void asyncFlushNative(JNIEnv *env, jobject thiz, jlong ptr) {
+static void AsyncFlushNative(JNIEnv *env, jobject thiz, jlong ptr) {
     auto *buffer = reinterpret_cast<Buffer *>(ptr);
-    if (p_file_flush != nullptr) {
-        buffer->callFileFlush(p_file_flush);
+    if (pFileFlush != nullptr) {
+        buffer->CallFileFlush(pFileFlush);
     }
 }
 
-static void changeLogPathNative(JNIEnv *env, jobject thiz, jlong ptr, jstring path) {
+static void ChangeLogPathNative(JNIEnv *env, jobject thiz, jlong ptr, jstring path) {
     const char *log_path = env->GetStringUTFChars(path, JNI_FALSE);
     auto *buffer = reinterpret_cast<Buffer *>(ptr);
-    buffer->changeLogPath(const_cast<charf *>(log_path));
+    buffer->ChangeLogPath(const_cast<charf *>(log_path));
     env->ReleaseStringUTFChars(path, log_path);
 }
 
-static void releaseNative(JNIEnv *env, jobject thiz, jlong ptr) {
+static void ReleaseNative(JNIEnv *env, jobject thiz, jlong ptr) {
     auto *buffer = reinterpret_cast<Buffer *>(ptr);
-    buffer->callFileFlush(p_file_flush, buffer);
-    if (p_file_flush != nullptr) {
-        delete p_file_flush;
+    buffer->CallFileFlush(pFileFlush, buffer);
+    if (pFileFlush != nullptr) {
+        delete pFileFlush;
     }
-    p_file_flush = nullptr;
+    pFileFlush = nullptr;
 }
 
 
-static JNINativeMethod gMethods[] = {
-        {"initNative",          "(Ljava/lang/String;ILjava/lang/String;Z)J", (void *) initNative},
-        {"writeNative",         "(JLjava/lang/String;)V",                    (void *) writeNative},
-        {"asyncFlushNative",    "(J)V",                                      (void *) asyncFlushNative},
-        {"changeLogPathNative", "(JLjava/lang/String;)V",                    (void *) changeLogPathNative},
-        {"releaseNative",       "(J)V",                                      (void *) releaseNative},
+static jstring TestCommonLib(JNIEnv *env, jobject thiz, jlong ptr) {
+
+    return env->NewStringUTF(Common::TestFunc().c_str());
+}
 
+static JNINativeMethod gMethods[] = {
+        {"initNative",          "(Ljava/lang/String;ILjava/lang/String;Z)J", (void *) InitNative},
+        {"writeNative",         "(JLjava/lang/String;)V",                    (void *) WriteNative},
+        {"asyncFlushNative",    "(J)V",                                      (void *) AsyncFlushNative},
+        {"changeLogPathNative", "(JLjava/lang/String;)V",                    (void *) ChangeLogPathNative},
+        {"releaseNative",       "(J)V",                                      (void *) ReleaseNative},
+        {"testCommonLib",             "(J)Ljava/lang/String;",                     (void *) TestCommonLib}
 };
 
 extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {

library_zap/src/main/java/com/suyghur/dolin/zap/impl/Record2MMap.kt

@@ -1,5 +1,6 @@
 package com.suyghur.dolin.zap.impl
 
+import android.util.Log
 import com.suyghur.dolin.zap.internal.IRecord
 
 /**
@@ -12,7 +13,7 @@ class Record2MMap(bufferPath: String, capacity: Int, logPath: String, compress:
     private var ptr = 0L
 
     init {
-        System.loadLibrary("zap")
+        System.loadLibrary("dolin-zap")
         try {
             ptr = initNative(bufferPath, capacity, logPath, compress)
         } catch (e: Exception) {
@@ -23,6 +24,7 @@ class Record2MMap(bufferPath: String, capacity: Int, logPath: String, compress:
     override fun write(msg: String) {
         if (ptr != 0L) {
             try {
+                Log.d("dolin_zap", "test : ${testCommonLib(ptr)}")
                 writeNative(ptr, msg)
             } catch (e: Exception) {
                 e.printStackTrace()
@@ -68,6 +70,8 @@ class Record2MMap(bufferPath: String, capacity: Int, logPath: String, compress:
 
     private external fun releaseNative(ptr: Long)
 
+    private external fun testCommonLib(ptr: Long): String
+
     companion object {
         @JvmStatic
         private external fun initNative(bufferPath: String, capacity: Int, logPath: String, compress: Boolean): Long