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

package/android/src/main/jni/GPChannel/include/utility/Apdu.hpp

@@ -0,0 +1,166 @@
+
+#ifndef __Apdu__
+#define __Apdu__
+
+#include "GPChannelSDK.h"
+
+#include <vector>
+
+namespace jub {
+
+class APDU {
+
+public:
+    APDU() {
+        cla = 0;
+        ins = 0;
+        p1 = 0;
+        p2 = 0;
+        lc = 0;
+        le = 0;
+        data.clear();
+    }
+    APDU(JUB_ULONG ncla,
+         JUB_ULONG nins,
+         JUB_ULONG np1,
+         JUB_ULONG np2,
+         JUB_ULONG nlc,
+         const JUB_BYTE* pData = nullptr,
+         JUB_ULONG nle = 0) :
+        cla(ncla),
+        ins(nins),
+        p1(np1),
+        p2(np2),
+        lc(nlc),
+        le(nle) {
+        if (         0 != lc
+            && nullptr != pData
+            ) {
+            SetData(pData, lc);
+        }
+        else {
+            data.clear();
+        }
+    }
+    ~APDU() {}
+
+public:
+    JUB_ULONG cla, ins, p1, p2, lc, le;
+    std::vector<JUB_BYTE> data;
+
+public:
+    void SetApdu(JUB_ULONG ncla,
+                 JUB_ULONG nins,
+                 JUB_ULONG np1,
+                 JUB_ULONG np2,
+                 JUB_ULONG nlc,
+                 JUB_BYTE* pData = nullptr,
+                 JUB_ULONG nle = 0) {
+        cla = ncla;
+        ins = nins;
+        p1 = np1;
+        p2 = np2;
+        lc = nlc;
+        le = nle;
+        if (         0 != lc
+            && nullptr != pData
+            ) {
+            SetData(pData, lc);
+        }
+        else {
+            data.clear();
+        }
+    }
+    void SetData(const JUB_BYTE* pData, JUB_ULONG ulDataSize) {
+        // assert(ulDataSize == lc);
+        data.clear();
+//        data.resize(ulDataSize);
+        data.insert(data.begin(), pData, pData + ulDataSize);
+    }
+}; // class APDU end
+
+
+class ResponseAPDU {
+
+public:
+    ResponseAPDU() {
+        raw.clear();
+        clear();
+    }
+    ResponseAPDU(std::vector<JUB_BYTE> raw)
+        : raw(raw) {
+        clear();
+    }
+    ResponseAPDU(JUB_BYTE_PTR ret, JUB_ULONG retLen) {
+        raw.insert(raw.end(), ret, ret+retLen);
+        clear();
+    }
+    ~ResponseAPDU() {
+        raw.clear();
+        clear();
+    }
+
+    void clear() {
+        data.clear();
+        cmac.clear();
+        SW1 = 0;
+        SW2 = 0;
+    }
+    bool empty() {
+        return (   data.empty()
+                && cmac.empty()
+        );
+    }
+
+    bool decode(bool hasMac=true) {
+        if (raw.empty()) {
+            return false;
+        }
+
+        if ( CMAC_LEN  > raw.size()
+            && SW_LEN != raw.size()
+            ) {
+            return false;
+        }
+
+        clear();
+
+        // parse SW
+        int swIndex1 = (int)raw.size() - SW_LEN;
+        int swIndex2 = (int)raw.size() - 1;
+        SW1 = raw[swIndex1];
+        SW2 = raw[swIndex2];
+        if (SW_LEN == raw.size()) {
+            return true;
+        }
+
+        int cmacLen = 0;
+        if (hasMac) {
+            cmacLen = CMAC_LEN;
+        }
+        int cmacIndex = (int)raw.size() - SW_LEN - cmacLen;
+        data.insert(data.end(), raw.begin(), raw.begin()+cmacIndex);
+        if (hasMac) {
+            cmac.insert(cmac.end(), raw.begin()+cmacIndex, raw.begin()+swIndex1);
+        }
+
+        return true;
+    }
+
+public:
+    const int CMAC_LEN = 8;
+    const int   SW_LEN = 2;
+
+    std::vector<JUB_BYTE> data;
+    std::vector<JUB_BYTE> cmac;
+    JUB_BYTE SW1;
+    JUB_BYTE SW2;
+
+private:
+    std::vector<JUB_BYTE> raw;
+};  // class ResponseAPDU end
+
+
+} // namespace jub end
+
+#endif  // __Apdu__

package/android/src/main/jni/GPChannel/include/utility/Debug.hpp

@@ -0,0 +1,59 @@
+
+#ifndef __DEBUG_H__
+#define __DEBUG_H__
+
+#include <string>
+
+#ifdef ANDROID
+#include <android/log.h>
+#endif
+
+namespace jub {
+
+#define DEBUG_LEVEL 1
+
+#define JUB_DebugLevel(level, ...)  \
+{                                   \
+    if (DEBUG_LEVEL >= level) {     \
+        JUB_DebugLog(__VA_ARGS__);  \
+    }                               \
+}
+
+#define JUB_Debug(level, STR)       \
+{                                   \
+    if (DEBUG_LEVEL >= level) {     \
+        JUB_DebugLog(STR);          \
+    }                               \
+}
+
+#ifdef ANDROID
+void JUB_DebugLog(android_LogPriority logPriority, const char *format, ...);
+void JUB_DebugLog(android_LogPriority logPriority, const std::string &log);
+#else
+void JUB_DebugLog(const char *format, ...);
+void JUB_DebugLog(const std::string &log);
+#endif
+
+#if defined(DEBUG) || defined(_DEBUG)
+    #ifdef ANDROID
+        #define DEBUG_LOG(...) jub::JUB_DebugLog(ANDROID_LOG_DEBUG, __VA_ARGS__)
+        #define DEBUG_ERR(...) jub::JUB_DebugLog(ANDROID_LOG_ERROR, __VA_ARGS__)
+    #else
+        #define DEBUG_LOG(...) jub::JUB_DebugLog(__VA_ARGS__)
+        #define DEBUG_ERR(...) jub::JUB_DebugLog(__VA_ARGS__)
+    #endif
+#else
+	#define DEBUG_LOG(...)
+    #define DEBUG_ERR(...)
+#endif
+
+enum {
+	BA2S_AA_BB,     //01 01 03 04
+	BA2S_0XAA_0XBB, //0x01 0x02 0x03 0x04
+	BA2S_AABB,      //01020304
+}; // enum end
+
+std::string ByteArray2String(const uint8_t* buf, uint32_t len, uint8_t type = BA2S_AABB);
+} // namespace jub end
+
+#endif // __DEBUG_H__

package/android/src/main/jni/GPChannel/include/utility/Singleton.h

@@ -0,0 +1,34 @@
+#pragma once
+#ifndef COINPASS_SINGLETON_HPP
+#define COINPASS_SINGLETON_HPP
+
+template<typename T>
+class Singleton {
+
+public:
+    template<typename... Args>
+    static T* GetInstance(Args&&... args) {
+        if (nullptr == _pInstance) {
+            _pInstance = new T(std::forward<Args>(args)...);
+        }
+        return _pInstance;
+    }
+
+    static void DestroyInstance() {
+        delete _pInstance;
+        _pInstance = nullptr;
+    }
+
+private:
+    Singleton(void);
+    virtual ~Singleton(void);
+    Singleton(const Singleton&);
+    Singleton& operator = (const Singleton&);
+
+private:
+    static T* _pInstance;
+}; // class Singleton end
+
+template <class T> T* Singleton<T>::_pInstance = nullptr;
+
+#endif

package/android/src/main/jni/GPChannel/include/utility/mutex.h

@@ -0,0 +1,24 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+/* 
+ * File:   mutex.h
+ * Author: zxc_work
+ *
+ * Created on 2020年2月22日, 下午2:08
+ */
+#pragma once
+
+#ifndef MUTEX_H
+#define MUTEX_H
+#include <mutex>
+
+extern std::mutex _mutex;
+
+#define CREATE_THREAD_LOCK_GUARD  std::lock_guard<std::mutex> lck(_mutex);
+
+#endif /* MUTEX_H */
+

package/android/src/main/jni/GPChannel/include/utility/trim.hpp

@@ -0,0 +1,155 @@
+//
+//  trim.hpp
+//  JubSDK
+//
+//  Created by panmin on 2019/9/26.
+//  Copyright © 2019 JuBiter. All rights reserved.
+//
+
+#ifndef trim_h
+#define trim_h
+
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+#include <iostream>
+#include <functional>
+
+namespace jub {
+namespace algorithm {
+
+namespace detail {
+//    template< typename ForwardIteratorT, typename PredicateT >
+//    inline ForwardIteratorT trim_end_iter_select(
+//                                                 ForwardIteratorT InBegin,
+//                                                 ForwardIteratorT InEnd,
+//                                                 PredicateT IsSpace,
+//                                                 std::forward_iterator_tag )
+//    {
+//        ForwardIteratorT TrimIt=InBegin;
+//
+//        for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
+//        {
+//            if ( !IsSpace(*It) )
+//            {
+//                TrimIt=It;
+//                ++TrimIt;
+//            }
+//        }
+//
+//        return TrimIt;
+//    }
+//
+//    template< typename ForwardIteratorT, typename PredicateT >
+//    inline ForwardIteratorT trim_end_iter_select(
+//                                                 ForwardIteratorT InBegin,
+//                                                 ForwardIteratorT InEnd,
+//                                                 PredicateT IsSpace,
+//                                                 std::bidirectional_iterator_tag )
+//    {
+//        for( ForwardIteratorT It=InEnd; It!=InBegin;  )
+//        {
+//            if ( !IsSpace(*(--It)) )
+//                return ++It;
+//        }
+//
+//        return InBegin;
+//    }
+
+template< typename ForwardIteratorT, typename PredicateT >
+inline ForwardIteratorT eTrim_iter_select(ForwardIteratorT InBegin,
+                                          ForwardIteratorT InEnd,
+                                          PredicateT IsSpace,
+                                          std::forward_iterator_tag ) {
+    ForwardIteratorT TrimIt=InBegin;
+    
+    for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
+    {
+        if ( !IsSpace(*It) )
+        {
+            TrimIt=It;
+            ++TrimIt;
+        }
+    }
+    
+    return TrimIt;
+}
+
+//    // Search for first non matching character from the beginning of the sequence
+//    template< typename ForwardIteratorT, typename PredicateT >
+//    inline ForwardIteratorT trim_begin(
+//                                       ForwardIteratorT InBegin,
+//                                       ForwardIteratorT InEnd,
+//                                       PredicateT IsSpace )
+//    {
+//        ForwardIteratorT It=InBegin;
+//        for(; It!=InEnd; ++It )
+//        {
+//            if (!IsSpace(*It))
+//                return It;
+//        }
+//
+//        return It;
+//    }
+template< typename ForwardIteratorT, typename PredicateT >
+inline ForwardIteratorT eTrim(ForwardIteratorT InBegin,
+                              ForwardIteratorT InEnd,
+                              PredicateT IsSpace ) {
+    typename std::iterator_traits<ForwardIteratorT>::iterator_category category;
+    return eTrim_iter_select(InBegin, InEnd, IsSpace, category);
+}
+
+} // namespace detail end
+
+template<typename SequenceT>
+inline SequenceT& lTrim(SequenceT &Input) {
+    auto p = find_if(Input.begin(), Input.end(), std::not1(std::function<bool(char)>(isspace)));
+    Input.erase(Input.begin(), p);
+    return Input;
+}
+
+//template<typename SequenceT, typename PredicateT>
+//inline void trim_right_if(SequenceT& Input, PredicateT IsSpace)
+//{
+//    Input.erase(
+//                ::boost::algorithm::detail::trim_end(
+//                                                     ::boost::begin(Input),
+//                                                     ::boost::end(Input),
+//                                                     IsSpace ),
+//                ::boost::end(Input)
+//                );
+//}
+template<typename SequenceT, typename PredicateT>
+inline void rTrim_if(SequenceT& Input, PredicateT IsSpace) {
+    Input.erase(detail::eTrim(Input.begin(),
+                              Input.end(),
+                              IsSpace),
+                Input.end());
+}
+
+//boost::algorithm::trim_right
+//template<typename SequenceT>
+//inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
+//{
+//    ::boost::algorithm::trim_right_if(
+//                                      Input,
+//                                      is_space(Loc) );
+//}
+template<typename SequenceT>
+inline SequenceT& rTrim(SequenceT &Input, const std::locale& Loc=std::locale()) {
+
+    auto p = find_if(Input.rbegin(), Input.rend(), std::not1(std::function<bool(char)>(isspace)));
+    Input.erase(p.base(), Input.end());
+    return Input;
+}
+
+template<typename SequenceT>
+inline SequenceT& trim(SequenceT &st) {
+    lTrim(rTrim(st));
+    return st;
+}
+
+} // namespace algorithm end
+} // namespace jub end
+#endif /* trim_h */

package/android/src/main/jni/GPChannel/include/utility/util.h

@@ -0,0 +1,104 @@
+#pragma once
+#ifndef COINPASS_BIO_UTIL_HPP
+#define COINPASS_BIO_UTIL_HPP
+
+#include <assert.h>
+#include <memory>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+#include <iostream>
+#include <cstring>
+#include "mSIGNA/stdutils/uchar_vector.h"
+//#include "Data.h"
+
+namespace jub {
+
+#define JUB_VERIFY_RET(x, r)    \
+do {                            \
+    if (!(x)) {                 \
+        return (r);             \
+    }                           \
+} while (0)
+
+#define JUB_VERIFY_RV(x)    \
+do {                        \
+    JUB_RV r = (x);         \
+    if (JUBR_OK != r) {     \
+        return r;           \
+    }                       \
+} while (0)
+
+#define JUB_CHECK_NULL(x)               \
+do {                                    \
+    if (!x) {                           \
+        assert(false);                  \
+        return JUBR_MEMORY_NULL_PTR;    \
+    }                                   \
+} while (0)
+
+#define JUB_UNREFERENCED_PARAMETER(P) (P)
+
+//template <class _Ty, size_t _Size>
+//constexpr size_t array_size(const _Ty (&)[_Size]) noexcept {
+//    return (_Size);
+//}
+//
+/*
+* String splitting function
+*/
+//std::vector<std::string> Split(std::string str, std::string pattern);
+/*
+* Merge string function
+*//*
+std::string Join(std::vector<std::string> v, std::string pattern);
+*/
+/*
+ * Decimal string conversion -> Hexadecimal string
+ */
+//std::string DecStringToHexString(std::string str);
+//
+//std::string numberToHexString(unsigned int val);
+//
+/*
+ * char array<uint8_t, 32> -> Hexadecimal string conversion
+ *//*
+std::string CharArray2HexStr(std::array<uint8_t, 32> v);
+*/
+/*
+ * Hexadecimal string conversion -> char array<uint8_t, 32>
+ *//*
+std::array<uint8_t, 32> HexStr2CharArray(std::string str);
+*/
+/*
+* std::vector<unsigned char> -> Hexadecimal string conversion
+*/
+//std::string CharPtr2HexStr(std::vector<unsigned char> v);
+//
+/*
+* Hexadecimal string conversion -> std::vector<unsigned char>
+*/
+//std::vector<unsigned char> HexStr2CharPtr(std::string str);
+/*
+// Put an array of strings into a vector
+std::vector<std::string> CharPtrArr2StrVector(const char* Arr[]);
+*/
+
+//#define ETH_PRDFIX "0x"
+/*
+ * std::vector<unsigned char> -> Hexadecimal string conversion
+ *//*
+std::string ETHCharPtr2HexStr(std::vector<unsigned char> v);
+*/
+/*
+ * Hexadecimal string conversion -> std::vector<unsigned char>
+ */
+//std::vector<unsigned char> ETHHexStr2CharPtr(std::string str);
+//
+//TW::Data ToTlv(uint8_t tag, const TW::Data &data);
+//std::vector<TW::Data> ParseTlv(const TW::Data &data);
+//TW::Data Tollv(const std::string& strData);
+} // namespace jub
+
+#endif

package/android/src/main/jni/GPChannel/include/utility/xFactory.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include <map>
+
+template<typename pI, typename T, typename F>
+class xFactory {
+
+protected:
+	typedef std::map<T, F> FactoryMap;
+	FactoryMap m_FactoryMap;
+
+public:
+	~xFactory() { m_FactoryMap.clear(); }
+
+	void Register(const T & name, F pfnCreate) {
+		m_FactoryMap[name] = pfnCreate;
+	};
+
+	template<typename... Args>
+	pI Create(const T &name, Args&&... args) {
+		auto it = m_FactoryMap.find(name);
+        if (it != m_FactoryMap.end()) {
+			return it->second(std::forward<Args>(args)...);
+        }
+		return nullptr;
+	}
+}; // class xFactory end

package/android/src/main/jni/GPChannel/include/utility/xManager.hpp

@@ -0,0 +1,84 @@
+#pragma once
+#ifndef __xManager__
+#define __xManager__
+
+#include "JUB_SDK.h"
+
+#include <map>
+
+template <class T>
+class xManager {
+public:
+    xManager() {
+        _ID = 0;
+        _last = nullptr;
+    };
+    ~xManager() {
+        ClearAll();
+    };
+
+    JUB_UINT16 AddOne(T* x) {
+        //srand((unsigned int)(time(NULL)));
+        //JUB_UINT16 ID = rand();
+        if (65535 == _ID) {
+            _ID = 0;
+        }
+        //JUB_UINT16 ID  = ++_ID;
+
+        //std::cout << "Add ID:" << ID << std::endl;
+        _mapList.insert(std::make_pair(++_ID, x));
+        return _ID;
+    };
+
+    JUB_UINT16 AddOne(JUB_UINT16 ID, T* x) {
+        _mapList.insert(std::make_pair(ID, x));
+
+        return ID;
+    };
+
+    T* GetLast() {
+        return _last;
+    };
+
+    void ClearLast() { _last = nullptr; };
+
+    void ClearOne(JUB_UINT16 ID) {
+        //std::cout << "Clear ID:" << ID << std::endl;
+        auto it = _mapList.find(ID);
+        if (it != _mapList.end()) {
+            delete it->second;
+            _mapList.erase(it);
+        }
+    }
+
+    void ClearAll() {
+        for (auto it : _mapList) {
+            delete it.second;
+        }
+        _mapList.clear();
+    }
+
+    T* GetOne(JUB_UINT16 ID) {
+        auto it = _mapList.find(ID);
+        if (it != _mapList.end()) {
+            _last = it->second;
+            return it->second;
+        }
+        return nullptr;
+    }
+
+    std::vector<JUB_UINT16> GetHandleList() {
+        std::vector<JUB_UINT16> vHandleList;
+        for (auto it : _mapList) {
+            vHandleList.push_back(it.first);
+        }
+        return vHandleList;
+    }
+
+protected:
+    std::map<JUB_UINT16, T*> _mapList;
+    T* _last;
+    JUB_UINT16 _ID;
+}; // class xManager end
+
+#endif