淺析android應用增量升級(轉)

時間  2019-11-12
標籤 淺析 android 應用 增量 升級 欄目 Android 简体版
原文   原文鏈接

   By 何明桂（http://blog.csdn.net/hmg25） 轉載請註明出處html

       好久沒有更新博客了，真是墮落啊，幾回想提起筆，卻老是被各類雜事耽擱，之後會多寫文章記錄點滴。java

背景

        隨着android應用體積的不斷增大，以及應用版本發佈的不斷更迭，用戶的升級成了一個問題，google也意識到不斷更新應用對用戶流量的損耗，在Google I/O 上說起的 Smart App update，即應用增量升級，或者叫作差分升級的作法，並在新版本的Google Play中獲得支持，某天在和羣友聊天是扯到這方面的話題，好奇就稍微研究了一下。

增量升級的原理

        今天咱們就來實現相似的應用的增量升級。其實增量升級的原理很簡單，即首先將應用的舊版本Apk與新版本Apk作差分，獲得更新的部分的補丁，例如舊版本的APK有5M，新版的有8M，更新的部分則可能只有3M左右(這裏須要說明的是，獲得的差分包大小並非簡單的相減，由於其實須要包含一些上下文相關的東西)，使用差分升級的好處顯而易見，那麼你不須要下載完整的8M文件，只須要下載更新部分就能夠，而更新部分可能只有三、4M，能夠很大程度上減小流量的損失。
 
         在用戶下載了差分包以後，須要在手機端將他們組合起來。能夠參考的作法是先將手機端的舊版本軟件(多半在/data/下)，複製到SD卡或者cache中，將它們和以前的差分patch進行組合，獲得一個新版本的apk應用，若是不出意外的話，這個生成的apk和你以前作差分的apk是一致的。

增量升級的操做

       在瞭解基本的原理以後，咱們來逐步解決其中的各個難點。首先是差分包patch的生成。若是作過android手機OTA升級的同窗應該注意到，在update.zip中的patch文件夾中有須要與系統文件同名可是以xxx.p 爲後綴的文件，他們就是生成的差分patch文件。咱們能夠借鑑OTA系統升級的差分生成工具來生成咱們單個應用apk的差分patch文件。
OTA系統差分包的製做，使用命令：
[html] view plain copy print ?
  1. ./build/tools/releasetools/ota_from_target_files -n -i <舊包> <新包> <差分包名>  
  ./build/tools/releasetools/ota_from_target_files -n -i <舊包> <新包> <差分包名>
       在查閱ota_from_target_files 的代碼可知，是在函數WriteIncrementalOTAPackage裏生成差分包的，在這個函數裏邊建立了common.Difference這個類，咱們繼續跟進，在common.py中的類   class Difference(object):裏能夠看到：    
[html] view plain copy print ?
  1. diff_program = DIFF_PROGRAM_BY_EXT.get(ext, "bsdiff")  
    diff_program = DIFF_PROGRAM_BY_EXT.get(ext, "bsdiff")
       至此咱們就看到了android中提供咱們用來製做差分增量升級包的工具，"bsdiff"，這是一個很牛X開源的二進制差分工具.相關的介紹 傳送門
相關的代碼 地址 或者在android的代碼目錄下 \external\bsdiff
 
       bsdiff是二進制差分工具,其對應的bspatch是相應的補丁合成工具
       須要注意的是增量升級的補丁包,是須要在服務器端,即PC端完成,大體流程如,製做補丁時調用bsdiff函數，根據兩個不一樣版本的二進制文件，生成補丁文件。  
[html] view plain copy print ?
  1. 命令：bsdiff oldfile newfile patchfile  
  2. 例如: bsdiff xx_v1.0.apk xx_v2.0.apk xx.patch  
命令：bsdiff oldfile newfile patchfile
例如: bsdiff xx_v1.0.apk xx_v2.0.apk xx.patch
 
       將生成的補丁包 xx.patch放置在升級服務器上，供用戶下載升級，對應多版本須要對不一樣的版本進行差分，對於版本跨度較大的，建議整包升級。
 
        用戶在下載了 xx.patch補丁包後，須要用到補丁所對應的apk，即原來系統安裝的舊版本apk和補丁合成的bspatch工具。系統舊版本的apk能夠經過copy系統data/app目錄下的apk文件獲取，而補丁合成的bspatch能夠經過將bspatch源碼稍做修改，封裝成一個so庫，供手機端調用。
[html] view plain copy print ?
  1. bspatch的命令格式爲：  
  2. bspatch oldfile newfile patchfile  
   bspatch的命令格式爲：
   bspatch oldfile newfile patchfile
      和差分時的參數同樣。合成新的apk即可以用於安裝。
    以上只是簡單的操做原理，增量升級還涉及不少其餘方面，例如，升級補丁校驗等問題，能夠參考android源碼中bootable\recovery\applypatch的相關操做，本文只是淺析，在此不表。

不足

     增量升級並不是天衣無縫的升級方式，至少存在如下兩點不足：
    1.增量升級是以兩個應用版本之間的差別來生成補丁的，你沒法保證用戶每次的及時升級到最新，因此你必須對你所發佈的每個版本都和最新的版本做差分，以便使全部版本的用戶均可以差分升級，這樣操做相對於原來的整包升級較爲繁瑣，不過能夠經過自動化的腳本批量生成。
    2.增量升級成功的前提是，用戶手機端必須有可以讓你拷貝出來且與你服務器用於差分的版本一致的apk，這樣就存在，例如，系統內置的apk沒法獲取到，沒法進行增量升級；對於某些與你差分版本一致，可是內容有過修改的(好比破解版apk)，這樣也是沒法進行增量升級的，爲了防止合成補丁錯誤，最好在補丁合成前對舊版本的apk進行sha1sum校驗，保證基礎包的一致性。

小實驗

       多說無益，實踐纔是王道。下面就來簡單實踐一下，檢測以前理論的正確性。 下載實驗包 ( http://download.csdn.net/detail/hmg25/4676737)，解壓後文件以下
[html] view plain copy print ?
  1. ├── bsdiff-4.3        //bsdiff的源碼路徑，官網獲取  
  2. │   ├── bsdiff.1  
  3. │   ├── bsdiff.c  
  4. │   ├── bspatch.1  
  5. │   ├── bspatch.c  
  6. │   └── Makefile  
  7. ├── bsdiff-4.3.tar.gz      
  8. ├── bsdiff4.3-win32     //windows PC端的測試工具  
  9. │   ├── Binary diff.txt  
  10. │   ├── bsdiff.exe  
  11. │   ├── bspatch.exe  
  12. │   └── LICENSE  
  13. ├── bspatch             //手機端的測試工具  
  14. ├── iReader1.6.2.0(v35).apk      // 舊版本的apk  
  15. └── iReader1.8.0.1(v40).apk    //新版本的apk  
├── bsdiff-4.3        //bsdiff的源碼路徑，官網獲取
│   ├── bsdiff.1
│   ├── bsdiff.c
│   ├── bspatch.1
│   ├── bspatch.c
│   └── Makefile
├── bsdiff-4.3.tar.gz    
├── bsdiff4.3-win32     //windows PC端的測試工具
│   ├── Binary diff.txt
│   ├── bsdiff.exe
│   ├── bspatch.exe
│   └── LICENSE
├── bspatch             //手機端的測試工具
├── iReader1.6.2.0(v35).apk      // 舊版本的apk
└── iReader1.8.0.1(v40).apk    //新版本的apk

       以附帶的iReader來作測試，在shell進入test\bsdiff4.3-win32文件夾，並下運行命令：
[html] view plain copy print ?
  1. bsdiff.exe   ../iReader1.6.2.0(v35).apk   ../iReader1.8.0.1(v40).apk   ../ireader.patch  
   bsdiff.exe   ../iReader1.6.2.0(v35).apk   ../iReader1.8.0.1(v40).apk   ../ireader.patch
       原來的apk(2.94M),新版本的(3.24M),獲得的patch文件爲1.77M，用戶須要下載的就只是1.77M，流量節省了不少。
     下面先在電腦端將他們合併。
    
[html] view plain copy print ?
  1. bspatch.exe  ../iReader1.6.2.0(v35).apk   ../new.apk    ../ireader.patch  
  bspatch.exe  ../iReader1.6.2.0(v35).apk   ../new.apk    ../ireader.patch
     執行後獲得名爲new.apk 的合成版本應用，我在ubuntu下進行校驗能夠看出他們是同樣的。

   
    下面咱們在手機端合成看看，將根目錄下的bspatch(此爲手機端運行的)、iReader1.6.2.0(v35).apk 和ireader.patch ，經過adb push到你有權限操做的目錄，最好是在/sdcard/下，而後設置bspatch的執行權限，重複操做上述命令，能夠合成新版本的apk，稍後安裝查看驗證版本便可，不詳述。

擴展閱讀

      使用bsdiff 進行差分升級，還並非最優的方式，google在它的Chromium項目中，對這個差分算法進行了優化，優化後的版本叫作小胡瓜 Courgette，聽說性能優化了不少不是一個數量級了，官方的一個例子：
Full update        10,385,920
bsdiff update      704,512
Courgette update       78,848
       大牛們能夠去研究下。
      最近有些小忙，稍後有時間會對增量升級進行封裝下，將合成的代碼弄成一個lib庫，供java調用。有興趣的童鞋能夠本身操做一下~~~
              By 何明桂（http://blog.csdn.net/hmg25） 轉載請註明出處   原裝正版，盜版必究 ^_^

 
補充：
不少人不知道怎麼進行封裝爲lib，其實這個和通常的android的C庫是同樣的，不明白的看看jni相關的知識，原來的測試工程已經找不到了，下邊我給出個簡單的例子，拋磚引玉，給你們參考下。
 
 
[java] view plain copy print ?
  1. #include <stdio.h>  
  2. #include "com_hmg25_newstart_BSpatch.h"  
  3.   
  4. #include <bzlib.h>  
  5. #include <stdlib.h>  
  6. #include <stdio.h>  
  7. #include <string.h>  
  8. #include <err.h>  
  9. #include <unistd.h>  
  10. #include <fcntl.h>  
  11. #include <android/log.h>  
  12.   
  13.   
  14. static off_t offtin(u_char *buf)  
  15. {  
  16.     off_t y;  
  17.   
  18.     y=buf[7]&0x7F;  
  19.     y=y*256;y+=buf[6];  
  20.     y=y*256;y+=buf[5];  
  21.     y=y*256;y+=buf[4];  
  22.     y=y*256;y+=buf[3];  
  23.     y=y*256;y+=buf[2];  
  24.     y=y*256;y+=buf[1];  
  25.     y=y*256;y+=buf[0];  
  26.   
  27.     if(buf[7]&0x80) y=-y;  
  28.   
  29.     return y;  
  30. }  
  31.   
  32. int applypatch(int argc,char * argv[])  
  33. {  
  34.     FILE * f, * cpf, * dpf, * epf;  
  35.     BZFILE * cpfbz2, * dpfbz2, * epfbz2;  
  36.     int cbz2err, dbz2err, ebz2err;  
  37.     int fd;  
  38.     ssize_t oldsize,newsize;  
  39.     ssize_t bzctrllen,bzdatalen;  
  40.     u_char header[32],buf[8];  
  41.     u_char *old, *new;  
  42.     off_t oldpos,newpos;  
  43.     off_t ctrl[3];  
  44.     off_t lenread;  
  45.     off_t i;  
  46.   
  47.     if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile\n",argv[0]);  
  48.   
  49.     /* Open patch file */  
  50.     if ((f = fopen(argv[3], "r")) == NULL)  
  51.         err(1, "fopen(%s)", argv[3]);  
  52.   
  53.     /* 
  54.     File format: 
  55.         0   8   "BSDIFF40" 
  56.         8   8   X 
  57.         16  8   Y 
  58.         24  8   sizeof(newfile) 
  59.         32  X   bzip2(control block) 
  60.         32+X    Y   bzip2(diff block) 
  61.         32+X+Y  ??? bzip2(extra block) 
  62.     with control block a set of triples (x,y,z) meaning "add x bytes 
  63.     from oldfile to x bytes from the diff block; copy y bytes from the 
  64.     extra block; seek forwards in oldfile by z bytes". 
  65.     */  
  66.   
  67.     /* Read header */  
  68.     if (fread(header, 1, 32, f) < 32) {  
  69.         if (feof(f))  
  70.             errx(1, "Corrupt patch\n");  
  71.         err(1, "fread(%s)", argv[3]);  
  72.     }  
  73.   
  74.     /* Check for appropriate magic */  
  75.     if (memcmp(header, "BSDIFF40", 8) != 0)  
  76.         errx(1, "Corrupt patch\n");  
  77.   
  78.     /* Read lengths from header */  
  79.     bzctrllen=offtin(header+8);  
  80.     bzdatalen=offtin(header+16);  
  81.     newsize=offtin(header+24);  
  82.     if((bzctrllen<0) || (bzdatalen<0) || (newsize<0))  
  83.         errx(1,"Corrupt patch\n");  
  84.   
  85.     /* Close patch file and re-open it via libbzip2 at the right places */  
  86.     if (fclose(f))  
  87.         err(1, "fclose(%s)", argv[3]);  
  88.     if ((cpf = fopen(argv[3], "r")) == NULL)  
  89.         err(1, "fopen(%s)", argv[3]);  
  90.     if (fseeko(cpf, 32, SEEK_SET))  
  91.         err(1, "fseeko(%s, %lld)", argv[3],  
  92.             (long long)32);  
  93.     if ((cpfbz2 = BZ2_bzReadOpen(&cbz2err, cpf, 0, 0, NULL, 0)) == NULL)  
  94.         errx(1, "BZ2_bzReadOpen, bz2err = %d", cbz2err);  
  95.     if ((dpf = fopen(argv[3], "r")) == NULL)  
  96.         err(1, "fopen(%s)", argv[3]);  
  97.     if (fseeko(dpf, 32 + bzctrllen, SEEK_SET))  
  98.         err(1, "fseeko(%s, %lld)", argv[3],  
  99.             (long long)(32 + bzctrllen));  
  100.     if ((dpfbz2 = BZ2_bzReadOpen(&dbz2err, dpf, 0, 0, NULL, 0)) == NULL)  
  101.         errx(1, "BZ2_bzReadOpen, bz2err = %d", dbz2err);  
  102.     if ((epf = fopen(argv[3], "r")) == NULL)  
  103.         err(1, "fopen(%s)", argv[3]);  
  104.     if (fseeko(epf, 32 + bzctrllen + bzdatalen, SEEK_SET))  
  105.         err(1, "fseeko(%s, %lld)", argv[3],  
  106.             (long long)(32 + bzctrllen + bzdatalen));  
  107.     if ((epfbz2 = BZ2_bzReadOpen(&ebz2err, epf, 0, 0, NULL, 0)) == NULL)  
  108.         errx(1, "BZ2_bzReadOpen, bz2err = %d", ebz2err);  
  109.   
  110.     if(((fd=open(argv[1],O_RDONLY,0))<0) ||  
  111.         ((oldsize=lseek(fd,0,SEEK_END))==-1) ||  
  112.         ((old=malloc(oldsize+1))==NULL) ||  
  113.         (lseek(fd,0,SEEK_SET)!=0) ||  
  114.         (read(fd,old,oldsize)!=oldsize) ||  
  115.         (close(fd)==-1)) err(1,"%s",argv[1]);  
  116.     if((new=malloc(newsize+1))==NULL) err(1,NULL);  
  117.   
  118.     oldpos=0;newpos=0;  
  119.     while(newpos<newsize) {  
  120.         /* Read control data */  
  121.         for(i=0;i<=2;i++) {  
  122.             lenread = BZ2_bzRead(&cbz2err, cpfbz2, buf, 8);  
  123.             if ((lenread < 8) || ((cbz2err != BZ_OK) &&  
  124.                 (cbz2err != BZ_STREAM_END)))  
  125.                 errx(1, "Corrupt patch\n");  
  126.             ctrl[i]=offtin(buf);  
  127.         };  
  128.   
  129.         /* Sanity-check */  
  130.         if(newpos+ctrl[0]>newsize)  
  131.             errx(1,"Corrupt patch\n");  
  132.   
  133.         /* Read diff string */  
  134.         lenread = BZ2_bzRead(&dbz2err, dpfbz2, new + newpos, ctrl[0]);  
  135.         if ((lenread < ctrl[0]) ||  
  136.             ((dbz2err != BZ_OK) && (dbz2err != BZ_STREAM_END)))  
  137.             errx(1, "Corrupt patch\n");  
  138.   
  139.         /* Add old data to diff string */  
  140.         for(i=0;i<ctrl[0];i++)  
  141.             if((oldpos+i>=0) && (oldpos+i<oldsize))  
  142.                 new[newpos+i]+=old[oldpos+i];  
  143.   
  144.         /* Adjust pointers */  
  145.         newpos+=ctrl[0];  
  146.         oldpos+=ctrl[0];  
  147.   
  148.         /* Sanity-check */  
  149.         if(newpos+ctrl[1]>newsize)  
  150.             errx(1,"Corrupt patch\n");  
  151.   
  152.         /* Read extra string */  
  153.         lenread = BZ2_bzRead(&ebz2err, epfbz2, new + newpos, ctrl[1]);  
  154.         if ((lenread < ctrl[1]) ||  
  155.             ((ebz2err != BZ_OK) && (ebz2err != BZ_STREAM_END)))  
  156.             errx(1, "Corrupt patch\n");  
  157.   
  158.         /* Adjust pointers */  
  159.         newpos+=ctrl[1];  
  160.         oldpos+=ctrl[2];  
  161.     };  
  162.   
  163.     /* Clean up the bzip2 reads */  
  164.     BZ2_bzReadClose(&cbz2err, cpfbz2);  
  165.     BZ2_bzReadClose(&dbz2err, dpfbz2);  
  166.     BZ2_bzReadClose(&ebz2err, epfbz2);  
  167.     if (fclose(cpf) || fclose(dpf) || fclose(epf))  
  168.         err(1, "fclose(%s)", argv[3]);  
  169.   
  170.     /* Write the new file */  
  171.     if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0666))<0) ||  
  172.         (write(fd,new,newsize)!=newsize) || (close(fd)==-1))  
  173.         err(1,"%s",argv[2]);  
  174.   
  175.     free(new);  
  176.     free(old);  
  177.   
  178.     return 0;  
  179. }  
  180.   
  181. JNIEXPORT jint JNICALL Java_com_hmg25_newstart_BSpatch_applyPatch(JNIEnv *env,  
  182.         jobject obj, jstring old, jstring new , jstring patch){  
  183.   int argc=4;  
  184.   char * argv[argc];  
  185.   argv[0]="bspatch";  
  186.   argv[1]=(*env)->GetStringUTFChars(env,old, 0);  
  187.   argv[2]=(*env)->GetStringUTFChars(env,new, 0);  
  188.   argv[3]=(*env)->GetStringUTFChars(env,patch, 0);  
  189.     
  190.   int ret=applypatch(argc, argv);  
  191.     
  192.    (*env)->ReleaseStringUTFChars(env,old,argv[1]);  
  193.    (*env)->ReleaseStringUTFChars(env,new,argv[2]);  
  194.    (*env)->ReleaseStringUTFChars(env,patch,argv[3]);  
  195.    return ret;  
  196. }  
#include <stdio.h>
#include "com_hmg25_newstart_BSpatch.h"

#include <bzlib.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <err.h>
#include <unistd.h>
#include <fcntl.h>
#include <android/log.h>


static off_t offtin(u_char *buf)
{
    off_t y;

    y=buf[7]&0x7F;
    y=y*256;y+=buf[6];
    y=y*256;y+=buf[5];
    y=y*256;y+=buf[4];
    y=y*256;y+=buf[3];
    y=y*256;y+=buf[2];
    y=y*256;y+=buf[1];
    y=y*256;y+=buf[0];

    if(buf[7]&0x80) y=-y;

    return y;
}

int applypatch(int argc,char * argv[])
{
    FILE * f, * cpf, * dpf, * epf;
    BZFILE * cpfbz2, * dpfbz2, * epfbz2;
    int cbz2err, dbz2err, ebz2err;
    int fd;
    ssize_t oldsize,newsize;
    ssize_t bzctrllen,bzdatalen;
    u_char header[32],buf[8];
    u_char *old, *new;
    off_t oldpos,newpos;
    off_t ctrl[3];
    off_t lenread;
    off_t i;

    if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile\n",argv[0]);

    /* Open patch file */
    if ((f = fopen(argv[3], "r")) == NULL)
        err(1, "fopen(%s)", argv[3]);

    /*
    File format:
        0   8   "BSDIFF40"
        8   8   X
        16  8   Y
        24  8   sizeof(newfile)
        32  X   bzip2(control block)
        32+X    Y   bzip2(diff block)
        32+X+Y  ??? bzip2(extra block)
    with control block a set of triples (x,y,z) meaning "add x bytes
    from oldfile to x bytes from the diff block; copy y bytes from the
    extra block; seek forwards in oldfile by z bytes".
    */

    /* Read header */
    if (fread(header, 1, 32, f) < 32) {
        if (feof(f))
            errx(1, "Corrupt patch\n");
        err(1, "fread(%s)", argv[3]);
    }

    /* Check for appropriate magic */
    if (memcmp(header, "BSDIFF40", 8) != 0)
        errx(1, "Corrupt patch\n");

    /* Read lengths from header */
    bzctrllen=offtin(header+8);
    bzdatalen=offtin(header+16);
    newsize=offtin(header+24);
    if((bzctrllen<0) || (bzdatalen<0) || (newsize<0))
        errx(1,"Corrupt patch\n");

    /* Close patch file and re-open it via libbzip2 at the right places */
    if (fclose(f))
        err(1, "fclose(%s)", argv[3]);
    if ((cpf = fopen(argv[3], "r")) == NULL)
        err(1, "fopen(%s)", argv[3]);
    if (fseeko(cpf, 32, SEEK_SET))
        err(1, "fseeko(%s, %lld)", argv[3],
            (long long)32);
    if ((cpfbz2 = BZ2_bzReadOpen(&cbz2err, cpf, 0, 0, NULL, 0)) == NULL)
        errx(1, "BZ2_bzReadOpen, bz2err = %d", cbz2err);
    if ((dpf = fopen(argv[3], "r")) == NULL)
        err(1, "fopen(%s)", argv[3]);
    if (fseeko(dpf, 32 + bzctrllen, SEEK_SET))
        err(1, "fseeko(%s, %lld)", argv[3],
            (long long)(32 + bzctrllen));
    if ((dpfbz2 = BZ2_bzReadOpen(&dbz2err, dpf, 0, 0, NULL, 0)) == NULL)
        errx(1, "BZ2_bzReadOpen, bz2err = %d", dbz2err);
    if ((epf = fopen(argv[3], "r")) == NULL)
        err(1, "fopen(%s)", argv[3]);
    if (fseeko(epf, 32 + bzctrllen + bzdatalen, SEEK_SET))
        err(1, "fseeko(%s, %lld)", argv[3],
            (long long)(32 + bzctrllen + bzdatalen));
    if ((epfbz2 = BZ2_bzReadOpen(&ebz2err, epf, 0, 0, NULL, 0)) == NULL)
        errx(1, "BZ2_bzReadOpen, bz2err = %d", ebz2err);

    if(((fd=open(argv[1],O_RDONLY,0))<0) ||
        ((oldsize=lseek(fd,0,SEEK_END))==-1) ||
        ((old=malloc(oldsize+1))==NULL) ||
        (lseek(fd,0,SEEK_SET)!=0) ||
        (read(fd,old,oldsize)!=oldsize) ||
        (close(fd)==-1)) err(1,"%s",argv[1]);
    if((new=malloc(newsize+1))==NULL) err(1,NULL);

    oldpos=0;newpos=0;
    while(newpos<newsize) {
        /* Read control data */
        for(i=0;i<=2;i++) {
            lenread = BZ2_bzRead(&cbz2err, cpfbz2, buf, 8);
            if ((lenread < 8) || ((cbz2err != BZ_OK) &&
                (cbz2err != BZ_STREAM_END)))
                errx(1, "Corrupt patch\n");
            ctrl[i]=offtin(buf);
        };

        /* Sanity-check */
        if(newpos+ctrl[0]>newsize)
            errx(1,"Corrupt patch\n");

        /* Read diff string */
        lenread = BZ2_bzRead(&dbz2err, dpfbz2, new + newpos, ctrl[0]);
        if ((lenread < ctrl[0]) ||
            ((dbz2err != BZ_OK) && (dbz2err != BZ_STREAM_END)))
            errx(1, "Corrupt patch\n");

        /* Add old data to diff string */
        for(i=0;i<ctrl[0];i++)
            if((oldpos+i>=0) && (oldpos+i<oldsize))
                new[newpos+i]+=old[oldpos+i];

        /* Adjust pointers */
        newpos+=ctrl[0];
        oldpos+=ctrl[0];

        /* Sanity-check */
        if(newpos+ctrl[1]>newsize)
            errx(1,"Corrupt patch\n");

        /* Read extra string */
        lenread = BZ2_bzRead(&ebz2err, epfbz2, new + newpos, ctrl[1]);
        if ((lenread < ctrl[1]) ||
            ((ebz2err != BZ_OK) && (ebz2err != BZ_STREAM_END)))
            errx(1, "Corrupt patch\n");

        /* Adjust pointers */
        newpos+=ctrl[1];
        oldpos+=ctrl[2];
    };

    /* Clean up the bzip2 reads */
    BZ2_bzReadClose(&cbz2err, cpfbz2);
    BZ2_bzReadClose(&dbz2err, dpfbz2);
    BZ2_bzReadClose(&ebz2err, epfbz2);
    if (fclose(cpf) || fclose(dpf) || fclose(epf))
        err(1, "fclose(%s)", argv[3]);

    /* Write the new file */
    if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0666))<0) ||
        (write(fd,new,newsize)!=newsize) || (close(fd)==-1))
        err(1,"%s",argv[2]);

    free(new);
    free(old);

    return 0;
}

JNIEXPORT jint JNICALL Java_com_hmg25_newstart_BSpatch_applyPatch(JNIEnv *env,
        jobject obj, jstring old, jstring new , jstring patch){
  int argc=4;
  char * argv[argc];
  argv[0]="bspatch";
  argv[1]=(*env)->GetStringUTFChars(env,old, 0);
  argv[2]=(*env)->GetStringUTFChars(env,new, 0);
  argv[3]=(*env)->GetStringUTFChars(env,patch, 0);
  
  int ret=applypatch(argc, argv);
  
   (*env)->ReleaseStringUTFChars(env,old,argv[1]);
   (*env)->ReleaseStringUTFChars(env,new,argv[2]);
   (*env)->ReleaseStringUTFChars(env,patch,argv[3]);
   return ret;
}
Android.mk：
[java] view plain copy print ?
  1. LOCAL_PATH:= $(call my-dir)  
  2. include $(CLEAR_VARS)  
  3.   
  4. # This is the target being built.  
  5. LOCAL_MODULE:= libbspatch  
  6.   
  7.   
  8. # All of the source files that we will compile.  
  9. LOCAL_SRC_FILES:= \  
  10.   com_hmg25_newstart_BSpatch.c  
  11.   
  12.   
  13. # No static libraries.  
  14. LOCAL_STATIC_LIBRARIES := \  
  15.      libbz  
  16.   
  17.   
  18. # Also need the JNI headers.  
  19. LOCAL_C_INCLUDES += \  
  20.     $(JNI_H_INCLUDE) external/bzip2  
  21.   
  22. # No special compiler flags.  
  23. LOCAL_CFLAGS +=  
  24.   
  25. include $(BUILD_SHARED_LIBRARY)  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程