react-native-nitro-sqlite 8.2.1-nitro.1

package/RNNitroSQLite.podspec

@@ -0,0 +1,59 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+# TODO: Should be customizable in package.json.
+# Used to create comparable benchmark results
+performance_mode = 1
+
+Pod::Spec.new do |s|
+  s.name         = "RNNitroSQLite"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => "1.0" }
+  s.source       = { :git => "https://github.com/margelo/react-native-nitro-sqlite.git", :tag => "#{s.version}" }
+
+  s.pod_target_xcconfig = {
+    :GCC_PREPROCESSOR_DEFINITIONS => "HAVE_FULLFSYNC=1",
+    :WARNING_CFLAGS => "-Wno-shorten-64-to-32 -Wno-comma -Wno-unreachable-code -Wno-conditional-uninitialized -Wno-deprecated-declarations",
+    :USE_HEADERMAP => "No",
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20',
+    'CLANG_CXX_LIBRARY' => 'libc++'
+  }
+
+  # s.header_mappings_dir = "cpp"
+  s.source_files = "ios/**/*.{h,hpp,m,mm}", "cpp/**/*.{h,hpp,c,cpp}"
+
+  load 'nitrogen/generated/ios/RNNitroSQLite+autolinking.rb'
+  add_nitrogen_files(s)
+
+  if defined?(install_modules_dependencies())
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-callinvoker"
+    s.dependency "React"
+    s.dependency "React-Core"
+  end
+
+  optimizedCflags = '$(inherited) -DSQLITE_DQS=0 -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_DEFAULT_WAL_SYNCHRONOUS=1 -DSQLITE_LIKE_DOESNT_MATCH_BLOBS=1 -DSQLITE_MAX_EXPR_DEPTH=0 -DSQLITE_OMIT_DEPRECATED=1 -DSQLITE_OMIT_PROGRESS_CALLBACK=1 -DSQLITE_OMIT_SHARED_CACHE=1 -DSQLITE_USE_ALLOCA=1'
+
+  if performance_mode == '1' then
+    log_message.call("Thread unsafe (1) performance mode enabled. Use only transactions! 🚀🚀")
+    xcconfig[:OTHER_CFLAGS] = optimizedCflags + ' -DSQLITE_THREADSAFE=0 '
+  end
+
+  if performance_mode == '2' then
+    log_message.call("Thread safe (2) performance mode enabled 🚀")
+    xcconfig[:OTHER_CFLAGS] = optimizedCflags + ' -DSQLITE_THREADSAFE=1 '
+  end
+
+  if ENV['NITRO_SQLITE_USE_PHONE_VERSION'] == '1' then
+    s.exclude_files = "cpp/sqlite3.c", "cpp/sqlite3.h"
+    s.library = "sqlite3"
+  end
+
+end

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Sun Oct 06 16:38:54 CEST 2024
+gradle.version=8.9

package/android/CMakeLists.txt

@@ -0,0 +1,38 @@
+project(RNNitroSQLite)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME RNNitroSQLite)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+add_definitions(
+  ${SQLITE_FLAGS}
+)
+
+file(GLOB_RECURSE cpp_files RELATIVE ${CMAKE_SOURCE_DIR}
+  "../cpp/**.c"
+  "../cpp/**.cpp"
+  "src/main/cpp/cpp-adapter.cpp"
+)
+
+# Create library "RNNitroSQLite" and add all C++ files to it
+add_library(${PACKAGE_NAME} SHARED
+  ${cpp_files}
+)
+
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/RNNitroSQLite+autolinking.cmake)
+
+# Specifies a path to native header files.
+include_directories(
+  ../cpp
+  ../cpp/specs
+  ../cpp/sqlite
+)
+
+find_library(LOG_LIB log)
+
+target_link_libraries(
+  ${PACKAGE_NAME}
+  ${LOG_LIB}
+  android
+)

package/android/build.gradle

@@ -0,0 +1,119 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.2"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+def SQLITE_FLAGS = rootProject.properties['nitroSqliteFlags']
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/RNNitroSQLite+autolinking.gradle'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["RNNitroSQLite_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RNNitroSQLite_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.rnnitrosqlite"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-O2", "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID", "-Wall", "-fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DSQLITE_FLAGS='${SQLITE_FLAGS ? SQLITE_FLAGS : ''}'"
+        abiFilters (*reactNativeArchitectures())
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "RNNitroSQLite"
+    codegenJavaPackageName = "com.margelo.rnnitrosqlite"
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.margelo.rnnitrosqlite">
+
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,21 @@
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <typeinfo>
+#include "HybridNitroSQLite.hpp"
+#include "RNNitroSQLiteOnLoad.hpp"
+
+using namespace margelo::nitro::rnnitrosqlite;
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+    return margelo::nitro::rnnitrosqlite::initialize(vm);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_margelo_rnnitrosqlite_RNNitroSQLiteOnLoadModule_setDocPathInJNI(JNIEnv *env, jclass clazz,
+                                                                         jstring doc_path) {
+  const char *nativeString = env->GetStringUTFChars(doc_path, nullptr);
+  HybridNitroSQLite::docPath = std::string(nativeString);
+  env->ReleaseStringUTFChars(doc_path, nativeString);
+}

package/android/src/main/java/com/margelo/rnnitrosqlite/RNNitroSQLiteOnLoadModule.java

@@ -0,0 +1,57 @@
+package com.margelo.rnnitrosqlite;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import java.util.Map;
+import java.util.HashMap;
+import com.margelo.rnnitrosqlite.NativeNitroSQLiteOnLoadSpec;
+
+public class RNNitroSQLiteOnLoadModule extends NativeNitroSQLiteOnLoadSpec {
+  private static ReactApplicationContext _reactContext;
+  private Callback reactApplicationContextReadyCallback;
+
+  public RNNitroSQLiteOnLoadModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+
+    _reactContext = reactContext;
+    setDocPath(reactContext);
+
+    if (reactApplicationContextReadyCallback != null) {
+      reactApplicationContextReadyCallback.invoke();
+    }
+  }
+
+  public static void setDocPath(ReactApplicationContext context) {
+    final String path = context.getFilesDir().getAbsolutePath();
+    setDocPathInJNI(path);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  @Override
+  public void onReactApplicationContextReady(Callback callback) {
+    if (_reactContext != null) {
+      callback.invoke();
+      return;
+    }
+
+    reactApplicationContextReadyCallback = callback;
+  }
+
+  public static ReactApplicationContext getReactContext() {
+    return _reactContext;
+  }
+
+  private native static void setDocPathInJNI(String docPath);
+}

package/android/src/main/java/com/margelo/rnnitrosqlite/RNNitroSQLitePackage.java

@@ -0,0 +1,48 @@
+package com.margelo.rnnitrosqlite;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class RNNitroSQLitePackage extends TurboReactPackage {
+  static {
+    System.loadLibrary("RNNitroSQLite");
+  }
+
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    if (name.equals(RNNitroSQLiteOnLoadModule.NAME)) {
+      return new RNNitroSQLiteOnLoadModule(reactContext);
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      moduleInfos.put(
+          RNNitroSQLiteOnLoadModule.NAME,
+          new ReactModuleInfo(
+              RNNitroSQLiteOnLoadModule.NAME,
+              RNNitroSQLiteOnLoadModule.NAME,
+              false,
+              true,
+              true,
+              false,
+              true));
+      return moduleInfos;
+    };
+  }
+}

package/cpp/NitroSQLiteException.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <string>
+#include <iostream>
+#include <exception>
+
+enum NitroSQLiteExceptionType {
+  UnknownError,
+  DatabaseCannotBeOpened,
+  DatabaseNotOpen,
+  UnableToAttachToDatabase,
+  SqlExecutionError,
+  CouldNotLoadFile,
+  NoBatchCommandsProvided
+};
+
+inline std::unordered_map<NitroSQLiteExceptionType, std::string> exceptionTypeStrings = {
+  {UnknownError, "UnknownError"},
+  {DatabaseCannotBeOpened, "DatabaseCannotBeOpened"},
+  {DatabaseNotOpen, "DatabaseNotOpen"},
+  {UnableToAttachToDatabase, "UnableToAttachToDatabase"},
+  {SqlExecutionError, "SqlExecutionError"},
+  {CouldNotLoadFile, "CouldNotLoadFile"},
+  {NoBatchCommandsProvided, "NoBatchCommandsProvided"}
+};
+
+inline std::string typeToString(NitroSQLiteExceptionType type) {
+  return exceptionTypeStrings[type];
+}
+
+class NitroSQLiteException : public std::exception {
+public:
+  explicit NitroSQLiteException(const char* message): NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, message) {}
+  explicit NitroSQLiteException(const std::string& message): NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, message) {}
+  NitroSQLiteException(const NitroSQLiteExceptionType& type, const char* message) : NitroSQLiteException(type, std::string(message)) {}
+  NitroSQLiteException(const NitroSQLiteExceptionType& type, const std::string& message)
+    : _exceptionString("[react-native-nitro-sqlite] " + typeToString(type) + ": " + message) {}
+
+private:
+  const std::string _exceptionString;
+
+public:
+  [[nodiscard]] const char* what() const noexcept override {
+    return this->_exceptionString.c_str();
+  }
+
+  static NitroSQLiteException DatabaseNotOpen(const std::string& dbName) {
+    return NitroSQLiteException(NitroSQLiteExceptionType::UnableToAttachToDatabase, dbName + " is not open");
+  }
+
+  static NitroSQLiteException SqlExecution(const std::string& errorMessage) {
+    return NitroSQLiteException(NitroSQLiteExceptionType::SqlExecutionError, errorMessage);
+  }
+
+  static NitroSQLiteException DatabaseFileNotFound(const std::string& dbFilePath) {
+    return NitroSQLiteException(NitroSQLiteExceptionType::SqlExecutionError, "Database file not found: " + dbFilePath);
+  }
+
+  static NitroSQLiteException CouldNotLoadFile(const std::string& fileLocation, std::optional<std::string> additionalLine = std::nullopt) {
+    const auto message = "Could not load file: " + fileLocation + (additionalLine ? (". " + *additionalLine) : "");
+    return NitroSQLiteException(NitroSQLiteExceptionType::CouldNotLoadFile, message);
+  }
+};

package/cpp/ThreadPool.cpp

@@ -0,0 +1,91 @@
+//
+//  ThreadPool.cpp
+//  react-native-nitro-sqlite
+//
+//  Created by Oscar on 13.03.22.
+//
+
+#include "ThreadPool.hpp"
+
+namespace margelo::rnnitrosqlite {
+
+ThreadPool::ThreadPool() : done(false) {
+  // This returns the number of threads supported by the system. If the
+  // function can't figure out this information, it returns 0. 0 is not good,
+  // so we create at least 1
+  auto numberOfThreads = std::thread::hardware_concurrency();
+  if (numberOfThreads == 0) {
+    numberOfThreads = 1;
+  }
+
+  for (unsigned i = 0; i < numberOfThreads; ++i) {
+    // The threads will execute the private member `doWork`. Note that we need
+    // to pass a reference to the function (namespaced with the class name) as
+    // the first argument, and the current object as second argument
+    threads.push_back(std::thread(&ThreadPool::doWork, this));
+  }
+}
+
+// The destructor joins all the threads so the program can exit gracefully.
+// This will be executed if there is any exception (e.g. creating the threads)
+ThreadPool::~ThreadPool() {
+  // So threads know it's time to shut down
+  done = true;
+
+  // Wake up all the threads, so they can finish and be joined
+  workQueueConditionVariable.notify_all();
+  for (auto& thread : threads) {
+    if (thread.joinable()) {
+      thread.join();
+    }
+  }
+}
+
+// This function will be called by the server every time there is a request
+// that needs to be processed by the thread pool
+void ThreadPool::queueWork(std::function<void(void)> task) {
+  // Grab the mutex
+  std::lock_guard<std::mutex> g(workQueueMutex);
+
+  // Push the request to the queue
+  workQueue.push(task);
+
+  // Notify one thread that there are requests to process
+  workQueueConditionVariable.notify_one();
+}
+
+// Function used by the threads to grab work from the queue
+void ThreadPool::doWork() {
+  // Loop while the queue is not destructing
+  while (!done) {
+    std::function<void(void)> task;
+
+    // Create a scope, so we don't lock the queue for longer than necessary
+    {
+      std::unique_lock<std::mutex> g(workQueueMutex);
+      workQueueConditionVariable.wait(g, [&] {
+        // Only wake up if there are elements in the queue or the program is
+        // shutting down
+        return !workQueue.empty() || done;
+      });
+
+      // If we are shutting down exit witout trying to process more work
+      if (done) {
+        break;
+      }
+
+      task = workQueue.front();
+      workQueue.pop();
+    }
+    ++busy;
+    task();
+    --busy;
+  }
+}
+
+void ThreadPool::waitFinished() {
+  std::unique_lock<std::mutex> g(workQueueMutex);
+  workQueueConditionVariable.wait(g, [&] { return workQueue.empty() && (busy == 0); });
+}
+
+} // namespace margelo::rnnitrosqlite

package/cpp/ThreadPool.hpp

@@ -0,0 +1,50 @@
+//
+//  ThreadPool.hpp
+//  react-native-nitro-sqlite
+//
+//  Created by Oscar on 13.03.22.
+//
+
+#pragma once
+
+#include <condition_variable>
+#include <exception>
+#include <mutex>
+#include <queue>
+#include <stdio.h>
+#include <thread>
+#include <vector>
+
+namespace margelo::rnnitrosqlite {
+
+class ThreadPool {
+public:
+  ThreadPool();
+  ~ThreadPool();
+  void queueWork(std::function<void(void)> task);
+  void waitFinished();
+
+private:
+  unsigned int busy;
+  // This condition variable is used for the threads to wait until there is work
+  // to do
+  std::condition_variable_any workQueueConditionVariable;
+
+  // We store the threads in a vector, so we can later stop them gracefully
+  std::vector<std::thread> threads;
+
+  // Mutex to protect workQueue
+  std::mutex workQueueMutex;
+
+  // Queue of requests waiting to be processed
+  std::queue<std::function<void(void)>> workQueue;
+
+  // This will be set to true when the thread pool is shutting down. This tells
+  // the threads to stop looping and finish
+  bool done;
+
+  // Function used by the threads to grab work from the queue
+  void doWork();
+};
+
+} // namespace margelo::rnnitrosqlite

package/cpp/importSqlFile.cpp

@@ -0,0 +1,48 @@
+/**
+ * SQL File Loader implementation
+ */
+
+#include "importSqlFile.hpp"
+#include <fstream>
+#include <iostream>
+#include "NitroSQLiteException.hpp"
+#include "operations.hpp"
+
+namespace margelo::rnnitrosqlite {
+
+SQLiteOperationResult importSqlFile(const std::string& dbName, const std::string& fileLocation) {
+  std::string line;
+  std::ifstream sqFile(fileLocation);
+  if (sqFile.is_open()) {
+    try {
+      int rowsAffected = 0;
+      int commands = 0;
+      sqliteExecuteLiteral(dbName, "BEGIN EXCLUSIVE TRANSACTION");
+      while (std::getline(sqFile, line, '\n')) {
+        if (!line.empty()) {
+          try {
+            SQLiteOperationResult result = sqliteExecuteLiteral(dbName, line);
+            rowsAffected += result.rowsAffected;
+            commands++;
+          } catch (NitroSQLiteException& e) {
+            sqliteExecuteLiteral(dbName, "ROLLBACK");
+            sqFile.close();
+            throw NitroSQLiteException::CouldNotLoadFile(fileLocation, "Transaction was rolled back");
+          }
+        }
+      }
+
+      sqFile.close();
+      sqliteExecuteLiteral(dbName, "COMMIT");
+      return {.rowsAffected = rowsAffected, .commands = commands};
+    } catch (...) {
+      sqFile.close();
+      sqliteExecuteLiteral(dbName, "ROLLBACK");
+      throw NitroSQLiteException(NitroSQLiteExceptionType::UnknownError, "Unexpected error. Transaction was rolled back");
+    }
+  } else {
+    throw NitroSQLiteException::CouldNotLoadFile(fileLocation);
+  }
+}
+
+} // namespace margelo::rnnitrosqlite

package/cpp/importSqlFile.hpp

@@ -0,0 +1,15 @@
+/**
+ * SQL File Loader
+ * Utilizes the regular sqlite bridge to load an SQLFile inside a transaction
+ *
+ */
+
+#pragma once
+
+#include "types.hpp"
+
+namespace margelo::rnnitrosqlite {
+
+SQLiteOperationResult importSqlFile(const std::string& dbName, const std::string& fileLocation);
+
+}

package/cpp/logs.hpp

@@ -0,0 +1,38 @@
+#ifdef ANDROID
+// LOGS ANDROID
+#include <android/log.h>
+#define LOG_TAG "react-native-nitro-sqlite"
+#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#define LOGSIMPLE(...)
+#else
+// LOGS NO ANDROID
+#include <stdio.h>
+#define LOG_TAG "react-native-nitro-sqlite"
+#define LOGV(...)                                                                                                                          \
+  printf("  ");                                                                                                                            \
+  printf(__VA_ARGS__);                                                                                                                     \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGD(...)                                                                                                                          \
+  printf("  ");                                                                                                                            \
+  printf(__VA_ARGS__);                                                                                                                     \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGI(...)                                                                                                                          \
+  printf("  ");                                                                                                                            \
+  printf(__VA_ARGS__);                                                                                                                     \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGW(...)                                                                                                                          \
+  printf("  * Warning: ");                                                                                                                 \
+  printf(__VA_ARGS__);                                                                                                                     \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGE(...)                                                                                                                          \
+  printf("  *** Error:  ");                                                                                                                \
+  printf(__VA_ARGS__);                                                                                                                     \
+  printf("\t -  <%s> \n", LOG_TAG);
+#define LOGSIMPLE(...)                                                                                                                     \
+  printf(" ");                                                                                                                             \
+  printf(__VA_ARGS__);
+#endif // ANDROID