react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/bsdiff_wrapper/bspatch_wrapper.c

@@ -0,0 +1,266 @@
+// bspatch_wrapper.c
+// HDiffPatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2021 HouSisong
+ 
+ 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 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.
+ */
+#include "bspatch_wrapper.h"
+#include "../libHDiffPatch/HPatch/patch_types.h"
+#include "../libHDiffPatch/HPatch/patch_private.h"
+#include <string.h>
+#define _hpatch_FALSE   hpatch_FALSE
+//hpatch_uint __debug_check_false_x=0; //for debug
+//#define _hpatch_FALSE (1/__debug_check_false_x)
+
+#ifndef _IS_RUN_MEM_SAFE_CHECK
+#   define _IS_RUN_MEM_SAFE_CHECK  1
+#endif
+
+#if (_IS_RUN_MEM_SAFE_CHECK)
+// __RUN_MEM_SAFE_CHECK : enables out-of-bounds memory access checking to protect against data that may be accidentally or intentionally corrupted.
+#   define __RUN_MEM_SAFE_CHECK
+#endif
+
+static const char* kBsDiffVersionType = "BSDIFF40";
+#define            kBsDiffVersionTypeLen 8  // ==strlen(kBsDiffVersionType);
+#define            kBsDiffHeadLen       (kBsDiffVersionTypeLen+3*8)
+
+static const char* kEsBsDiffVersionType = "ENDSLEY/BSDIFF43";
+#define            kEsBsDiffVersionTypeLen 16  // ==strlen(kEsBsDiffVersionType);
+#define            kEsBsDiffHeadLen     (kEsBsDiffVersionTypeLen+8)
+
+
+static hpatch_inline hpatch_uint32_t _readUInt32(const unsigned char* buf){
+    return buf[0] | (((hpatch_uint32_t)buf[1])<<8)  |
+           (((hpatch_uint32_t)buf[2])<<16)  | (((hpatch_uint32_t)buf[3])<<24) ;
+}
+static hpatch_inline hpatch_uint64_t readUInt64(const unsigned char* buf){
+    return _readUInt32(buf) | (((hpatch_uint64_t)_readUInt32(buf+4))<<32);
+}
+
+#define _clip_readUInt64(_clip,_result) { \
+    const unsigned char* buf=_TStreamCacheClip_readData(_clip,8); \
+    if (buf!=0) *(_result)=readUInt64(buf); \
+    else return _hpatch_FALSE; \
+}
+
+hpatch_BOOL getBsDiffInfo(hpatch_BsDiffInfo* out_diffinfo,const hpatch_TStreamInput* diffStream){
+    unsigned char _buf[kBsDiffHeadLen];
+    unsigned char* buf=&_buf[0];
+    if (diffStream->streamSize<kBsDiffHeadLen)
+        return _hpatch_FALSE;
+    if (!diffStream->read(diffStream,0,buf,buf+kBsDiffHeadLen)) // must bz2 compressed size>=8
+        return _hpatch_FALSE;
+    if (0==memcmp(buf,kBsDiffVersionType,kBsDiffVersionTypeLen)){
+        out_diffinfo->isEndsleyBsdiff=hpatch_FALSE;
+        out_diffinfo->headSize=kBsDiffHeadLen;
+    }else if (0==memcmp(buf,kEsBsDiffVersionType,kEsBsDiffVersionTypeLen)){
+        out_diffinfo->isEndsleyBsdiff=hpatch_TRUE;
+        out_diffinfo->headSize=kEsBsDiffHeadLen;
+    }else{
+        return _hpatch_FALSE;
+    }
+    if (out_diffinfo->isEndsleyBsdiff){
+        buf+=kEsBsDiffVersionTypeLen;
+        out_diffinfo->ctrlDataSize=0;
+        out_diffinfo->subDataSize =0;
+        out_diffinfo->newDataSize =readUInt64(buf);
+    }else{
+        buf+=kBsDiffVersionTypeLen;
+        out_diffinfo->ctrlDataSize=readUInt64(buf);
+        out_diffinfo->subDataSize =readUInt64(buf+8);
+        out_diffinfo->newDataSize =readUInt64(buf+8*2);
+    }
+    return (out_diffinfo->ctrlDataSize<diffStream->streamSize)&&
+           (out_diffinfo->subDataSize<diffStream->streamSize)&&
+           (out_diffinfo->headSize+out_diffinfo->ctrlDataSize+out_diffinfo->subDataSize<diffStream->streamSize);
+}
+
+hpatch_BOOL getBsDiffInfo_mem(hpatch_BsDiffInfo* out_diffinfo,const unsigned char* diffData,const unsigned char* diffData_end){
+    hpatch_TStreamInput diffStream;
+    mem_as_hStreamInput(&diffStream,diffData,diffData_end);
+    return getBsDiffInfo(out_diffinfo,&diffStream);
+}
+
+hpatch_BOOL getIsBsDiff(const hpatch_TStreamInput* diffData,hpatch_BOOL* out_isSingleCompressedDiff){
+    hpatch_BsDiffInfo diffinfo;
+    hpatch_BOOL result=getBsDiffInfo(&diffinfo,diffData);
+    if (result&&out_isSingleCompressedDiff) *out_isSingleCompressedDiff=diffinfo.isEndsleyBsdiff;
+    return result;
+}
+
+hpatch_BOOL getIsBsDiff_mem(const unsigned char* diffData,const unsigned char* diffData_end,hpatch_BOOL* out_isSingleCompressedDiff){
+    hpatch_TStreamInput diffStream;
+    mem_as_hStreamInput(&diffStream,diffData,diffData_end);
+    return getIsBsDiff(&diffStream,out_isSingleCompressedDiff);
+}
+
+static hpatch_BOOL _patch_add_old_with_sub(_TOutStreamCache* outCache,TStreamCacheClip* subClip,
+                                           const hpatch_TStreamInput* old,hpatch_uint64_t oldPos,
+                                           hpatch_uint64_t addLength,unsigned char* aCache,hpatch_size_t aCacheSize){
+    while (addLength>0){
+        hpatch_size_t decodeStep=aCacheSize;
+        if (decodeStep>addLength)
+            decodeStep=(hpatch_size_t)addLength;
+        if (!old->read(old,oldPos,aCache,aCache+decodeStep)) return _hpatch_FALSE;
+        if (!_TStreamCacheClip_addDataTo(subClip,aCache,decodeStep)) return _hpatch_FALSE;
+        if (!_TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
+        oldPos+=decodeStep;
+        addLength-=decodeStep;
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL bspatchByClip(_TOutStreamCache* outCache,const hpatch_TStreamInput* oldData,
+                          TStreamCacheClip* ctrlClip,TStreamCacheClip* subClip,TStreamCacheClip* newDataDiffClip,
+                          unsigned char* temp_cache,hpatch_size_t cache_size){
+    const hpatch_uint64_t newDataSize=_TOutStreamCache_leaveSize(outCache);
+#ifdef __RUN_MEM_SAFE_CHECK
+    const hpatch_uint64_t oldDataSize=oldData->streamSize;
+#endif
+    hpatch_uint64_t     newPosBack=0;
+    hpatch_uint64_t     oldPosBack=0;
+    assert(cache_size>=8);
+    
+    while (newPosBack<newDataSize){
+        hpatch_uint64_t coverLen;
+        hpatch_uint64_t skipNewLen;
+        hpatch_uint64_t skipOldLen;
+        {//read ctrl
+            _clip_readUInt64(ctrlClip,&coverLen);
+            _clip_readUInt64(ctrlClip,&skipNewLen);
+            _clip_readUInt64(ctrlClip,&skipOldLen);
+        }
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (coverLen>(hpatch_uint64_t)(newDataSize-newPosBack)) return _hpatch_FALSE;
+        if (oldPosBack>oldDataSize) return _hpatch_FALSE;
+        if (coverLen>(hpatch_uint64_t)(oldDataSize-oldPosBack)) return _hpatch_FALSE;
+#endif
+        if (!_patch_add_old_with_sub(outCache,subClip,oldData,oldPosBack,coverLen,
+                                     temp_cache,cache_size)) return _hpatch_FALSE;
+        oldPosBack+=((skipOldLen>>63)==0)?(coverLen+skipOldLen):(coverLen-(skipOldLen&((((hpatch_uint64_t)1)<<63)-1)));
+        newPosBack+=coverLen;
+        if (skipNewLen){
+#ifdef __RUN_MEM_SAFE_CHECK
+            if (skipNewLen>(hpatch_uint64_t)(newDataSize-newPosBack)) return _hpatch_FALSE;
+#endif
+            if (!_TOutStreamCache_copyFromClip(outCache,newDataDiffClip,skipNewLen)) return _hpatch_FALSE;
+            newPosBack+=skipNewLen;
+        }
+    }
+
+    if (!_TOutStreamCache_flush(outCache))
+        return _hpatch_FALSE;
+    if (_TOutStreamCache_isFinish(outCache)
+        && (newPosBack==newDataSize) )
+        return hpatch_TRUE;
+    else
+        return _hpatch_FALSE;
+}
+
+
+#define _kCacheBsDecCount 5
+
+static const hpatch_uint64_t _kUnknowMaxSize=~(hpatch_uint64_t)0;
+#define _clear_return(exitValue) {  result=exitValue; goto clear; }
+
+hpatch_BOOL bspatch_with_cache(const hpatch_TStreamOutput* out_newData,
+                               const hpatch_TStreamInput*  oldData,
+                               const hpatch_TStreamInput*  compressedDiff,
+                               hpatch_TDecompress* decompressPlugin,
+                               unsigned char* temp_cache,unsigned char* temp_cache_end){
+    hpatch_BsDiffInfo diffInfo;
+    TStreamCacheClip  ctrlClip;
+    TStreamCacheClip  subClip;
+    TStreamCacheClip* _ctrlClip=&ctrlClip;
+    TStreamCacheClip* _subClip=&subClip;
+    TStreamCacheClip  newDataDiffClip;
+    _TDecompressInputStream decompressers[3];
+    hpatch_size_t           i;
+    hpatch_BOOL  result=hpatch_TRUE;
+    hpatch_StreamPos_t  diffPos0;
+    hpatch_size_t cacheSize;
+    hpatch_BOOL    isReadError=hpatch_FALSE;
+    assert(decompressPlugin!=0);
+    assert(out_newData!=0);
+    assert(out_newData->write!=0);
+    assert(oldData!=0);
+    assert(oldData->read!=0);
+    assert(compressedDiff!=0);
+    assert(compressedDiff->read!=0);
+    if (!getBsDiffInfo(&diffInfo,compressedDiff)) 
+        return _hpatch_FALSE;
+    if (out_newData->streamSize!=diffInfo.newDataSize)
+        return _hpatch_FALSE;
+    for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i)
+        decompressers[i].decompressHandle=0;
+
+    _patch_cache_all_old(&oldData,_kCacheBsDecCount*hpatch_kStreamCacheSize,&temp_cache,&temp_cache_end,&isReadError);//can cache all old?
+    if (isReadError) return _hpatch_FALSE;
+    cacheSize=(temp_cache_end-temp_cache);
+    cacheSize=cacheSize/(diffInfo.isEndsleyBsdiff?_kCacheBsDecCount-2:_kCacheBsDecCount);
+    if (cacheSize<8) return _hpatch_FALSE;
+
+    diffPos0=diffInfo.headSize;
+    if (diffInfo.isEndsleyBsdiff){
+        if (!getStreamClip(&newDataDiffClip,&decompressers[0],
+                        _kUnknowMaxSize,compressedDiff->streamSize-diffPos0,compressedDiff,&diffPos0,
+                        decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+        temp_cache+=cacheSize;
+        _ctrlClip=&newDataDiffClip;
+        _subClip=&newDataDiffClip;
+    }else{
+        if (!getStreamClip(&ctrlClip,&decompressers[0],
+                        _kUnknowMaxSize,diffInfo.ctrlDataSize,compressedDiff,&diffPos0,
+                        decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+        temp_cache+=cacheSize;
+        if (!getStreamClip(&subClip,&decompressers[1],
+                        _kUnknowMaxSize,diffInfo.subDataSize,compressedDiff,&diffPos0,
+                        decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+        temp_cache+=cacheSize;
+        if (!getStreamClip(&newDataDiffClip,&decompressers[2],
+                        _kUnknowMaxSize,compressedDiff->streamSize-diffPos0,compressedDiff,&diffPos0,
+                        decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+        temp_cache+=cacheSize;
+    }
+    assert(diffPos0==compressedDiff->streamSize);
+
+    {
+        _TOutStreamCache outCache;
+        _TOutStreamCache_init(&outCache,out_newData,temp_cache,cacheSize);
+        temp_cache+=cacheSize;
+        result=bspatchByClip(&outCache,oldData,_ctrlClip,_subClip,&newDataDiffClip,
+                            temp_cache,cacheSize);
+    }
+
+clear:
+    for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i) {
+        if (decompressers[i].decompressHandle){
+            if (!decompressPlugin->close(decompressPlugin,decompressers[i].decompressHandle))
+                result=_hpatch_FALSE;
+            decompressers[i].decompressHandle=0;
+        }
+    }
+    return result;
+}

package/harmony/pushy/src/main/cpp/HDiffPatch/bsdiff_wrapper/bspatch_wrapper.h

@@ -0,0 +1,58 @@
+// bspatch_wrapper.h
+// HDiffPatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2021 HouSisong
+ 
+ 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 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.
+ */
+#ifndef hpatch_bspatch_wrapper_h
+#define hpatch_bspatch_wrapper_h
+#include "../libHDiffPatch/HPatch/patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct hpatch_BsDiffInfo{
+    hpatch_StreamPos_t  headSize;
+    hpatch_StreamPos_t  ctrlDataSize;
+    hpatch_StreamPos_t  subDataSize;
+    hpatch_StreamPos_t  newDataSize;
+    hpatch_BOOL         isEndsleyBsdiff;
+} hpatch_BsDiffInfo;
+
+hpatch_BOOL getIsBsDiff(const hpatch_TStreamInput* diffData,hpatch_BOOL* out_isSingleCompressedDiff);
+hpatch_BOOL getIsBsDiff_mem(const unsigned char* diffData,const unsigned char* diffData_end,hpatch_BOOL* out_isSingleCompressedDiff);
+
+hpatch_BOOL getBsDiffInfo(hpatch_BsDiffInfo* out_diffinfo,const hpatch_TStreamInput* diffStream);
+hpatch_BOOL getBsDiffInfo_mem(hpatch_BsDiffInfo* out_diffinfo,const unsigned char* diffData,const unsigned char* diffData_end);
+
+hpatch_BOOL bspatch_with_cache(const hpatch_TStreamOutput* out_newData,
+                               const hpatch_TStreamInput*  oldData,
+                               const hpatch_TStreamInput*  compressedDiff, //create by bsdiff4 or hdiffz -BSD
+                               hpatch_TDecompress* decompressPlugin, // ==&_bz2DecompressPlugin_unsz in "decompress_plugin_demo.h"
+                               unsigned char* temp_cache,unsigned char* temp_cache_end);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/Android.mk

@@ -0,0 +1,190 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := hpatchz
+
+# args
+# is use multi-thread patch? (threads for I/O & decompress)
+MT    := 0
+ZLIB  := 1
+LZMA  := 1
+ZSTD  := 1
+BROTLI:= 0
+VCD   := 0
+# if open BSD,must open BZIP2
+BSD   := 0
+BZIP2 := 0
+# is need directory patch?
+DIR   := 0
+ifeq ($(DIR),0)
+  MD5 := 0
+  XXH := 0
+else
+  MD5 := 1
+  XXH := 1
+endif
+
+DEF_FLAGS := -Os -flto -DANDROID_NDK -DNDEBUG -D_LARGEFILE_SOURCE -D_IS_NEED_DEFAULT_CompressPlugin=0 \
+             -D_IS_NEED_CACHE_OLD_BY_COVERS=0 -D_IS_NEED_CACHE_OLD_ALL=1
+LINK_FLAGS:= -llog
+
+HDP_PATH  := $(LOCAL_PATH)/../..
+Src_Files := $(HDP_PATH)/builds/android_ndk_jni_mk/hpatch_jni.c \
+             $(HDP_PATH)/builds/android_ndk_jni_mk/hpatch.c \
+             $(HDP_PATH)/file_for_patch.c \
+             $(HDP_PATH)/libHDiffPatch/HPatch/patch.c
+
+ifeq ($(MT),0)
+  DEF_FLAGS += -D_IS_USED_MULTITHREAD=0
+else  
+  DEF_FLAGS += -D_IS_USED_MULTITHREAD=1
+  Src_Files += $(HDP_PATH)/libHDiffPatch/HPatch/hpatch_mt/_hcache_old_mt.c \
+               $(HDP_PATH)/libHDiffPatch/HPatch/hpatch_mt/_hinput_mt.c \
+               $(HDP_PATH)/libHDiffPatch/HPatch/hpatch_mt/_houtput_mt.c \
+               $(HDP_PATH)/libHDiffPatch/HPatch/hpatch_mt/_hpatch_mt.c \
+               $(HDP_PATH)/libHDiffPatch/HPatch/hpatch_mt/hpatch_mt.c \
+               $(HDP_PATH)/libParallel/parallel_import_c.c
+endif
+
+ifeq ($(DIR),0)
+  DEF_FLAGS += -D_IS_NEED_DIR_DIFF_PATCH=0
+else
+  DEF_FLAGS += -D_IS_NEED_DIR_DIFF_PATCH=1 -D_IS_NEED_DEFAULT_ChecksumPlugin=0 -D_ChecksumPlugin_fadler64
+  Src_Files += $(HDP_PATH)/libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c \
+               $(HDP_PATH)/dirDiffPatch/dir_patch/dir_patch.c \
+               $(HDP_PATH)/dirDiffPatch/dir_patch/dir_patch_tools.c \
+               $(HDP_PATH)/dirDiffPatch/dir_patch/new_dir_output.c \
+               $(HDP_PATH)/dirDiffPatch/dir_patch/new_stream.c \
+               $(HDP_PATH)/dirDiffPatch/dir_patch/ref_stream.c \
+               $(HDP_PATH)/dirDiffPatch/dir_patch/res_handle_limit.c
+
+  ifeq ($(ZLIB),0)
+  else
+    DEF_FLAGS += -D_ChecksumPlugin_crc32
+  endif
+  ifeq ($(MD5),0)
+  else
+    MD5_PATH := $(HDP_PATH)/../libmd5
+    DEF_FLAGS += -D_ChecksumPlugin_md5 -I$(MD5_PATH)
+    Src_Files += $(MD5_PATH)/md5.c
+  endif
+  ifeq ($(XXH),0)
+  else
+    XXH_PATH := $(HDP_PATH)/../xxHash
+    DEF_FLAGS += -D_ChecksumPlugin_xxh3 -D_ChecksumPlugin_xxh128 -I$(XXH_PATH)
+  endif
+endif
+
+ifeq ($(BSD),0)
+  DEF_FLAGS += -D_IS_NEED_BSDIFF=0
+else
+  DEF_FLAGS += -D_IS_NEED_BSDIFF=1
+  Src_Files += $(HDP_PATH)/bsdiff_wrapper/bspatch_wrapper.c
+endif
+
+ifeq ($(VCD),0)
+  DEF_FLAGS += -D_IS_NEED_VCDIFF=0
+else
+  DEF_FLAGS += -D_IS_NEED_VCDIFF=1
+  Src_Files += $(HDP_PATH)/vcdiff_wrapper/vcpatch_wrapper.c
+  ifeq ($(DIR),0)
+    Src_Files +=$(HDP_PATH)/libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c
+  endif
+endif
+
+ifeq ($(ZLIB),0)
+else
+  DEF_FLAGS += -D_CompressPlugin_zlib
+  LINK_FLAGS+= -lz
+endif
+
+ifeq ($(BZIP2),0)
+else
+  # http://www.bzip.org  https://github.com/sisong/bzip2
+  BZ2_PATH  :=  $(HDP_PATH)/../bzip2
+  DEF_FLAGS += -D_CompressPlugin_bz2 -DBZ_NO_STDIO -I$(BZ2_PATH)
+  Src_Files +=  $(BZ2_PATH)/blocksort.c \
+                $(BZ2_PATH)/bzlib.c \
+                $(BZ2_PATH)/compress.c \
+                $(BZ2_PATH)/crctable.c \
+                $(BZ2_PATH)/decompress.c \
+                $(BZ2_PATH)/huffman.c \
+                $(BZ2_PATH)/randtable.c
+endif
+
+ifeq ($(LZMA),0)
+else
+  # https://github.com/sisong/lzma
+  LZMA_PATH := $(HDP_PATH)/../lzma/C
+  DEF_FLAGS += -D_CompressPlugin_lzma -D_CompressPlugin_lzma2 -DZ7_ST -I$(LZMA_PATH)
+  ifeq ($(TARGET_ARCH_ABI),arm64-v8a)
+    DEF_FLAGS += -DZ7_LZMA_DEC_OPT
+  endif
+  Src_Files += $(LZMA_PATH)/LzmaDec.c \
+               $(LZMA_PATH)/Lzma2Dec.c
+  ifeq ($(TARGET_ARCH_ABI),arm64-v8a)
+    Src_Files += $(LZMA_PATH)/../Asm/arm64/LzmaDecOpt.S
+  endif
+  ifeq ($(VCD),0)
+  else
+    DEF_FLAGS += -D_CompressPlugin_7zXZ
+    Src_Files +=$(LZMA_PATH)/7zCrc.c \
+                $(LZMA_PATH)/7zCrcOpt.c \
+                $(LZMA_PATH)/Bra.c \
+                $(LZMA_PATH)/Bra86.c \
+                $(LZMA_PATH)/BraIA64.c \
+                $(LZMA_PATH)/Delta.c \
+                $(LZMA_PATH)/Sha256.c \
+                $(LZMA_PATH)/Sha256Opt.c \
+                $(LZMA_PATH)/Xz.c \
+                $(LZMA_PATH)/XzCrc64.c \
+                $(LZMA_PATH)/XzCrc64Opt.c \
+                $(LZMA_PATH)/XzDec.c \
+                $(LZMA_PATH)/CpuArch.c
+  endif
+endif
+
+ifeq ($(ZSTD),0)
+else
+  # https://github.com/sisong/zstd
+  ZSTD_PATH  := $(HDP_PATH)/../zstd/lib
+  DEF_FLAGS += -D_CompressPlugin_zstd -I$(ZSTD_PATH) -I$(ZSTD_PATH)/common -I$(ZSTD_PATH)/decompress \
+			-DZSTD_HAVE_WEAK_SYMBOLS=0 -DZSTD_TRACE=0 -DZSTD_DISABLE_ASM=1 -DZSTDLIB_HIDDEN= \
+			-DZSTDLIB_VISIBLE= -DZDICTLIB_VISIBLE= -DZSTDERRORLIB_VISIBLE= \
+			-DDYNAMIC_BMI2=0 -DZSTD_LEGACY_SUPPORT=0 -DZSTD_LIB_DEPRECATED=0 -DHUF_FORCE_DECOMPRESS_X1=1 \
+			-DZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT=1 -DZSTD_NO_INLINE=1 -DZSTD_STRIP_ERROR_STRINGS=1 -DZSTDERRORLIB_VISIBILITY=
+  Src_Files +=$(ZSTD_PATH)/common/debug.c \
+              $(ZSTD_PATH)/common/entropy_common.c \
+              $(ZSTD_PATH)/common/error_private.c \
+              $(ZSTD_PATH)/common/fse_decompress.c \
+              $(ZSTD_PATH)/common/xxhash.c \
+              $(ZSTD_PATH)/common/zstd_common.c \
+              $(ZSTD_PATH)/decompress/huf_decompress.c \
+              $(ZSTD_PATH)/decompress/zstd_ddict.c \
+              $(ZSTD_PATH)/decompress/zstd_decompress.c \
+              $(ZSTD_PATH)/decompress/zstd_decompress_block.c
+endif
+
+ifeq ($(BROTLI),0)
+else
+  # https://github.com/google/brotli
+  BROTLI_PATH := $(HDP_PATH)/../brotli/c
+  DEF_FLAGS += -D_CompressPlugin_brotli -I$(BROTLI_PATH)/include
+  Src_Files +=$(BROTLI_PATH)/common/constants.c \
+              $(BROTLI_PATH)/common/context.c \
+              $(BROTLI_PATH)/common/dictionary.c \
+              $(BROTLI_PATH)/common/platform.c \
+              $(BROTLI_PATH)/common/shared_dictionary.c \
+              $(BROTLI_PATH)/common/transform.c \
+              $(BROTLI_PATH)/dec/bit_reader.c \
+              $(BROTLI_PATH)/dec/decode.c \
+              $(BROTLI_PATH)/dec/huffman.c \
+              $(BROTLI_PATH)/dec/state.c
+endif
+
+
+LOCAL_SRC_FILES := $(Src_Files)
+LOCAL_LDLIBS    := $(LINK_FLAGS)
+LOCAL_CFLAGS    := $(DEF_FLAGS)
+include $(BUILD_SHARED_LIBRARY)
+

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/Application.mk

@@ -0,0 +1,8 @@
+APP_PLATFORM := android-16
+APP_CFLAGS += -s -Wno-error=format-security
+APP_CFLAGS += -fvisibility=hidden -fvisibility-inlines-hidden
+APP_CFLAGS += -ffunction-sections -fdata-sections
+APP_LDFLAGS += -s -Wl,--gc-sections,--as-needed
+APP_LDFLAGS += -Wl,-z,max-page-size=16384
+APP_BUILD_SCRIPT := Android.mk
+APP_ABI := arm64-v8a armeabi-v7a x86_64 x86

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/build_libs.bat

@@ -0,0 +1 @@
+ndk-build NDK_PROJECT_PATH=.  APP_BUILD_SCRIPT=Android.mk  NDK_APPLICATION_MK=Application.mk

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/build_libs.sh

@@ -0,0 +1 @@
+ndk-build NDK_PROJECT_PATH=.  APP_BUILD_SCRIPT=Android.mk  NDK_APPLICATION_MK=Application.mk

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/build_libs_patchers.bat

@@ -0,0 +1 @@
+ndk-build NDK_PROJECT_PATH=.  APP_BUILD_SCRIPT=Android.mk  NDK_APPLICATION_MK=Application.mk BSD=1 VCD=1 BZIP2=1

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/build_libs_patchers.sh

@@ -0,0 +1 @@
+ndk-build NDK_PROJECT_PATH=.  APP_BUILD_SCRIPT=Android.mk  NDK_APPLICATION_MK=Application.mk BSD=1 VCD=1 BZIP2=1

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/hpatch.c

@@ -0,0 +1,49 @@
+// hpatch.c
+// Created by sisong on 2019-12-30.
+#include "hpatch.h"
+
+#define _IS_NEED_PRINT_LOG              0
+#define _IS_NEED_MAIN                   0
+#define _IS_NEED_CMDLINE                0
+#define _IS_NEED_SFX                    0
+#define _IS_NEED_ALL_CompressPlugin     0
+#define _IS_NEED_ALL_ChecksumPlugin     0
+#include "../../hpatchz.c"
+
+#ifdef _CompressPlugin_bz2
+# ifdef BZ_NO_STDIO
+#ifdef __cplusplus
+extern "C" {
+#endif
+void bz_internal_error(int errcode){
+    LOG_ERR("\n\nbzip2 v%s: internal error number %d.\n",
+            BZ2_bzlibVersion(),errcode);
+    exit(HPATCH_DECOMPRESSER_DECOMPRESS_ERROR);
+}
+#ifdef __cplusplus
+}
+#endif
+# endif
+#endif
+
+    static inline size_t limitCacheMemory(int64_t cacheMemory){
+        #define _kPatchCacheSize_min  (1024*256)
+        #define _kPatchCacheSize_max  (((size_t)1)<<((sizeof(size_t)>4)?32:30))
+        if (cacheMemory<=_kPatchCacheSize_min) return _kPatchCacheSize_min;
+        return (size_t)(((uint64_t)cacheMemory<_kPatchCacheSize_max)?cacheMemory:_kPatchCacheSize_max);
+    }
+
+int hpatchz(const char *oldFileName,const char *diffFileName,
+            const char *outNewFileName,int64_t cacheMemory,size_t threadNum){
+#if (_IS_NEED_DIR_DIFF_PATCH)
+    const hpatch_BOOL isDirDiff=getIsDirDiffFile(diffFileName);
+    if (isDirDiff){
+        TDirPatchChecksumSet checksumSet={0,hpatch_FALSE,hpatch_TRUE,hpatch_TRUE,hpatch_FALSE};
+        return hpatch_dir(oldFileName,diffFileName,outNewFileName,
+                          hpatch_FALSE,limitCacheMemory(cacheMemory),kMaxOpenFileNumber_default_patch,
+                          &checksumSet,&defaultPatchDirlistener,0,0,threadNum);
+    } else
+#endif
+        return hpatch(oldFileName,diffFileName,outNewFileName,
+                      hpatch_FALSE,limitCacheMemory(cacheMemory),0,0,1,1,threadNum);
+}

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/hpatch.h

@@ -0,0 +1,31 @@
+// hpatch.h
+// Created by sisong on 2019-12-30.
+#ifndef hpatch_h
+#define hpatch_h
+#include <assert.h>
+#include <string.h>
+#include <stdint.h> //int64_t
+#ifdef __cplusplus
+extern "C" {
+#endif
+    #ifndef H_PATCH_EXPORT
+    #   if ( __GNUC__ >= 4 )
+        #define H_PATCH_EXPORT __attribute__((visibility("default")))
+    #   else
+        #define H_PATCH_EXPORT
+    #   endif
+    #endif
+
+    // return THPatchResult, 0 is ok
+    //  threadNum: 1..5
+    //    multi-thread (threadNum>1) patching now only support single compressed diffData(created by hdiffz -SD);
+    //  cacheMemory:
+    //    cacheMemory is used for file IO, different cacheMemory only affects patch speed;
+    //    recommended 256*1024,1024*1024,... if cacheMemory<0 then default 256*1024;
+    int hpatchz(const char *oldFileName,const char *diffFileName,
+                const char *outNewFileName,int64_t cacheMemory,size_t threadNum) H_PATCH_EXPORT;
+
+#ifdef __cplusplus
+}
+#endif
+#endif // hpatch_h

package/harmony/pushy/src/main/cpp/HDiffPatch/builds/android_ndk_jni_mk/hpatch_jni.c

@@ -0,0 +1,38 @@
+// hpatch_jni.c
+// Created by sisong on 2019-09-30.
+#include <jni.h>
+#include "hpatch.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    #define HPATCH_OPTIONS_ERROR 1
+    #define _check_rt(v)              do { if (!(v)) { result=HPATCH_OPTIONS_ERROR; goto _clear; }; } while(0)
+    #define __j2cstr_(jstr,cstr)      do { (cstr)=(*jenv)->GetStringUTFChars(jenv,jstr,NULL); _check_rt(cstr); } while(0)
+    #define _check_j2cstr(jstr,cstr)  do { _check_rt(jstr); __j2cstr_(jstr,cstr); } while(0)
+    #define _check_jn2cstr(jstr,cstr) do { if (jstr) __j2cstr_(jstr,cstr); else (cstr)=0; } while(0)
+    #define _jrelease_cstr(jstr,cstr) do { if (cstr) (*jenv)->ReleaseStringUTFChars(jenv,jstr,cstr); } while(0)
+
+    JNIEXPORT jint
+    Java_com_github_sisong_HPatch_patch(JNIEnv* jenv,jobject jobj,
+                                        jstring oldFileName,jstring diffFileName,
+                                        jstring outNewFileName,jlong cacheMemory,jint threadNum){
+        const char* cOldFileName   =0;
+        const char* cDiffFileName  =0;
+        const char* cOutNewFileName=0;
+        int result=0;
+
+        _check_jn2cstr(oldFileName,cOldFileName);
+        _check_j2cstr(diffFileName,cDiffFileName);
+        _check_j2cstr(outNewFileName,cOutNewFileName);
+        result=hpatchz(cOldFileName,cDiffFileName,cOutNewFileName,(int64_t)cacheMemory,(threadNum>1)?threadNum:1);
+    _clear:
+        _jrelease_cstr(outNewFileName,cOutNewFileName);
+        _jrelease_cstr(diffFileName,cDiffFileName);
+        _jrelease_cstr(oldFileName,cOldFileName);
+        return result;
+    }
+    
+#ifdef __cplusplus
+}
+#endif
+