APK增量升级

#标签：读博客

本文转载自：

http://blog.csdn.net/hmg25/article/details/8100896

主要内容摘要： 了解 bsdiff/bzlib2工具

背景

        随着android应用体积的不断增大，以及应用版本发布的不断更迭，用户的升级成了一个问题，google也意识到不断更新应用对用户流量的损耗，在Google I/O 上提及的 Smart App update，即应用增量升级，或者叫做差分升级的做法，并在新版本的Google Play中得到支持，某天在和群友聊天是扯到这方面的话题，好奇就稍微研究了一下。

增量升级的原理

        今天我们就来实现类似的应用的增量升级。其实增量升级的原理很简单，即首先将应用的旧版本Apk与新版本Apk做差分，得到更新的部分的补丁，例如旧版本的APK有5M，新版的有8M，更新的部分则可能只有3M左右(这里需要说明的是，得到的差分包大小并不是简单的相减，因为其实需要包含一些上下文相关的东西)，使用差分升级的好处显而易见，那么你不需要下载完整的8M文件，只需要下载更新部分就可以，而更新部分可能只有3、4M，可以很大程度上减少流量的损失。

         在用户下载了差分包之后，需要在手机端将他们组合起来。可以参考的做法是先将手机端的旧版本软件(多半在/data/下)，复制到SD卡或者cache中，将它们和之前的差分patch进行组合，得到一个新版本的apk应用，如果不出意外的话，这个生成的apk和你之前做差分的apk是一致的。

增量升级的操作

       在了解基本的原理之后，我们来逐步解决其中的各个难点。首先是差分包patch的生成。如果做过android手机OTA升级的同学应该注意到，在update.zip中的patch文件夹中有需要与系统文件同名但是以xxx.p 为后缀的文件，他们就是生成的差分patch文件。我们可以借鉴OTA系统升级的差分生成工具来生成我们单个应用apk的差分patch文件。

OTA系统差分包的制作，使用命令：

./build/tools/releasetools/ota_from_target_files -n -i <旧包> <新包> <差分包名>

在查阅ota_from_target_files 的代码可知，是在函数WriteIncrementalOTAPackage里生成差分包的，在这个函数里边创建了common.Difference这个类，我们继续跟进，在common.py中的类   class Difference(object):里可以看到：  

diff_program = DIFF_PROGRAM_BY_EXT.get(ext, "bsdiff")

至此我们就看到了android中提供我们用来制作差分增量升级包的工具，"bsdiff"，这是一个很牛X开源的二进制差分工具.相关的介绍传送门

相关的代码地址 或者在android的代码目录下 \external\bsdiff

       bsdiff是二进制差分工具,其对应的bspatch是相应的补丁合成工具

       需要注意的是增量升级的补丁包,是需要在服务器端,即PC端完成,大致流程如,制作补丁时调用bsdiff函数，根据两个不同版本的二进制文件，生成补丁文件。 

命令：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库，供手机端调用。

bspatch的命令格式为：  
bspatch oldfile newfile patchfile

和差分时的参数一样。合成新的apk便可以用于安装。

    以上只是简单的操作原理，增量升级还涉及很多其他方面，例如，升级补丁校验等问题，可以参考android源码中bootable\recovery\applypatch的相关操作，本文只是浅析，在此不表。

不足

     增量升级并非完美无缺的升级方式，至少存在以下两点不足：

    1.增量升级是以两个应用版本之间的差异来生成补丁的，你无法保证用户每次的及时升级到最新，所以你必须对你所发布的每一个版本都和最新的版本作差分，以便使所有版本的用户都可以差分升级，这样操作相对于原来的整包升级较为繁琐，不过可以通过自动化的脚本批量生成。

    2.增量升级成功的前提是，用户手机端必须有能够让你拷贝出来且与你服务器用于差分的版本一致的apk，这样就存在，例如，系统内置的apk无法获取到，无法进行增量升级；对于某些与你差分版本一致，但是内容有过修改的(比如破解版apk)，这样也是无法进行增量升级的，为了防止合成补丁错误，最好在补丁合成前对旧版本的apk进行sha1sum校验，保证基础包的一致性。

扩展阅读

      使用bsdiff 进行差分升级，还并不是最优的方式，google在它的Chromium项目中，对这个差分算法进行了优化，优化后的版本叫做小胡瓜Courgette，据说性能优化了很多不是一个数量级了，官方的一个例子：
Full update       10,385,920

bsdiff update     704,512

Courgette update      78,848
       大牛们可以去研究下。

其他补充：（增量升级的一个Demo）

http://blog.csdn.net/tu_bingbing/article/details/8538592

第一、生成旧版和新版的差分比patch文件，可以借助bsdiff开源库windows版本

bsdiff.exe   ../iReader1.6.2.0(v35).apk   ../iReader1.8.0.1(v40).apk   ../ireader.patch

第二、有了patch文件，我们就可以在Android平台上利用JNI调用bzlib2就可以实现增量升级了。

1、首先要有ndk编译环境，具体怎么搭建详见：http://blog.csdn.net/tibib/article/details/8504680

2、编写本地方法

//oldapk_filepath：旧版本存储路径   newapk_savepath：生成的新版本要存放的路径  patchpath:差分比文件存放路径  
public native int applyPatchToOldApk(String oldapk_filepath, String newapk_savepath , String patchpath);

3、编写Android.mk配置文件，并把需要的bzlib2源代码文件()拷贝到目录下

LOCAL_PATH:= $(call my-dir)  
include $(CLEAR_VARS)  
  
# This is the target being built.  
LOCAL_MODULE:= libBsdiff  
  
  
# All of the source files that we will compile.  
# 具体到底需要哪些c代码，没有仔细研究过  
LOCAL_SRC_FILES:= tu_bingbing_bsdiff_BsdiffBusiness.c \  
                  bzlib.c \  
                  blocksort.c \  
                  compress.c \  
                  crctable.c \  
                  decompress.c \  
                  huffman.c \  
                  randtable.c \  
                  bzip2.c \  
                          
# No static libraries.  
LOCAL_STATIC_LIBRARIES := \  
     libbz  
  
  
# Also need the JNI headers.  
LOCAL_C_INCLUDES += \  
    $(JNI_H_INCLUDE) external/bzip2  
  
# No special compiler flags.  
LOCAL_CFLAGS +=  
  
include $(BUILD_SHARED_LIBRARY)

4、实现本地方法

#include <stdio.h>  
#include "tu_bingbing_bsdiff_BsdiffBusiness.h"  
  
#include "bzlib_private.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;  
}  
  
// old 升级之前apk包路径  
// new 升级之后apk包路径  
// patch文件，可以用bsdiff工具生成  
// 具体原理可以参看http://blog.csdn.net/hmg25/article/details/8100896  
JNIEXPORT jint JNICALL Java_tu_bingbing_bsdiff_BsdiffBusiness_applyPatchToOldApk(JNIEnv *env,  
        jobject obj, jstring old, jstring new , jstring patch){  
  int argc=4;  
  char * argv[argc];  
  argv[0]="bspatch";  
  argv[1]=(char*)((*env)->GetStringUTFChars(env,old, 0));  
  argv[2]=(char*)((*env)->GetStringUTFChars(env,new, 0));  
  argv[3]=(char*)((*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;  
}

最后 ndk编译，在Android中调用native方法，你会发现在你传入路径下生成了新版本的apk。

DEMO：http://download.csdn.net/detail/tibib/5581905

另外一个改进了异常处理和代码打包：

http://blog.csdn.net/sgwhp/article/details/9009427

本文在以上两篇博客的基础上再增加了异常处理，并将生成的so库和Native代码一起打包。

（JNI调用）

1、准备工具

（1）bspatch源码（点击下载）、某个应用的两个不同版本。或者直接下载上面提到的第一个博主提供的工具和素材。点击打开链接 这里面包括了我们需要用到的bsdiff源码和apk等。

（2）除此之外，还需要下载bzip2。点击打开链接

2、编译环境

Linux、Windows均可，但必须有NDK，Windows下的NDK版本需在R7以上，否则还需要安装cygwin。Windows下搭建NDK环境请参考：NDK配置

3、编码实现

（1）创建Native方法类

先看代码：

public class PatchClient{  
    //定义Native方法  
    static private native int applyPatchToOldApk(String oldapk_filepath, String newapk_savepath , String patchpath);  
      
    public static void loadLib(){  
        System.loadLibrary("PatchDroid");  
    }  
      
    /** 
     *  
     * @param oldApkPath 旧版apk文件的路径 
     * @param newApkPath 新版apk文件的路径 
     * @param patchPath 增量包的路径 
     * @throws IOException 
     */  
    public static void applyPatch(String oldApkPath, String newApkPath, String patchPath) throws IOException{  
        applyPatchToOldApk(oldApkPath, newApkPath, patchPath);  
    }  
      
    /** 
     * 根据context获取本app的旧版apk文件，与增量包合并生成新版apk 
     * @param context 
     * @param newApkPath 新版apk文件路径 
     * @param patchPath 增量包路径 
     * @throws IOException 
     */  
    public static void applyPatchToOwn(Context context, String newApkPath, String patchPath) throws IOException{  
        String old = context.getApplicationInfo().sourceDir;  
        applyPatchToOldApk(old, newApkPath, patchPath);  
    }  
}

重点在代码的第三行，其他几个方法在后面介绍。编译之后，会在项目的bin/classes下生成.class文件，打开cmd，切到该目录，输入

javah cn.sgwhp.PatchDroid（包名.类名）

此时会生成头文件cn_sgwhp_patchdroid_PatchClient.h，在项目的根目录下创建jni文件夹，并把刚才生成的.h文件剪切过去。

（2）实现Native方法

解压下载的bzip2包以及bspatch源码到jni目录下，将bspatch.c命名为cn_sgwhp_patchdroid_PatchClient.c，实现其中的Java_cn_sgwhp_patchdroid_PatchClient_applyPatchToOldApk方法。这里只简单地调用源码的main方法来实现：

#include "cn_sgwhp_patchdroid_PatchClient.h"    
        
    #include "bzlib_private.h"   
  
    JNIEXPORT jint JNICALL Java_cn_sgwhp_patchdroid_PatchClient_applyPatchToOldApk(JNIEnv *env,    
            jobject obj, jstring old, jstring new , jstring patch){   
      int argc=4;    
      char * argv[argc];    
      argv[0]="bspatch";    
      argv[1]=(char*)((*env)->GetStringUTFChars(env,old, 0));    
      argv[2]=(char*)((*env)->GetStringUTFChars(env,new, 0));    
      argv[3]=(char*)((*env)->GetStringUTFChars(env,patch, 0));   
      int ret=applypatch(argc, argv, env);  //将源码中的main方法改成applypatch即可  
       (*env)->ReleaseStringUTFChars(env,old,argv[1]);    
       (*env)->ReleaseStringUTFChars(env,new,argv[2]);    
       (*env)->ReleaseStringUTFChars(env,patch,argv[3]);   
       return ret;    
    }

（3）异常处理

源码中只有c的err异常，java是没有办法在控制台输出这些异常信息的，我们将它改造一下，利用JNIEnv的ThrowNew方法来抛出IOException。在cn_sgwhp_patchdroid_PatchClient.c中添加throwIOException方法，并把env参数从Java_cn_sgwhp_patchdroid_PatchClient_applyPatchToOldApk传入applypatch：

void throwIOException(JNIEnv* env,const char* msg)  
   {  
//找到指定名称的类的class类型  
jclass cls=(*env)->FindClass(env,"java/io/IOException");  
  
(*env)->ThrowNew(env,cls,msg);  
  
(*env)->DeleteLocalRef(env,cls);  
   }  
  
   int applypatch(int argc,char * argv[],JNIEnv* env)    
   {  ...}

把applypatch方法中所有调用err方法的代码注释掉，改成：

throwIOException(env, "can not open the patch file");  
return 0

此时，Native方法类中的applyPatch和applyPatchToOwn要 申明抛出IOException，避免程序因为异常而退出。

（4）编译

在jni目录下创建Android.mk文件，并复制以下代码：

LOCAL_PATH:= $(call my-dir)  
include $(CLEAR_VARS)  
  
# This is the target being built.  
LOCAL_MODULE:= PatchDroid  
  
  
# All of the source files that we will compile.  
# 具体到底需要哪些c代码，没有仔细研究过  
LOCAL_SRC_FILES:= cn_sgwhp_patchdroid_PatchClient.c \  
                  bzlib.c \  
                  blocksort.c \  
                  compress.c \  
                  crctable.c \  
                  decompress.c \  
                  huffman.c \  
                  randtable.c \  
                  bzip2.c \  
  
  
ifeq ($(HOST_OS),windows)    
 #NDK环境下    
     LOCAL_LDLIBS := -llog    
 else   
 #完整源码环境下    
     LOCAL_SHARED_LIBRARIES := libutils    
 endif  
  
LOCAL_SHARED_LIBRARIES := \  
     libandroid_runtime  
                          
# No static libraries.  
LOCAL_STATIC_LIBRARIES := \  
     libbz  
  
# Also need the JNI headers.  
LOCAL_C_INCLUDES += \  
    $(JNI_H_INCLUDE) external/bzip2  
  
# No special compiler flags.  
LOCAL_CFLAGS +=  
  
include $(BUILD_SHARED_LIBRARY)

刷新项目NDK就会自动帮我们编译了。

4、打包

右击项目，选择properties，选择Android，勾选Is Library，保存之后Clean项目，在bin目录下会生成一个jar包。其他项目需要用到时，把jar包导入，并把libs目录下的armeabi目录复制到新项目的libs目录下即可。

5、后话

有关applyPatchToOwn(Context context, String newApkPath, String patchPath)方法：

程序安装后，apk文件会存在于/data/app目录下，名字是“包名-数字.apk”，我们可以通过ApplicationInfo的sourceDir来获得目前版本的apk绝对路径，这样只要将增量包下载到sd卡就可以合成新版的apk了。记得要添加外部存储设备的读写权限。