@digitalshieldfe/react-native-backup-card-sdk 0.1.1 → 0.1.3

package/android/src/main/jni/src/implJni.cpp

@@ -0,0 +1,313 @@
+//
+// Created by FT on 2018/4/16.
+//
+
+#include <jni.h>
+#include <logUtils.h>
+#include <GPChannelSDK.h>
+#include <jsoncpp/include/json/json.h>
+#include <jsoncpp/include/json/value.h>
+#include <mSIGNA/stdutils/uchar_vector.h>
+
+// 保存 JavaVM
+JavaVM *g_vm = NULL;
+int errorCode = 0;
+
+JNIEXPORT jint JNICALL native_getErrorCode(JNIEnv *env, jclass obj) {
+    return errorCode;
+}
+
+JNIEXPORT jint  JNICALL native_GPC_Initialize(JNIEnv *env, jclass obj,
+                                              jstring jJSON) {
+    if (NULL == jJSON) {
+        return JUBR_ARGUMENTS_BAD;
+    }
+    int length = env->GetStringLength(jJSON);
+    if (0 == length) {
+        return JUBR_ARGUMENTS_BAD;
+    }
+
+    JUB_CHAR_PTR pJSON = const_cast<JUB_CHAR_PTR>(env->GetStringUTFChars(jJSON, NULL));
+
+    Json::Reader reader;
+    Json::Value root;
+    reader.parse(pJSON, root);
+
+    GPC_SCP11_SHAREDINFO sharedInfo = {0};
+    sharedInfo.scpID = root["scpID"].asUInt();
+    sharedInfo.keyUsage = root["keyUsage"].asUInt();
+    sharedInfo.keyType = root["keyType"].asUInt();
+    sharedInfo.keyLength = root["keyLength"].asUInt();
+    strcpy(sharedInfo.hostID,(JUB_CHAR_PTR) root["hostID"].asCString());
+    uchar_vector groupID = uchar_vector(root["cardGroupID"].asCString());
+    std::string str_groupID(groupID.begin(),groupID.end());
+    JUB_RV ret = JUB_GPC_Initialize(sharedInfo,
+                                    str_groupID.c_str(),
+                                    "",
+                                    "");
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_Initialize: %08x", ret);
+    }
+    env->ReleaseStringUTFChars(jJSON, (const char *) pJSON);
+    return static_cast<jint>(ret);
+}
+
+JNIEXPORT jint JNICALL native_GPC_Finalize(JNIEnv *env, jclass obj) {
+    JUB_RV ret = JUB_GPC_Finalize();
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_Finalize: %08x", ret);
+    }
+    return static_cast<jint>(ret);
+}
+
+JNIEXPORT jstring JNICALL native_GPC_BuildMutualAuthData(JNIEnv *env, jclass obj) {
+    JUB_CHAR_PTR mutualAuthData;
+    JUB_RV ret = JUB_GPC_BuildMutualAuthData(&mutualAuthData);
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_BuildMutualAuthData: %08x", ret);
+        errorCode = static_cast<int>(ret);
+        return NULL;
+    } else {
+        jstring result = env->NewStringUTF(mutualAuthData);
+        JUB_FreeMemory(mutualAuthData);
+        return result;
+    }
+}
+
+JNIEXPORT jint JNICALL native_GPC_OpenSecureChannel(JNIEnv *env, jclass obj, jstring jResponse) {
+    JUB_CHAR_PTR pResponse = const_cast<JUB_CHAR_PTR>(env->GetStringUTFChars(jResponse, NULL));
+    JUB_RV ret = JUB_GPC_OpenSecureChannel(pResponse);
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_OpenSecureChannel: %08x", ret);
+    }
+    return static_cast<jint>(ret);
+}
+
+JNIEXPORT jstring JNICALL
+native_GPC_BuildAPDU(JNIEnv *env, jclass obj, jlong jCla, jlong jIns, jlong jP1, jlong jP2,
+                     jstring jData) {
+
+    JUB_CHAR_PTR pData = const_cast<JUB_CHAR_PTR>(env->GetStringUTFChars(jData, NULL));
+
+    JUB_CHAR_PTR apdu;
+    JUB_RV ret = JUB_GPC_BuildAPDU(jCla, jIns, jP1, jP2, pData, &apdu);
+    env->ReleaseStringUTFChars(jData, (const char *) pData);
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_BuildAPDU: %08x", ret);
+        errorCode = static_cast<int>(ret);
+        return NULL;
+    } else {
+        jstring result = env->NewStringUTF(apdu);
+        JUB_FreeMemory(apdu);
+        return result;
+    }
+}
+
+JNIEXPORT jstring JNICALL
+native_GPC_BuildSafeAPDU(JNIEnv *env, jclass obj, jlong jCla, jlong jIns, jlong jP1, jlong jP2,
+                         jstring jData) {
+    JUB_CHAR_PTR pData = const_cast<JUB_CHAR_PTR>(env->GetStringUTFChars(jData, NULL));
+
+    JUB_CHAR_PTR apdu;
+    JUB_RV ret = JUB_GPC_BuildSafeAPDU(jCla, jIns, jP1, jP2, pData, &apdu);
+    env->ReleaseStringUTFChars(jData, (const char *) pData);
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_BuildSafeAPDU: %08x", ret);
+        errorCode = static_cast<int>(ret);
+        return NULL;
+    } else {
+        jstring result = env->NewStringUTF(apdu);
+        JUB_FreeMemory(apdu);
+        return result;
+    }
+}
+
+JNIEXPORT jstring JNICALL
+native_GPC_ParseSafeAPDUResponse(JNIEnv *env, jclass obj, jstring jResponse) {
+
+    JUB_CHAR_PTR pResponse = const_cast<JUB_CHAR_PTR>(env->GetStringUTFChars(jResponse, NULL));
+    JUB_UINT16 wRet = 0;
+    JUB_CHAR_PTR response;
+    JUB_RV ret = JUB_GPC_ParseSafeAPDUResponse(pResponse, &wRet, &response);
+    env->ReleaseStringUTFChars(jResponse, (const char *) pResponse);
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_ParseSafeAPDUResponse: %08x", ret);
+        errorCode = static_cast<int>(ret);
+        return NULL;
+    } else {
+        Json::FastWriter writer;
+        Json::Value root;
+        root["wRet"] = wRet;
+        root["response"] = response;
+        jstring result = env->NewStringUTF(writer.write(root).c_str());
+        JUB_FreeMemory(response);
+        return result;
+    }
+}
+
+JNIEXPORT jstring JNICALL
+native_GPC_ParseAPDUResponse(JNIEnv *env, jclass obj, jstring jResponse) {
+
+    JUB_CHAR_PTR pResponse = const_cast<JUB_CHAR_PTR>(env->GetStringUTFChars(jResponse, NULL));
+    JUB_UINT16 wRet = 0;
+    JUB_CHAR_PTR resp;
+    JUB_RV ret = JUB_GPC_ParseAPDUResponse(pResponse, &wRet, &resp);
+    env->ReleaseStringUTFChars(jResponse, (const char *) pResponse);
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_ParseAPDUResponse: %08x", ret);
+        errorCode = static_cast<int>(ret);
+        return NULL;
+    } else {
+        Json::FastWriter writer;
+        Json::Value root;
+        root["wRet"] = wRet;
+        root["response"] = resp;
+        jstring result = env->NewStringUTF(writer.write(root).c_str());
+        JUB_FreeMemory(resp);
+        return result;
+    }
+}
+
+JNIEXPORT jstring JNICALL
+native_GPC_TLVDecode(JNIEnv *env, jclass obj, jstring jApdu) {
+    JUB_CHAR_PTR pApdu = const_cast<JUB_CHAR_PTR>(env->GetStringUTFChars(jApdu, NULL));
+    JUB_ULONG tag = 0;
+    JUB_CHAR_PTR value;
+    JUB_RV ret = JUB_GPC_TLVDecode(pApdu, &tag, &value);
+    env->ReleaseStringUTFChars(jApdu, (const char *) pApdu);
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_TLVDecode: %08x", ret);
+        errorCode = static_cast<int>(ret);
+        return NULL;
+    } else {
+        Json::FastWriter writer;
+        Json::Value root;
+        Json::Int64 tmTag = tag;
+        root["tag"] = tmTag;
+        root["value"] = value;
+        jstring result = env->NewStringUTF(writer.write(root).c_str());
+        JUB_FreeMemory(value);
+        return result;
+    }
+}
+
+JNIEXPORT jstring JNICALL
+native_GPC_ParseCertificate(JNIEnv *env, jclass obj, jstring jCert) {
+    JUB_CHAR_PTR pCert = const_cast<JUB_CHAR_PTR>(env->GetStringUTFChars(jCert, NULL));
+    JUB_CHAR_PTR sn;
+    JUB_CHAR_PTR subjectID;
+    JUB_RV ret = JUB_GPC_ParseCertificate(pCert, &sn, &subjectID);
+    env->ReleaseStringUTFChars(jCert, (const char *) pCert);
+    if (ret != JUBR_OK) {
+        LOG_ERR("JUB_GPC_ParseCertificate: %08x", ret);
+        errorCode = static_cast<int>(ret);
+        return NULL;
+    } else {
+        Json::FastWriter writer;
+        Json::Value root;
+        root["sn"] = sn;
+        root["subjectID"] = subjectID;
+        jstring result = env->NewStringUTF(writer.write(root).c_str());
+        JUB_FreeMemory(sn);
+        JUB_FreeMemory(subjectID);
+        return result;
+    }
+}
+
+/**
+ * JNINativeMethod由三部分组成:
+ * (1)Java中的函数名;
+ * (2)函数签名,格式为(输入参数类型)返回值类型;
+ * (3)native函数名
+ */
+static JNINativeMethod gMethods[] = {
+        {
+                "nativeGetErrorCode",
+                "()I",
+                (void *) native_getErrorCode
+        },
+        {
+                "nativeGPCInitialize",
+                "(Ljava/lang/String;)I",
+                (void *) native_GPC_Initialize
+        },
+        {
+                "nativeGPCFinalize",
+                "()I",
+                (void *) native_GPC_Finalize
+        },
+        {
+                "nativeGPCBuildMutualAuthData",
+                "()Ljava/lang/String;",
+                (void *) native_GPC_BuildMutualAuthData
+        },
+        {
+                "nativeGPCOpenSecureChannel",
+                "(Ljava/lang/String;)I",
+                (void *) native_GPC_OpenSecureChannel
+        },
+        {
+                "nativeGPCBuildAPDU",
+                "(JJJJLjava/lang/String;)Ljava/lang/String;",
+                (void *) native_GPC_BuildAPDU
+        },
+        {
+                "nativeGPCBuildSafeAPDU",
+                "(JJJJLjava/lang/String;)Ljava/lang/String;",
+                (void *) native_GPC_BuildSafeAPDU
+        },
+        {
+                "nativeGPCParseSafeAPDUResponse",
+                "(Ljava/lang/String;)Ljava/lang/String;",
+                (void *) native_GPC_ParseSafeAPDUResponse
+        },
+        {
+                "nativeGPCParseAPDUResponse",
+                "(Ljava/lang/String;)Ljava/lang/String;",
+                (void *) native_GPC_ParseAPDUResponse
+        },
+        {
+                "nativeGPCTLVDecode",
+                "(Ljava/lang/String;)Ljava/lang/String;",
+                (void *) native_GPC_TLVDecode
+        },
+        {
+                "nativeGPCParseCertificate",
+                "(Ljava/lang/String;)Ljava/lang/String;",
+                (void *) native_GPC_ParseCertificate
+        }
+};
+
+
+//#define NATIVE_API_CLASS "com/jubiter/sdk/gpchannel/GPChannelNatives"
+#define NATIVE_API_CLASS "com/ziancube/backupcardsdk/GPChannelNatives"
+
+/**
+ * JNI_OnLoad 默认会在 System.loadLibrary 过程中自动调用到，因而可利用此函数，进行动态注册
+ * JNI 版本的返回视对应 JDK 版本而定
+ */
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
+    JNIEnv *env = NULL;
+    jint ret = JNI_FALSE;
+
+    // 获取 env 指针
+    if (vm->GetEnv((void **) &env, JNI_VERSION_1_6) != JNI_OK) {
+        return ret;
+    }
+
+    // 保存全局 JVM 以便在动态注册的皆空中使用 env 环境
+    env->GetJavaVM(&g_vm);
+
+    // 获取类引用
+    jclass clazz = env->FindClass(NATIVE_API_CLASS);
+    if (clazz == NULL) {
+        return ret;
+    }
+
+    // 注册 JNI 方法
+    if (env->RegisterNatives(clazz, gMethods, sizeof(gMethods) / sizeof(gMethods[0])) < JNI_OK) {
+        return ret;
+    }
+    // 成功
+    return JNI_VERSION_1_6;
+}

package/android/src/main/jni/src/implJni.h

@@ -0,0 +1,9 @@
+//
+// Created by FT on 2018/3/12.
+//
+
+#ifndef JUBITER_IMPLJNI_H
+#define JUBITER_IMPLJNI_H
+
+
+#endif //JUBITER_IMPLJNI_H

package/android/src/main/jni/utils/jsoncpp/AUTHORS

@@ -0,0 +1,111 @@
+Baptiste Lepilleur <blep@users.sourceforge.net>
+
+Aaron Jacobs <aaronjjacobs@gmail.com>
+Aaron Jacobs <jacobsa@google.com>
+Adam Boseley <ABoseley@agjunction.com>
+Adam Boseley <adam.boseley@gmail.com>
+Aleksandr Derbenev <13alexac@gmail.com>
+Alexander Gazarov <DrMetallius@users.noreply.github.com>
+Alexander V. Brezgin <abrezgin@appliedtech.ru>
+Alexandr Brezgin <albrezgin@mail.ru>
+Alexey Kruchinin <alexey@mopals.com>
+Anton Indrawan <anton.indrawan@gmail.com>
+Baptiste Jonglez <git@bitsofnetworks.org>
+Baptiste Lepilleur <baptiste.lepilleur@gmail.com>
+Baruch Siach <baruch@tkos.co.il>
+Ben Boeckel <mathstuf@gmail.com>
+Benjamin Knecht <bknecht@logitech.com>
+Bernd Kuhls <bernd.kuhls@t-online.de>
+Billy Donahue <billydonahue@google.com>
+Braden McDorman <bmcdorman@gmail.com>
+Brandon Myers <bmyers1788@gmail.com>
+Brendan Drew <brendan.drew@daqri.com>
+chason <cxchao802@gmail.com>
+Chris Gilling <cgilling@iparadigms.com>
+Christopher Dawes <christopher.dawes.1981@googlemail.com>
+Christopher Dunn <cdunn2001@gmail.com>
+Chuck Atkins <chuck.atkins@kitware.com>
+Cody P Schafer <dev@codyps.com>
+Connor Manning <connor@hobu.co>
+Cory Quammen <cory.quammen@kitware.com>
+Cristóvão B da Cruz e Silva <CrisXed@gmail.com>
+Daniel Krügler <daniel.kruegler@gmail.com>
+Dani-Hub <daniel.kruegler@googlemail.com>
+Dan Liu <gzliudan>
+datadiode <datadiode@users.noreply.github.com>
+datadiode <jochen.neubeck@vodafone.de>
+David Seifert <soap@gentoo.org>
+David West <david-west@idexx.com>
+dawesc <chris.dawes@eftlab.co.uk>
+Dmitry Marakasov <amdmi3@amdmi3.ru>
+dominicpezzuto <dom@dompezzuto.com>
+Don Milham <dmilham@gmail.com>
+drgler <daniel.kruegler@gmail.com>
+ds283 <D.Seery@sussex.ac.uk>
+Egor Tensin <Egor.Tensin@gmail.com>
+eightnoteight <mr.eightnoteight@gmail.com>
+Evince <baneyue@gmail.com>
+filipjs <filipjs@users.noreply.github.com>
+findblar <ft@finbarr.ca>
+Florian Meier <florian.meier@koalo.de>
+Gaëtan Lehmann <gaetan.lehmann@gmail.com>
+Gaurav <g.gupta@samsung.com>
+Gergely Nagy <ngg@ngg.hu>
+Gida Pataki <gida.pataki@prezi.com>
+I3ck <buckmartin@buckmartin.de>
+Iñaki Baz Castillo <ibc@aliax.net>
+Jacco <jacco@geul.net>
+Jean-Christophe Fillion-Robin <jchris.fillionr@kitware.com>
+Jonas Platte <mail@jonasplatte.de>
+Jörg Krause <joerg.krause@embedded.rocks>
+Keith Lea <keith@whamcitylights.com>
+Kevin Grant <kbradleygrant@gmail.com>
+Kirill V. Lyadvinsky <jia3ep@gmail.com>
+Kirill V. Lyadvinsky <mail@codeatcpp.com>
+Kobi Gurkan <kobigurk@gmail.com>
+Magnus Bjerke Vik <mbvett@gmail.com>
+Malay Shah <malays@users.sourceforge.net>
+Mara Kim <hacker.root@gmail.com>
+Marek Kotewicz <marek.kotewicz@gmail.com>
+Mark Lakata <mark@lakata.org>
+Mark Zeren <mzeren@vmware.com>
+Martin Buck <buckmartin@buckmartin.de>
+Martyn Gigg <martyn.gigg@gmail.com>
+Mattes D <github@xoft.cz>
+Matthias Loy <matthias.loy@hbm.com>
+Merlyn Morgan-Graham <kavika@gmail.com>
+Michael Shields <mshields@google.com>
+Michał Górny <mgorny@gentoo.org>
+Mike Naberezny <mike@naberezny.com>
+mloy <matthias.loy@googlemail.com>
+Motti <lanzkron@gmail.com>
+nnkur <nnkur@mail.ru>
+Omkar Wagh <owagh@owaghlinux.ny.tower-research.com>
+paulo <paulobrizolara@users.noreply.github.com>
+pavel.pimenov <pavel.pimenov@gmail.com>
+Paweł Bylica <chfast@gmail.com>
+Péricles Lopes Machado <pericles.raskolnikoff@gmail.com>
+Peter Spiess-Knafl <psk@autistici.org>
+pffang <pffang@vip.qq.com>
+Rémi Verschelde <remi@verschelde.fr>
+renu555 <renu.tyagi@samsung.com>
+Robert Dailey <rcdailey@gmail.com>
+Sam Clegg <sbc@chromium.org>
+selaselah <selah@outlook.com>
+Sergiy80 <sil2004@gmail.com>
+sergzub <sergzub@gmail.com>
+Stefan Schweter <stefan@schweter.it>
+Steffen Kieß <Steffen.Kiess@ipvs.uni-stuttgart.de>
+Steven Hahn <hahnse@ornl.gov>
+Stuart Eichert <stuart@fivemicro.com>
+SuperManitu <supermanitu@gmail.com>
+Techwolf <dring@g33kworld.net>
+Tengiz Sharafiev <btolfa+github@gmail.com>
+Tomasz Maciejewski <tmaciejewsk@gmail.com>
+Vicente Olivert Riera <Vincent.Riera@imgtec.com>
+xiaoyur347 <xiaoyur347@gmail.com>
+ycqiu <429148848@qq.com>
+yiqiju <fred_ju@selinc.com>
+Yu Xiaolei <dreifachstein@gmail.com>
+
+Google Inc.

package/android/src/main/jni/utils/jsoncpp/CMakeLists.txt

@@ -0,0 +1,159 @@
+# vim: et ts=4 sts=4 sw=4 tw=0
+
+CMAKE_MINIMUM_REQUIRED(VERSION 3.1)
+PROJECT(jsoncpp)
+ENABLE_TESTING()
+
+OPTION(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test executables" ON)
+OPTION(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a post build step" ON)
+OPTION(JSONCPP_WITH_WARNING_AS_ERROR "Force compilation to fail if a warning occurs" OFF)
+OPTION(JSONCPP_WITH_STRICT_ISO "Issue all the warnings demanded by strict ISO C and ISO C++" ON)
+OPTION(JSONCPP_WITH_PKGCONFIG_SUPPORT "Generate and install .pc files" ON)
+OPTION(JSONCPP_WITH_CMAKE_PACKAGE "Generate and install cmake package files" OFF)
+OPTION(BUILD_SHARED_LIBS "Build jsoncpp_lib as a shared library." OFF)
+OPTION(BUILD_STATIC_LIBS "Build jsoncpp_lib static library." ON)
+
+# Ensures that CMAKE_BUILD_TYPE is visible in cmake-gui on Unix
+IF(NOT WIN32)
+    IF(NOT CMAKE_BUILD_TYPE)
+        SET(CMAKE_BUILD_TYPE Release CACHE STRING
+            "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Coverage."
+            FORCE)
+    ENDIF()
+ENDIF()
+
+# Enable runtime search path support for dynamic libraries on OSX
+IF(APPLE)
+    SET(CMAKE_MACOSX_RPATH 1)
+ENDIF()
+
+# Adhere to GNU filesystem layout conventions
+INCLUDE(GNUInstallDirs)
+
+SET(DEBUG_LIBNAME_SUFFIX "" CACHE STRING "Optional suffix to append to the library name for a debug build")
+
+# Set variable named ${VAR_NAME} to value ${VALUE}
+FUNCTION(set_using_dynamic_name VAR_NAME VALUE)
+    SET( "${VAR_NAME}" "${VALUE}" PARENT_SCOPE)
+ENDFUNCTION()
+
+# Extract major, minor, patch from version text
+# Parse a version string "X.Y.Z" and outputs
+# version parts in ${OUPUT_PREFIX}_MAJOR, _MINOR, _PATCH.
+# If parse succeeds then ${OUPUT_PREFIX}_FOUND is TRUE.
+MACRO(jsoncpp_parse_version VERSION_TEXT OUPUT_PREFIX)
+    SET(VERSION_REGEX "[0-9]+\\.[0-9]+\\.[0-9]+(-[a-zA-Z0-9_]+)?")
+    IF( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
+        STRING(REGEX MATCHALL "[0-9]+|-([A-Za-z0-9_]+)" VERSION_PARTS ${VERSION_TEXT})
+        LIST(GET VERSION_PARTS 0 ${OUPUT_PREFIX}_MAJOR)
+        LIST(GET VERSION_PARTS 1 ${OUPUT_PREFIX}_MINOR)
+        LIST(GET VERSION_PARTS 2 ${OUPUT_PREFIX}_PATCH)
+        set_using_dynamic_name( "${OUPUT_PREFIX}_FOUND" TRUE )
+    ELSE( ${VERSION_TEXT} MATCHES ${VERSION_REGEX} )
+        set_using_dynamic_name( "${OUPUT_PREFIX}_FOUND" FALSE )
+    ENDIF()
+ENDMACRO()
+
+# Read out version from "version" file
+#FILE(STRINGS "version" JSONCPP_VERSION)
+#SET( JSONCPP_VERSION_MAJOR X )
+#SET( JSONCPP_VERSION_MINOR Y )
+#SET( JSONCPP_VERSION_PATCH Z )
+SET( JSONCPP_VERSION 1.8.4 )
+jsoncpp_parse_version( ${JSONCPP_VERSION} JSONCPP_VERSION )
+#IF(NOT JSONCPP_VERSION_FOUND)
+#    MESSAGE(FATAL_ERROR "Failed to parse version string properly. Expect X.Y.Z")
+#ENDIF(NOT JSONCPP_VERSION_FOUND)
+SET( JSONCPP_SOVERSION 19 )
+SET( JSONCPP_USE_SECURE_MEMORY "0" CACHE STRING "-D...=1 to use memory-wiping allocator for STL" )
+
+MESSAGE(STATUS "JsonCpp Version: ${JSONCPP_VERSION_MAJOR}.${JSONCPP_VERSION_MINOR}.${JSONCPP_VERSION_PATCH}")
+# File version.h is only regenerated on CMake configure step
+CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/src/lib_json/version.h.in"
+                "${PROJECT_SOURCE_DIR}/include/json/version.h"
+                NEWLINE_STYLE UNIX )
+CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/version.in"
+                "${PROJECT_SOURCE_DIR}/version"
+                NEWLINE_STYLE UNIX )
+
+MACRO(UseCompilationWarningAsError)
+    IF(MSVC)
+        # Only enabled in debug because some old versions of VS STL generate
+        # warnings when compiled in release configuration.
+        SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /WX ")
+    ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+        IF(JSONCPP_WITH_STRICT_ISO)
+            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic-errors")
+        ENDIF()
+    ENDIF()
+ENDMACRO()
+
+# Include our configuration header
+INCLUDE_DIRECTORIES( ${jsoncpp_SOURCE_DIR}/include )
+
+IF(MSVC)
+    # Only enabled in debug because some old versions of VS STL generate
+    # unreachable code warning when compiled in release configuration.
+    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /W4 ")
+ENDIF()
+
+# Require C++11 support, prefer ISO C++ over GNU variants,
+# as relying solely on ISO C++ is more portable.
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_EXTENSIONS OFF)
+
+IF(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # using regular Clang or AppleClang
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wconversion -Wshadow -Werror=conversion -Werror=sign-compare")
+ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # using GCC
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wconversion -Wshadow -Wextra")
+    # not yet ready for -Wsign-conversion
+
+    IF(JSONCPP_WITH_STRICT_ISO)
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
+    ENDIF()
+    IF(JSONCPP_WITH_WARNING_AS_ERROR)
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=conversion")
+    ENDIF()
+ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+    # using Intel compiler
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wconversion -Wshadow -Wextra -Werror=conversion")
+
+    IF(JSONCPP_WITH_STRICT_ISO AND NOT JSONCPP_WITH_WARNING_AS_ERROR)
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
+    ENDIF()
+ENDIF()
+
+FIND_PROGRAM(CCACHE_FOUND ccache)
+IF(CCACHE_FOUND)
+    SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+    SET_PROPERTY(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+ENDIF(CCACHE_FOUND)
+
+IF(JSONCPP_WITH_WARNING_AS_ERROR)
+    UseCompilationWarningAsError()
+ENDIF()
+
+IF(JSONCPP_WITH_PKGCONFIG_SUPPORT)
+    CONFIGURE_FILE(
+        "pkg-config/jsoncpp.pc.in"
+        "pkg-config/jsoncpp.pc"
+        @ONLY)
+    INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/pkg-config/jsoncpp.pc"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+ENDIF()
+
+IF(JSONCPP_WITH_CMAKE_PACKAGE)
+        INSTALL(EXPORT jsoncpp
+                DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp
+                FILE        jsoncppConfig.cmake)
+ENDIF()
+
+# Build the different applications
+ADD_SUBDIRECTORY( src )
+
+#install the includes
+ADD_SUBDIRECTORY( include )

package/android/src/main/jni/utils/jsoncpp/LICENSE

@@ -0,0 +1,55 @@
+The JsonCpp library's source code, including accompanying documentation, 
+tests and demonstration applications, are licensed under the following
+conditions...
+
+Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all 
+jurisdictions which recognize such a disclaimer. In such jurisdictions, 
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
+The JsonCpp Authors, and is released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this 
+software may choose to accept it either as 1) Public Domain, 2) under the 
+conditions of the MIT License (see below), or 3) under the terms of dual 
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+   
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.