react-native-update 10.34.1 → 10.34.3

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/sync_make_hash_clash.h

@@ -0,0 +1,122 @@
+//  sync_make_hash_clash.h
+//  sync_make
+//  Created by housisong on 2019-09-17.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019-2022 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 hsync_make_hash_clash_h
+#define hsync_make_hash_clash_h
+#include "../sync_client/sync_client_type.h"
+#include "../sync_client/sync_client_type_private.h"
+
+namespace sync_private{
+    const size_t _kMaxRollHashBits      = 8*sizeof(uint64_t);
+    const size_t _kBadRollHashBits      = _kMaxRollHashBits/2; //for reduce defect in fadler64 & toSavedPartRollHash
+    
+    hpatch_inline static
+    size_t _estimateCompareCountBit(hpatch_StreamPos_t newDataSize,uint32_t kSyncBlockSize){
+        hpatch_StreamPos_t blockCount=getSyncBlockCount(newDataSize,kSyncBlockSize);
+        const hpatch_StreamPos_t nbmul=newDataSize*blockCount;
+        if ((blockCount==0)||(nbmul/blockCount)==newDataSize)
+            return sync_private::upper_ilog2(nbmul);
+        else
+            return sync_private::upper_ilog2(newDataSize)+sync_private::upper_ilog2(blockCount);
+    }
+    
+    hpatch_inline static
+    size_t getNeedHashBits(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,uint32_t kSyncBlockSize){
+        const size_t _kNeedMinHashBits=_kNeedMinRollHashBits+_kNeedMinStrongHashBits;
+        size_t compareCountBit=_estimateCompareCountBit(newDataSize,kSyncBlockSize);
+        size_t result=compareCountBit+kSafeHashClashBit;
+        return (result>=_kNeedMinHashBits)?result:_kNeedMinHashBits;
+    }
+    hpatch_inline static
+    size_t getSavedHashBits(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,uint32_t kSyncBlockSize,
+                            size_t kStrongHashBits,size_t* out_partRollHashBits,size_t* out_partStrongHashBits){
+        const size_t result=getNeedHashBits(kSafeHashClashBit,newDataSize,kSyncBlockSize);
+        assert(kStrongHashBits>=kStrongChecksumByteSize_min*8);
+        assert(result<=kStrongHashBits+_kMaxRollHashBits);
+        size_t compareCountBit=_estimateCompareCountBit(newDataSize,kSyncBlockSize);
+        size_t rollHashBits=compareCountBit;
+        if (rollHashBits<_kNeedMinRollHashBits) rollHashBits=_kNeedMinRollHashBits;
+        else if (rollHashBits>_kMaxRollHashBits) rollHashBits=_kMaxRollHashBits;
+        assert(rollHashBits<=result);
+
+        #define __StrongHashBITS_ ((size_t)(result-rollHashBits))
+        if (__StrongHashBITS_<rollHashBits){
+            rollHashBits-=2;
+        }
+        if (__StrongHashBITS_<_kNeedMinStrongHashBits){
+            rollHashBits=result-_kNeedMinStrongHashBits;
+        }
+        if (rollHashBits<__StrongHashBITS_){
+            size_t moveBits=(__StrongHashBITS_-rollHashBits+2)/3;
+            moveBits=(moveBits<=_kNeedMinRollHashBits)?moveBits:_kNeedMinRollHashBits;
+            rollHashBits+=moveBits;
+            if (rollHashBits>_kMaxRollHashBits) rollHashBits=_kMaxRollHashBits;
+        }
+        if (__StrongHashBITS_>kStrongHashBits){
+            rollHashBits=result-kStrongHashBits;
+            assert((rollHashBits>=_kNeedMinRollHashBits)&&(rollHashBits<=_kMaxRollHashBits));
+        }
+        if (rollHashBits==_kBadRollHashBits){
+            size_t moveBits=(__StrongHashBITS_<kStrongHashBits)?1:((size_t)0)-((size_t)1);
+            rollHashBits-=moveBits;
+        }
+        *out_partRollHashBits=rollHashBits;
+        *out_partStrongHashBits=__StrongHashBITS_;
+        #undef __StrongHashBITS_
+        return result;
+    }
+}//namespace sync_private
+
+
+hpatch_inline static //check strongChecksumBits is strong enough?
+bool _getStrongForHashClash(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,
+                            uint32_t kSyncBlockSize,size_t strongChecksumBits,size_t validRollHashBits){
+    if (strongChecksumBits<kStrongChecksumByteSize_min*8)
+        return false;
+    size_t needHashBits=sync_private::getNeedHashBits(kSafeHashClashBit,newDataSize,kSyncBlockSize);
+    return validRollHashBits+strongChecksumBits>=needHashBits;
+}
+
+hpatch_inline static //check strongChecksumBits is strong enough?
+bool getStrongForHashClash(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,
+                           uint32_t kSyncBlockSize,size_t strongChecksumBits){
+    return _getStrongForHashClash(kSafeHashClashBit,newDataSize,kSyncBlockSize,
+                                  strongChecksumBits,sync_private::_kMaxRollHashBits);
+}
+
+hpatch_inline static
+hpatch_StreamPos_t estimatePatchMemSize(size_t kSafeHashClashBit,hpatch_StreamPos_t newDataSize,
+                                        uint32_t kSyncBlockSize,bool isUsedCompress){
+    hpatch_StreamPos_t blockCount=getSyncBlockCount(newDataSize,kSyncBlockSize);
+    hpatch_StreamPos_t bet=24;
+    bet+= _bitsToBytes(sync_private::getNeedHashBits(kSafeHashClashBit,newDataSize,kSyncBlockSize)+4);
+    bet+=isUsedCompress?4:0;
+    return bet*blockCount + 2*(hpatch_StreamPos_t)kSyncBlockSize;
+}
+
+#endif // hsync_make_hash_clash_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/sync_make/sync_make_private.h

@@ -0,0 +1,66 @@
+//  sync_make_private.h
+//  sync_make
+/*
+ The MIT License (MIT)
+ Copyright (c) 2019-2025 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 hsync_make_private_h
+#define hsync_make_private_h
+#include "../../libHDiffPatch/HPatch/checksum_plugin.h"
+#include "../../libHDiffPatch/HDiff/diff_types.h"
+#include "../../dirDiffPatch/dir_diff/dir_diff_tools.h"
+#include "../sync_client/sync_client_type.h"
+#include "../sync_client/match_in_types.h"
+#include "dict_compress_plugin.h"
+#include "hsynz_plugin.h"
+namespace sync_private{
+
+struct _TCompress;
+struct _TCreateDatas;
+struct TWorkBuf;
+
+struct _ICreateSync_by{
+    tm_roll_uint     (*roll_hash_start)(const adler_data_t* pdata,size_t n);
+    tm_roll_uint (*toSavedPartRollHash)(tm_roll_uint rollHash,size_t savedRollHashBits);
+    void           (*checkChecksumInit)(unsigned char* checkChecksumBuf,size_t checksumByteSize);
+    void     (*checkChecksumAppendData)(unsigned char* checkChecksumBuf,uint32_t checksumIndex,
+                                        hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum,
+                                        const unsigned char* blockChecksum,const unsigned char* blockData,size_t blockDataSize);
+    void          (*checkChecksumEndTo)(unsigned char* dst,unsigned char* checkChecksumBuf,
+                                        hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum);
+    void       (*create_sync_data_part)(_TCreateDatas& cd,TWorkBuf* workData,
+                                        hdiff_private::CChecksum& checksumBlockData,_TCompress& compress,void* _mt);
+    
+};
+
+void _create_sync_data_by(_ICreateSync_by* cs_by,TNewDataSyncInfo* newSyncInfo,
+                          const hpatch_TStreamInput* newData,const hpatch_TStreamOutput* out_hsynz,
+                          hsync_TDictCompress* compressPlugin,hsync_THsynz* hsynzPlugin,size_t threadNum);
+
+void _private_create_sync_data(TNewDataSyncInfo* newSyncInfo, const hpatch_TStreamInput*  newData,
+                               const hpatch_TStreamOutput* out_hsyni, const hpatch_TStreamOutput* out_hsynz,
+                               hsync_TDictCompress* compressPlugin, hsync_THsynz* hsynzPlugin,size_t threadNum);
+               
+}
+#endif // hsync_make_private_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/zsync_client_wrapper/zsync_client_type.h

@@ -0,0 +1,36 @@
+// zsync_client_type.h
+// zsync_client for hsynz
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 zsync_client_type_h
+#define zsync_client_type_h
+#include "../sync_client/sync_info_client.h"
+
+typedef TNewDataSyncInfo TNewDataZsyncInfo;
+static inline
+void TNewDataZsyncInfo_init(TNewDataZsyncInfo* self) { TNewDataSyncInfo_init(self); }
+
+#endif

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/zsync_client_wrapper/zsync_client_type_private.h

@@ -0,0 +1,81 @@
+//  zsync_client_type_private.h
+//  zsync_client for hsynz
+//  Created by housisong on 2025-07-04.
+/*
+ The MIT License (MIT)
+ Copyright (c) 2015 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 zsync_client_type_private_h
+#define zsync_client_type_private_h
+#include "../sync_client/sync_client_type_private.h"
+
+namespace sync_private{
+
+inline static hpatch_uint32_t z_roll_hash32_start(const adler_data_t* pdata,size_t n){
+    hpatch_uint32_t radler=0; hpatch_uint32_t sum=0;
+    for (;n>0;n--){
+        radler+=*pdata++;
+        sum+=radler;
+    }
+    return (sum<<16) | (radler&0xFFFF);
+}
+    
+hpatch_force_inline static hpatch_uint32_t z_roll_hash32_roll(hpatch_uint32_t adler,size_t blockSize,
+                                                              adler_data_t out_data,adler_data_t in_data){
+    hpatch_uint32_t sum=(adler>>16)-((hpatch_uint32_t)blockSize)*out_data;
+    hpatch_uint32_t radler=adler+in_data-out_data;
+    return ((sum+radler)<<16) | (radler&0xFFFF);
+}
+
+
+struct zsync_checkChecksum_t{
+    volatile hpatch_uint32_t checkBlockIndex;
+    volatile hpatch_byte     state; //0: not run, 1: checking, 2: end
+};
+
+static hpatch_inline
+size_t z_checkChecksumBufByteSize(size_t kStrongChecksumByteSize){
+        return 2*kStrongChecksumByteSize+sizeof(zsync_checkChecksum_t); }
+
+void z_checkChecksumInit(unsigned char* checkChecksumBuf,size_t kStrongChecksumByteSize);
+
+
+//must call by checksumIndex order
+void z_checkChecksumAppendData(unsigned char* checkChecksumBuf,uint32_t checksumIndex,
+                               hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum,
+                               const unsigned char* blockChecksum,const unsigned char* blockData,size_t blockDataSize);
+
+void z_checkChecksumEndTo(unsigned char* dst,unsigned char* checkChecksumBuf,
+                          hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum);
+
+static hpatch_force_inline
+hpatch_uint64_t z_toSavedPartRollHash(hpatch_uint64_t _rollHash,size_t savedRollHashBits){
+    //byte order: 0123 -> 2301
+    hpatch_uint32_t rollHash=(hpatch_uint32_t)_rollHash;
+    rollHash= (rollHash<<16) | (rollHash>>16);
+    return rollHash<<(32-savedRollHashBits)>>(32-savedRollHashBits);
+}
+
+} //namespace sync_private
+#endif //zsync_client_type_private_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/zsync_client_wrapper/zsync_client_wrapper.cpp

@@ -0,0 +1,247 @@
+// zsync_client_wrapper.h
+// zsync_client for hsynz
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 "zsync_client_wrapper.h"
+#include "zsync_client_type_private.h"
+#include "zsync_info_client.h"
+#include "zsync_match_in_old.h"
+#include "../sync_client/sync_client_private.h"
+#include "../sync_client/sync_diff_data.h"
+#include "../../libHDiffPatch/HPatch/patch_private.h"
+#include "../../file_for_patch.h"
+#include <stdexcept>
+namespace sync_private{
+
+#define check(v,errorCode) \
+            do{ if (!(v)) { if (result==kSyncClient_ok) result=errorCode; \
+                            if (!_inClear) goto clear; } }while(0)
+
+void z_checkChecksumInit(unsigned char* checkChecksumBuf,size_t kStrongChecksumByteSize){
+    zsync_checkChecksum_t* self=(zsync_checkChecksum_t*)(checkChecksumBuf+2*kStrongChecksumByteSize);
+    assert((kStrongChecksumByteSize%sizeof(self->checkBlockIndex))==0);
+    self->checkBlockIndex=0;
+    self->state=0; //not run
+}
+
+void z_checkChecksumAppendData(unsigned char* checkChecksumBuf,uint32_t checksumIndex,
+                               hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum,
+                               const unsigned char* blockChecksum,const unsigned char* blockData,size_t blockDataSize){
+    const size_t kStrongChecksumByteSize=checkChecksumPlugin->checksumByteSize();
+    zsync_checkChecksum_t* self=(zsync_checkChecksum_t*)(checkChecksumBuf+2*kStrongChecksumByteSize);
+    assert(self->checkBlockIndex<=checksumIndex); //must check by order
+    self->checkBlockIndex++;
+    if (self->state==0){
+        assert(checksumIndex==0);
+        self->state=1; //checking
+        checkChecksumPlugin->begin(checkChecksum);
+    }
+    checkChecksumPlugin->append(checkChecksum,blockData,blockData+blockDataSize);
+}
+
+void z_checkChecksumEndTo(unsigned char* dst,unsigned char* checkChecksumBuf,
+                          hpatch_TChecksum* checkChecksumPlugin,hpatch_checksumHandle checkChecksum){
+    const size_t kStrongChecksumByteSize=checkChecksumPlugin->checksumByteSize();
+    zsync_checkChecksum_t* self=(zsync_checkChecksum_t*)(checkChecksumBuf+2*kStrongChecksumByteSize);
+    unsigned char* checksum=checkChecksumBuf+kStrongChecksumByteSize;
+    if (self->state==0){
+        self->state=1;
+        checkChecksumPlugin->begin(checkChecksum);
+    }
+    if (self->state==1){
+        checkChecksumPlugin->end(checkChecksum,checksum,checksum+kStrongChecksumByteSize);
+        self->state=2; //end
+    }
+    assert(self->state==2);
+    memcpy(dst,checksum,kStrongChecksumByteSize);
+}
+
+
+static TSyncClient_resultType z_writeToNewOrDiff(_TWriteDatas& wd) {
+    _IWriteToNewOrDiff_by wr_by={0};
+    wr_by.checkChecksumAppendData=
+        ((const TNewDataZsyncInfo*)wd.newSyncInfo)->fileChecksumPlugin?z_checkChecksumAppendData:0;
+    return _writeToNewOrDiff_by(&wr_by,wd);
+}
+
+TSyncClient_resultType
+    _zsync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,TSyncDiffData* diffData,
+                 const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
+                 const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
+                 const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
+                 const hpatch_TStreamInput* diffContinue,int threadNum){
+    _ISyncPatch_by sp_by={0};
+    sp_by.matchNewDataInOld=z_matchNewDataInOld;
+    sp_by.writeToNewOrDiff=z_writeToNewOrDiff;
+    sp_by.checkChecksumInit=newSyncInfo->fileChecksumPlugin?z_checkChecksumInit:0;
+    sp_by.checkChecksumEndTo=newSyncInfo->fileChecksumPlugin?z_checkChecksumEndTo:0;
+    return _sync_patch_by(&sp_by, listener,syncDataListener,diffData,oldStream,newSyncInfo,
+                          out_newStream,newDataContinue,out_diffStream,diffType,diffContinue,threadNum);
+}
+
+}//end namespace sync_private
+using namespace sync_private;
+
+TSyncClient_resultType zsync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                                   const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
+                                   const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
+                                   const hpatch_TStreamOutput* out_diffInfoStream,const hpatch_TStreamInput* diffInfoContinue,int threadNum){
+    return _zsync_patch(listener,syncDataListener,0,oldStream,newSyncInfo,out_newStream,newDataContinue,
+                        out_diffInfoStream,kSyncDiff_info,diffInfoContinue,threadNum);
+}
+
+TSyncClient_resultType zsync_local_diff(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                                        const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
+                                        const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
+                                        const hpatch_TStreamInput* diffContinue,int threadNum){
+    return _zsync_patch(listener,syncDataListener,0,oldStream,newSyncInfo,0,0,
+                        out_diffStream,diffType,diffContinue,threadNum);
+}
+
+
+TSyncClient_resultType zsync_local_patch(ISyncInfoListener* listener,const hpatch_TStreamInput* in_diffStream,
+                                         const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
+                                         const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,int threadNum){
+    TSyncDiffData diffData;
+    if (!_TSyncDiffData_load(&diffData,in_diffStream)) return kSyncClient_loadDiffError;
+    return _zsync_patch(listener,0,&diffData,oldStream,newSyncInfo,out_newStream,newDataContinue,
+                      0,kSyncDiff_default,0,threadNum);
+}
+
+namespace sync_private{
+
+static TSyncClient_resultType
+    _zsync_patch_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                           TSyncDiffData* diffData,const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
+                           const char* outNewFile,hpatch_BOOL isOutNewContinue,
+                           const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
+                           const hpatch_TStreamInput* diffContinue,int threadNum){
+    TSyncClient_resultType result=kSyncClient_ok;
+    int _inClear=0;
+    TNewDataZsyncInfo           newSyncInfo;
+    hpatch_TFileStreamInput     oldData;
+    hpatch_TFileStreamOutput    out_newData;
+    const hpatch_TStreamInput*  newDataContinue=0;
+    hpatch_TStreamInput         _newDataContinue;
+    const hpatch_TStreamInput*  oldStream=0;
+    bool isOldPathInputEmpty=(oldFile==0)||(strlen(oldFile)==0);
+    
+    TNewDataZsyncInfo_init(&newSyncInfo);
+    hpatch_TFileStreamInput_init(&oldData);
+    hpatch_TFileStreamOutput_init(&out_newData);
+    result=TNewDataZsyncInfo_open_by_file(&newSyncInfo,newSyncInfoFile,isIgnoreCompressInfo,listener);
+    check(result==kSyncClient_ok,result);
+    
+    if (!isOldPathInputEmpty)
+        check(hpatch_TFileStreamInput_open(&oldData,oldFile),kSyncClient_oldFileOpenError);
+    oldStream=&oldData.base;
+    if (outNewFile){
+        check(_open_continue_out(isOutNewContinue,outNewFile,&out_newData,&_newDataContinue,newSyncInfo.newDataSize),
+              isOutNewContinue?kSyncClient_newFileReopenWriteError:kSyncClient_newFileCreateError);
+        if (isOutNewContinue) newDataContinue=&_newDataContinue;
+    }
+    
+    result=_zsync_patch(listener,syncDataListener,diffData,oldStream,&newSyncInfo,
+                        outNewFile?&out_newData.base:0,newDataContinue,
+                        out_diffStream,diffType,diffContinue,threadNum);
+clear:
+    _inClear=1;
+    check(hpatch_TFileStreamOutput_close(&out_newData),kSyncClient_newFileCloseError);
+    check(hpatch_TFileStreamInput_close(&oldData),kSyncClient_oldFileCloseError);
+    TNewDataZsyncInfo_close(&newSyncInfo);
+    return result;
+}
+
+}//end namespace sync_private
+
+TSyncClient_resultType zsync_patch_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                                             const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
+                                             const char* outNewFile,hpatch_BOOL isOutNewContinue,
+                                             const char* cacheDiffInfoFile,int threadNum){
+    TSyncClient_resultType result=kSyncClient_ok;
+    int _inClear=0;
+    hpatch_TFileStreamOutput out_diffInfo;
+    hpatch_TFileStreamOutput_init(&out_diffInfo);
+    const hpatch_TStreamInput* diffContinue=0;
+    hpatch_TStreamInput _diffContinue;
+    if (cacheDiffInfoFile){
+        hpatch_BOOL isOutDiffContinue=hpatch_TRUE;
+        check(_open_continue_out(isOutDiffContinue,cacheDiffInfoFile,&out_diffInfo,&_diffContinue),
+            isOutDiffContinue?kSyncClient_diffFileReopenWriteError:kSyncClient_diffFileCreateError);
+        if (isOutDiffContinue) diffContinue=&_diffContinue;
+    }
+
+    result=_zsync_patch_file2file(listener,syncDataListener,0,oldFile,newSyncInfoFile,isIgnoreCompressInfo,
+                                  outNewFile,isOutNewContinue,
+                                  cacheDiffInfoFile?&out_diffInfo.base:0,kSyncDiff_info,diffContinue,threadNum);
+clear:
+    _inClear=1;
+    check(hpatch_TFileStreamOutput_close(&out_diffInfo),kSyncClient_diffFileCloseError);
+    return result;
+}
+
+TSyncClient_resultType zsync_local_diff_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                                                  const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
+                                                  const char* outDiffFile,TSyncDiffType diffType,
+                                                  hpatch_BOOL isOutDiffContinue,int threadNum){
+    TSyncClient_resultType result=kSyncClient_ok;
+    int _inClear=0;
+    hpatch_TFileStreamOutput out_diff;
+    hpatch_TFileStreamOutput_init(&out_diff);
+    const hpatch_TStreamInput* diffContinue=0;
+    hpatch_TStreamInput _diffContinue;
+    
+    check(_open_continue_out(isOutDiffContinue,outDiffFile,&out_diff,&_diffContinue),
+          isOutDiffContinue?kSyncClient_diffFileReopenWriteError:kSyncClient_diffFileCreateError);
+    if (isOutDiffContinue) diffContinue=&_diffContinue;
+    
+    result=_zsync_patch_file2file(listener,syncDataListener,0,oldFile,newSyncInfoFile,isIgnoreCompressInfo,0,hpatch_FALSE,
+                                  &out_diff.base,diffType,diffContinue,threadNum);
+
+clear:
+    _inClear=1;
+    check(hpatch_TFileStreamOutput_close(&out_diff),kSyncClient_diffFileCloseError);
+    return result;
+}
+
+TSyncClient_resultType zsync_local_patch_file2file(ISyncInfoListener* listener,const char* inDiffFile,
+                                                   const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
+                                                   const char* outNewFile,hpatch_BOOL isOutNewContinue,int threadNum){
+    TSyncClient_resultType result=kSyncClient_ok;
+    int _inClear=0;
+    TSyncDiffData diffData;
+    hpatch_TFileStreamInput in_diffData;
+    hpatch_TFileStreamInput_init(&in_diffData);
+    check(hpatch_TFileStreamInput_open(&in_diffData,inDiffFile),
+          kSyncClient_diffFileOpenError);
+    check(_TSyncDiffData_load(&diffData,&in_diffData.base),kSyncClient_loadDiffError);
+    result=_zsync_patch_file2file(listener,0,&diffData,oldFile,newSyncInfoFile,isIgnoreCompressInfo,outNewFile,isOutNewContinue,
+                                 0,kSyncDiff_default,0,threadNum);
+clear:
+    _inClear=1;
+    check(hpatch_TFileStreamInput_close(&in_diffData),kSyncClient_diffFileCloseError);
+    return result;
+}

package/harmony/pushy/src/main/cpp/HDiffPatch/libhsync/zsync_client_wrapper/zsync_client_wrapper.h

@@ -0,0 +1,71 @@
+// zsync_client_wrapper.h
+// zsync_client for hsynz
+/*
+ The MIT License (MIT)
+ Copyright (c) 2025 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 zsync_client_wrapper_h
+#define zsync_client_wrapper_h
+#include "zsync_info_client.h"
+
+//zsync_patch(oldStream+syncDataListener) to out_newStream
+TSyncClient_resultType zsync_patch(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                                   const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
+                                   const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,
+                                   const hpatch_TStreamOutput* out_diffInfoStream,const hpatch_TStreamInput* diffInfoContinue,int threadNum);
+
+//zsync patch(oldFile+syncDataListener) to outNewFile
+TSyncClient_resultType zsync_patch_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                                             const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
+                                             const char* outNewFile,hpatch_BOOL isOutNewContinue,
+                                             const char* cacheDiffInfoFile,int threadNum);
+
+//zsync_patch can split to two steps: zsync_local_diff + zsync_local_patch
+
+
+//download diff data from syncDataListener to out_diffStream
+//  if (diffContinue) then continue download
+TSyncClient_resultType zsync_local_diff(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                                        const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
+                                        const hpatch_TStreamOutput* out_diffStream,TSyncDiffType diffType,
+                                        const hpatch_TStreamInput* diffContinue,int threadNum);
+
+//patch(oldStream+in_diffStream) to out_newStream
+TSyncClient_resultType zsync_local_patch(ISyncInfoListener* listener,const hpatch_TStreamInput* in_diffStream,
+                                         const hpatch_TStreamInput* oldStream,const TNewDataZsyncInfo* newSyncInfo,
+                                         const hpatch_TStreamOutput* out_newStream,const hpatch_TStreamInput* newDataContinue,int threadNum);
+
+
+//download diff data from syncDataListener to outDiffFile
+//  if (isOutDiffContinue) then continue download
+TSyncClient_resultType zsync_local_diff_file2file(ISyncInfoListener* listener,IReadSyncDataListener* syncDataListener,
+                                                  const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
+                                                  const char* outDiffFile,TSyncDiffType diffType,
+                                                  hpatch_BOOL isOutDiffContinue,int threadNum);
+
+//patch(oldFile+inDiffFile) to outNewFile
+TSyncClient_resultType zsync_local_patch_file2file(ISyncInfoListener* listener,const char* inDiffFile,
+                                                   const char* oldFile,const char* newSyncInfoFile,hpatch_BOOL isIgnoreCompressInfo,
+                                                   const char* outNewFile,hpatch_BOOL isOutNewContinue,int threadNum);
+#endif