关于多渠道打包的最强攻略--总结版

心已赠人 2022-07-14 03:40 131阅读 0赞

作开发工程师发布产品时多渠道打包是个必要的过程,此文可以对产品打包及上线不太熟悉的人提供了解及建议:

# [原始多渠道打包][Link 1] #

原始多渠道打包的方式，指的是每次打包的时候在代码中设置channelId，打包完这个渠道的apk包后，需要重新设置channelId再进行打包，如此反复。该方式多出现在android早期的时候，多被一些刚入行的android工程师使用，或者是一些公司面对较少渠道的时候使用。

### 原理 ###

原始多渠道打包就是个体力活，在较少渠道的时候可以使用，但是面对上千的渠道的时候，使用这种方式你会后悔当一名android开发工程师。它的原理是在应用代码中设置渠道ID，使用的时候将渠道ID设置给数据分析接口，数据分析平台通过该渠道ID分析之。其实后面多渠道方式的本质原理都是这样的，但是具体扩展方式不同而已，将在后面的分析的时候介绍。

### 实现 ###

*  第一步：设置渠道id

方式一 在代码中直接设置channelId

String channelId="channel1";
      
       
        1
       
      
       
        1

方式二 在AndroidMainfest.xml中application中设置meta-data

<manifest ...><application ...><meta-data android:name="CHANNEL_NAME"android:value="channel1" />
            ...
        </application></manifest>
      
       
        1
        2
        3
        4
        5
        6
        7
        8
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8

在代码中获取channelId

ApplicationInfo appInfo = this.getPackageManager()
                                  .getApplicationInfo(getPackageName()
                                  ,PackageManager.GET_META_DATA);
    String channelId = appInfo.metaData.getString("CHANNEL_NAME");
      
       
        1
        2
        3
        4
       
      
       
        1
        2
        3
        4

*  第二步：集成到sdk中，比如友盟sdk

MobclickAgent. startWithConfigure(UMAnalyticsConfig config)
    UMAnalyticsConfig(Context context, String appkey, String channelId)
    UMAnalyticsConfig(Context context, String appkey, String channelId, EScenarioType eType)
    UMAnalyticsConfig(Context context, String appkey, String channelId, EScenarioType eType,Boolean isCrashEnable)
      
       
        1
        2
        3
        4
       
      
       
        1
        2
        3
        4

### 优缺点 ###

在渠道较少(个位数)的时候可以使用，但对于多渠道的时候太耗时耗力了。

# 友盟多渠道打包 #

该方法是友盟几年前公布的多渠道打包方式，并且在github开源了打包工具，友盟多渠道打包方式经历了多次迭代，主要有两种方式，一种是通过反编译apk修改渠道信息，另一种是通过AXML解析器编辑修改渠道信息。

### 原理 ###

*  第一种方法：   
    通过ApkTool进行解包，然后修改AndroidManifest中修改渠道标示，最后再通过ApkTool进行打包、签名。
 *  第二种方法：   
    使用AXML解析器[axmleditor.jar][]，拥有很弱的编辑功能，工程中用来编辑二进制格式的 AndroidManifest.xml 文件.

### 实现 ###

*  第一步 apktool解包apk

[apktool][]是一个逆向工程工具，可以用它解码（decode）并修改apk中的资源。接下来详细介绍如何使用apktool生成渠道包。

在[Android多渠道打包(一)][Link 1]介绍过，同样需要在AndroidManifest.xml文件中定义元素，并在应用启动的时候读取清单文件中的渠道号。打包时，只需构建一次生成一个apk，然后在该apk的基础上生成其他渠道包即可。

首先，使用apktool decode应用程序，在终端中输入如下命令：

> `apktool d your_unsigned.apk build`

解包后生成如下图片的文件   
![apk_packaging1.jpg][]

*  第二步 使用python脚本修改AndroidManifest.xml中的渠道号

AndroidManifest.xml文件内容

<manifest ...><application ...><meta-data android:name="CHANNEL_NAME"android:value="channel" />
            ...
        </application></manifest>
      
       
        1
        2
        3
        4
        5
        6
        7
        8
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8

[Python][]脚本

import re
    
    def replace_channel(channel, manifest):
        pattern = r'(<meta-data\s+android:name="CHANNEL_NAME"\s+android:value=")(\S+)("\s+/>)'
        replacement = r"\g<1>channel\g<3>".format(channel=channel1)
        return re.sub(pattern, replacement, manifest)
      
       
        1
        2
        3
        4
        5
        6
       
      
       
        1
        2
        3
        4
        5
        6

或者使用AXML解析器直接编辑修改AndroidManifest.xml中的渠道号

*  第三步 使用apktool重新构建未签名的apk

> `apktool b build your_unsigned_apk`

*  第四步 使用jarsigner重新签名apk

> `jarsigner -sigalg MD5withRSA -digestalg SHA1 -keystore your_keystore_path -storepass your_storepass -signedjar your_signed_apk, your_unsigned_apk, your_alias`

*  另在代码中集成，比如友盟sdk

### 官方说明 ###

*  最近更新

[友盟][Link 2]本次更新最大的改变是放弃了 V2.x 版本中通过 Apktool 反编译apk文件打包的方式，这种打包方式会对开发的apk文件做出大幅度的修改，可能会产生许多不兼容的问题，比如对jar包中包含资源的情况无法支持，对包含 .so 文件的apk兼容性也不好，而且在打包时 AndroidManifest.xml 文件中的特殊标签会丢失。为了解决这些问题减少对开发者apk文件的修改, 我们决定放弃这种方式，而采用直接编辑二进制的AndroidManifest.xml 文件的方式。这种方式只会修改 AndroidManifest.xml 文件，对于apk包中的资源文件和代码文件都不会做任何改变。如果打包不成功，生成的apk文件有问题，在[测试][Link 3]阶段也可以快速发现，因为修改只会影响AndroidManifest.xml 相关的少量的设置。

*  工具使用

axmleditor.jar 一个AXML解析器，拥有很弱的编辑功能，工程中用来编辑二进制格式的 AndroidManifest.xml 文件.   
JarSigner.jar 给 Apk 签名， SignApk.jar 文件是我们修改过的 apk 签名工具，实现了和 ADT 中一样的签名方式.   
这些[Java][]工具都是使用java7编译的，如果您还在使用[Java ][Java 1]1.6 请留下issue。   
DotNetZip 解压缩和压缩文件使用的是DotNetZip(Ionic.Zip.dll), 运行源码需要加入这个库.

### 优缺点 ###

对比之前的老方法大大节省了构建时间，因为该方法只需构建一次，然后通过脚本修改渠道并签名就可。   
但是对于三位数以上的渠道还是有点力不从心，另外该方法需要解压缩、压缩、重签名耗费时间较多，重签名可能会导致apk包在运行时有兼容性问题。

### 引用 ###

[友盟github][Link 2]

# maven&gradle打包 #

### 原理 ###

都是采用在AndroidManifest.xml的节点中添加如下元素，构建时替换value值得方式。

### 实现 ###

*  Maven

Maven是一个软件项目管理和自动构建工具，配合使用[Android][]\-maven-plugin插件，以及maven-resources-plugin插件可以很方便的生成渠道包，下面简要介绍下打包过程，更多Maven以及插件的使用方法请参考相关文档。

首先，在AndroidManifest.xml的节点中添加如下元素，用来定义渠道的来源：

<meta-data android:name="channel"android:value="${channel}" />
       
        
         1
         2
         3
         4
        
       
        
         1
         2
         3
         4

定义好渠道来源后，接下来就可以在程序启动时读取渠道号了：

private String getChannel(Context context) {
            try {
                PackageManager pm = context.getPackageManager();
                ApplicationInfo appInfo = pm.getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
                return appInfo.metaData.getString("channel");
            } catch (PackageManager.NameNotFoundException ignored) {
            }
            return "";
        }
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9

要替换AndroidManifest.xml文件定义的渠道号，还需要在pom.xml文件中配置Resources插件：

<resources><resource><directory>${project.basedir}</directory><filtering>true</filtering><targetPath>${project.build.directory}/filtered-manifest</targetPath><includes><include>AndroidManifest.xml</include></includes></resource></resources>
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10

准备工作已经完成，现在需要的就是实际的渠道号了。下面的脚本会遍历渠道列表，逐个替换并打包：

#!/bin/bash package(){
        while read line
        do
            mvn clean
            mvn  -Dchannel=$line package
        done < $1
    }
    
    package $1
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11

在前期渠道很少时这种方法还可以接受，但只要渠道稍微增多该方法就不再适用了，原因是每打一个包都要执行一遍构建过程，效率太低。

*  gradle

以友盟的渠道统计为例，渠道信息一般在 AndroidManifest.xml中修改以下值：

首先你必须在AndroidManifest.xml中的meta-data修改以下的样子：

其中`${UMENG_CHANNEL_VALUE}`中的值就是你在gradle中自定义配置的值。   
build.gradle文件就利用productFlavors这样写

productFlavors { 
        wandoujia {
            manifestPlaceholders = [UMENG_CHANNEL_VALUE: "wandoujia"]
        }
        baidu {
            manifestPlaceholders = [UMENG_CHANNEL_VALUE: "baidu"]
        } 
        c360 {
            manifestPlaceholders = [UMENG_CHANNEL_VALUE: "c360"]
        } 
        uc {
            manifestPlaceholders = [UMENG_CHANNEL_VALUE: "uc"]
        } 
    }
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14

其中`[UMENG_CHANNEL_VALUE: "wandoujia"]`就是对应`${UMENG_CHANNEL_VALUE}`的值。

不过现在有个更加简洁的写法

productFlavors {
    
        wandoujia {
         ...}//支持在{}定义属性
        baidu {
         ...}
        c360 {
         ...}
        uc {
         ...}
    
    productFlavors.all { flavor ->
        flavor.manifestPlaceholders = [UMENG_CHANNEL_VALUE: name]
    }
    
    }
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12

在android studio中sync gradle在build下可以看到

![20161006161832637][]   
直接在gradle中点击`assemble`可构建所有渠道的包   
单独点击对应渠道的`assemble` 比如`assembleC360`可以单独构建出C360渠道的包   
代码中获取渠道值如下代码

### 优缺点 ###

maven&gradle对于每个渠道都会单独构建一次，比较耗时，但是可以对各个渠道更加细化的定制

样例参考:

Gradle多渠道打包 
         
          由于国内Android市场众多渠道，为了统计每个渠道的下载及其它数据统计，就需要我们针对每个渠道单独打包，如果让你打几十个市场的包岂不烦死了，不过有了Gradle，这再也不是事了。 以友盟统计为例，在AndroidManifest.xml里面会有这么一段： 
         
          <meta-data 
         
          android:name="UMENG_CHANNEL" 
         
          android:value="Channel_ID" /> 
         
          里面的Channel_ID就是渠道标示。我们的目标就是在编译的时候这个值能够自动变化。 * 第一步 在AndroidManifest.xml里配置PlaceHolder 
         
          <meta-data 
         
          android:name="UMENG_CHANNEL" 
         
          android:value="${UMENG_CHANNEL_VALUE}" /> 
         
          第二步 在build.gradle 设置productFlavors 
         
          android { 
         
          productFlavors { 
         
          xiaomi {} 
         
          _360 {} 
         
          baidu {} 
         
          wandoujia {} 
         
          } 
         
          productFlavors.all { 
         
          flavor -> flavor.manifestPlaceholders = [UMENG_CHANNEL_VALUE: name] 
         
          } 
         
          } 
         
          然后直接执行 ./gradlew assembleRelease 
         
          然后就等待打包完成吧。 
         
          assemble 这个命令，会结合 Build Type 创建自己的task，如: 
         
          ./gradlew assembleDebug 
         
          ./gradlew assembleRelease

常用命令如下：(linux下是./gradlew，该脚本在项目下，windows直接gradlew即可) 
         
            
         
          ./gradlew -v 版本号，首次运行，没有gradle的要下载的哦。 
         
            
         
          ./gradlew clean 删除HelloWord/app目录下的build文件夹 
         
            
         
          ./gradlew build 检查依赖并编译打包 
         
          这里注意的是 ./gradlew build 命令把debug、release环境的包都打出来，生成的包在目录HelloWord/app/build/outputs/apk/下。如果正式发布只需要打release的包，该怎么办呢，下面介绍一个很有用的命令 assemble, 如 
         
            
         
          ./gradlew assembleDebug 编译并打Debug包 
         
            
         
          ./gradlew assemblexiaomiDebug 编译并打xiaomi的debug包，其他类似 
         
            
         
          ./gradlew assembleRelease 编译并打Release的包 
         
            
         
          ./gradlew assemblexiaomiRelease 编译并打xiaomi的Release包，其他类似 
         
            
         
          ./gradlew installRelease Release模式打包并安装 
         
            
         
          ./gradlew uninstallRelease 卸载Release模式包 
        
         
        
         
         
          
        
         
        
         
         
          http://www.jianshu.com/p/44d40f8e67c9 git自动获取包名打包

# 360多渠道打包 #

### 来源 ###

这个打包方法是由奇虎360的工程师开源出来的，这位大神在github的id是[seven456][]

### 原理 ###

利用的是Zip文件“可以添加comment（摘要）”的[数据结构][Link 4]特点，在文件的末尾写入任意数据，而不用重新解压zip文件（apk文件就是zip文件格式）；所以该工具不需要对apk文件解压缩和重新签名即可完成多渠道自动打包，高效速度快，无兼容性问题；

![20161006161324292][]

### 实现方式 ###

*  java源码

/*关键代码*/public static void main(String[] args) throws Exception {
    // 写入渠道号// args = "-path D:/111.apk -outdir D:/111/ -contents googleplay;m360; -password 12345678".split(" ");// 查看工具程序版本号// args = "-version".split(" ");// 读取渠道号// args = "-path D:/111_m360.apk -password 12345678".split(" ");long time = System.currentTimeMillis();
            String cmdPath  = "-path";
            String cmdOutdir  = "-outdir";
            String cmdContents  = "-contents";
            String cmdPassword  = "-password";
            String cmdVersion  = "-version";
            String help = "用法：java -jar MCPTool.jar [" + cmdPath + "] [arg0] [" + cmdOutdir + "] [arg1] [" + cmdContents + "] [arg2] [" + cmdPassword + "] [arg3]"
                    + "\n" + cmdPath + " APK文件路径"
                    + "\n" + cmdOutdir + " 输出路径（可选），默认输出到APK文件同一级目录"
                    + "\n" + cmdContents + " 写入内容集合，多个内容之间用“;”分割（linux平台请在“;”前加“\\”转义符），如：googleplay;m360; 当没有" + cmdContents + "”参数时输出已有文件中的contents"
                    + "\n" + cmdPassword + " 加密密钥（可选），长度8位以上，如果没有该参数，不加密"
                    + "\n" + cmdVersion + " 显示MCPTool版本号"
                    + "\n例如："
                    + "\n写入：java -jar MCPTool.jar -path D:/test.apk -outdir ./ -contents googleplay;m360; -password 12345678"
                    + "\n读取：java -jar MCPTool.jar -path D:/test.apk -password 12345678";
    
            if (args.length == 0 || args[0] == null || args[0].trim().length() == 0) {
                System.out.println(help);
            } else {
                if (args.length > 0) {
                    if (args.length == 1 && cmdVersion.equals(args[0])) {
                        System.out.println("version: " + VERSION_1_1);
                    } else {
                        Map<String, String> argsMap = new LinkedHashMap<String, String>();
                        for (int i = 0; i < args.length; i += 2) {
                            if (i + 1 < args.length) {
                                if (args[i + 1].startsWith("-")) {
                                    throw new IllegalStateException("args is error, help: \n" + help);
                                } else {
                                    argsMap.put(args[i], args[i + 1]);
                                }
                            }
                        }
                        System.out.println("argsMap = " + argsMap);
                        File path = argsMap.containsKey(cmdPath) ? new File(argsMap.get(cmdPath)) : null;
                        String parent = path == null? null : (path.getParent() == null ? "./" : path.getParent());
                        File outdir = parent == null ? null : new File(argsMap.containsKey(cmdOutdir) ? argsMap.get(cmdOutdir) : parent);
                        String[] contents = argsMap.containsKey(cmdContents) ? argsMap.get(cmdContents).split(";") : null;
                        String password = argsMap.get(cmdPassword);
                        if (path != null) {
                            System.out.println("path: " + path);
                            System.out.println("outdir: " + outdir);
                            if (contents != null && contents.length > 0) {
                                System.out.println("contents: " + Arrays.toString(contents));
                            }
                            System.out.println("password: " + password);
                            if (contents == null || contents.length == 0) { // 读取数据；
                                System.out.println("content: " + readContent(path, password));
                            } else { // 写入数据；
                                String fileName = path.getName();
                                int dot = fileName.lastIndexOf(".");
                                String prefix = fileName.substring(0, dot);
                                String suffix = fileName.substring(dot);
                                for (String content : contents) {
                                    File target = new File(outdir, prefix + "_" + content + suffix);
                                    if (nioTransferCopy(path, target)) {
                                        write(target, content, password);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            System.out.println("time：" + (System.currentTimeMillis() - time));
        }
    }
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        44
        45
        46
        47
        48
        49
        50
        51
        52
        53
        54
        55
        56
        57
        58
        59
        60
        61
        62
        63
        64
        65
        66
        67
        68
        69
        70
        71
        72
        73
        74
        75
        76
        77
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        44
        45
        46
        47
        48
        49
        50
        51
        52
        53
        54
        55
        56
        57
        58
        59
        60
        61
        62
        63
        64
        65
        66
        67
        68
        69
        70
        71
        72
        73
        74
        75
        76
        77

*  使用方法

1、命令行使用说明：   
用法：[Java][] -jar MCPTool.jar \[-path\] \[arg\] \[-contents\] \[arg\] \[-password\] \[arg\]   
\-path APK文件路径   
\-outdir 输出路径（可选），默认输出到APK文件同一目录   
\-contents 写入内容集合，多个内容之间用“;”分割，如：googleplay;m360; 当没有“-contents”参数时输出已有文件中的content   
\-password 加密密钥（可选），长度8位以上，如果没有该参数，不加密   
\-version 显示版本号   
例如：

> 写入：   
> `java -jar MCPTool.jar -path D:/test.apk -outdir ./ -contents googleplay;m360; -password 12345678`   
> 读取：   
> `java -jar MCPTool.jar -path D:/test.apk -password 12345678`

2、[Android][]代码中读取写入的渠道号：   
导入MCPTool.jar中的MCPTool类，MCPTool.getChannelId(context, mcptoolPassword, defValue)读出写入的渠道号；

3、jenkins、hudson、ant使用说明：   
请看MultiChannelPackageTool\\build-ant\\MCPTool\\build.xml文件；

4、Windows下bat脚本运行说明：   
拖拽文件即可完成多渠道打包：MultiChannelPackageTool\\build-ant\\MCPTool\\MCPTool.bat；   
拖拽文件检查渠道号是否写入成功：MultiChannelPackageTool\\build-ant\\MCPTool\\MCPTool-check.bat；

*  获取渠道号

/** * Android平台读取渠道号 * @param context Android中的android.content.Context对象 * @param mcptoolPassword mcptool解密密钥 * @param defValue 读取不到时用该值作为默认值 * @return */public static String getChannelId(Object context, String mcptoolPassword, String defValue) {
            String content = MCPTool.readContent(new File(getPackageCodePath(context)), mcptoolPassword);
            return content == null || content.length() == 0 ? defValue : content;
        }
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11

String channelId = MCPTool.getChannelId(context,password,default);
      
       
        1
       
      
       
        1

### 优缺点 ###

没有解压缩、压缩、重签名，没有兼容性问题，速度最快；写入的渠道号数据支持加密，安全可靠；

由于速度极快，我还可以作为服务器端下载apk时动态写入“特定数据”，用户下载到apk后安装启动，读取“特定数据”完成特定的操作；   
如：加好友功能，下载前写入用户ID，用户下载后启动apk，读取写入的用户ID，完成加好友操作，用户体验大大提升，没有断裂感；   
当然，也可以写入JSON数据，想做什么就做什么；

### 引用 ###

[seven456：MultiChannelPackageTool][seven456_MultiChannelPackageTool]

# 360多渠道打包升级版: #

### 原理 ###

利用的是Zip文件“可以添加comment（摘要）”的[数据结构][Link 4]特点，在文件的末尾写入任意数据，而不用重新解压zip文件（apk文件就是zip文件格式）。

### 实现 ###

实现方式有三种：[Python][]脚本、[Java][]脚本、gradle构建

*  方法一：python脚本的方式

python源码

'''关键代码'''def _check(apkfile, marketfile=MARKET_PATH, output=OUTPUT_PATH, format=ARCHIVE_FORMAT, show=False, test=0):''' check apk file exists, check apk valid, check arguments, check market file exists '''if not os.path.exists(apkfile):
            print('apk file', apkfile, 'not exists or not readable')
            returnif not parse_apk(apkfile):
            print('apk file', apkfile, 'is not valid apk')
            returnif show:
            show_market(apkfile)
            returnif test > 0:
            run_test(apkfile, test)
            returnif not os.path.exists(marketfile):
            print('marketfile file', marketfile, 'not exists or not readable.')
            return
        old_market = read_market(apkfile)
        if old_market:
            print('apk file', apkfile, 'already had market:', old_market,
                  'please using original release apk file')
            return
        process(apkfile, marketfile, output, format)
    
    
    def _parse_args():''' parse command line arguments '''
        parser = argparse.ArgumentParser(
            formatter_class=argparse.RawDescriptionHelpFormatter,
            description='PackerNg v{0} created by mcxiaoke.\n {1}'.format(__version__, INTRO_TEXT),
            epilog='')
        parser.add_argument('apkfile', nargs='?',
                            help='original release apk file path (required)')
        parser.add_argument('marketfile', nargs='?', default=MARKET_PATH,
                            help='markets file path [default: ./markets.txt]')
        parser.add_argument('output', nargs='?', default=OUTPUT_PATH,
                            help='archives output path [default: ./archives]')
        parser.add_argument('-f', '--format', nargs='?', default=ARCHIVE_FORMAT, const=True,
                            help="archive format [default:'${name}-${package}-v${vname}-${vcode}-${market}${ext}']")
        parser.add_argument('-s', '--show', action='store_const', const=True,
                            help='show apk file info (pkg/market/version)')
        parser.add_argument('-t', '--test', default=0, type=int,
                            help='perform serval times packer-ng test')
        args = parser.parse_args()
        if len(sys.argv) == 1:
            parser.print_help()
            return Nonereturn args
    
    if __name__ == '__main__':
        args = _parse_args()
        if args:
            _check(**vars(args))
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59

python脚本

`python PackerNg.py [file] [market] [output] [-h] [-s] [-t TEST]`

方法二：java脚本的方式

/*关键代码*//*java 脚本程序入口*/public static void main(String[] args) {
            if (args.length < 2) {
                Helper.println(USAGE_TEXT);
                Helper.println(INTRO_TEXT);
                System.exit(1);
            }
            File apkFile = new File(args[0]);
            File marketFile = new File(args[1]);
            File outputDir = new File(args.length >= 3 ? args[2] : "apks");
            if (!apkFile.exists()) {
                Helper.printErr("Apk file '" + apkFile.getAbsolutePath() +
                        "' is not exists or not readable.");
                Helper.println(USAGE_TEXT);
                System.exit(1);
                return;
            }
            if (!marketFile.exists()) {
                Helper.printErr("Market file '" + marketFile.getAbsolutePath() +
                        "' is not exists or not readable.");
                Helper.println(USAGE_TEXT);
                System.exit(1);
                return;
            }
            if (!outputDir.exists()) {
                outputDir.mkdirs();
            }
            Helper.println("Apk File: " + apkFile.getAbsolutePath());
            Helper.println("Market File: " + marketFile.getAbsolutePath());
            Helper.println("Output Dir: " + outputDir.getAbsolutePath());
            List<String> markets = null;
            try {
                markets = Helper.parseMarkets(marketFile);
            } catch (IOException e) {
                Helper.printErr("Market file parse failed.");
                System.exit(1);
            }
            if (markets == null || markets.isEmpty()) {
                Helper.printErr("No markets found.");
                System.exit(1);
                return;
            }
            final String baseName = Helper.getBaseName(apkFile.getName());
            final String extName = Helper.getExtension(apkFile.getName());
            int processed = 0;
            try {
                for (final String market : markets) {
                    final String apkName = baseName + "-" + market + "." + extName;
                    File destFile = new File(outputDir, apkName);
                    Helper.copyFile(apkFile, destFile);
                    Helper.writeMarket(destFile, market);
                    if (Helper.verifyMarket(destFile, market)) {
                        ++processed;
                        Helper.println("Generating apk " + apkName);
                    } else {
                        destFile.delete();
                        Helper.printErr("Failed to generate " + apkName);
                    }
                }
                Helper.println("[Success] All " + processed
                        + " apks saved to " + outputDir.getAbsolutePath());
                Helper.println(INTRO_TEXT);
            } catch (MarketExistsException ex) {
                Helper.printErr("Market info exists in '" + apkFile
                        + "', please using a clean apk.");
                System.exit(1);
            } catch (IOException ex) {
                Helper.printErr("" + ex);
                System.exit(1);
            }
    }
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71
         72
         73
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28
         29
         30
         31
         32
         33
         34
         35
         36
         37
         38
         39
         40
         41
         42
         43
         44
         45
         46
         47
         48
         49
         50
         51
         52
         53
         54
         55
         56
         57
         58
         59
         60
         61
         62
         63
         64
         65
         66
         67
         68
         69
         70
         71
         72
         73

java脚本

`java -jar PackerNg.jar apkFile marketFile outputDir`

方法三：gradle构建

在项目top level build.gradle中添加

buildscript {
        ......
        dependencies{
        // add packer-ng
            classpath 'com.mcxiaoke.gradle:packer-ng:1.0.7'
        }
    }  
       
        
         1
         2
         3
         4
         5
         6
         7
        
       
        
         1
         2
         3
         4
         5
         6
         7

在 app level build.gradle中添加

apply plugin: 'packer'
    packer {
        checkSigningConfig = true
        checkZipAlign = true
        archiveNameFormat = '${appPkg}-${flavorName}-${buildType}-v${versionName}-${versionCode}-${fileMD5}'
        archiveOutput = file(new File(project.rootProject.buildDir.path, "apks"))
    }
       
        
         1
         2
         3
         4
         5
         6
         7
        
       
        
         1
         2
         3
         4
         5
         6
         7

### 着重几点 ###

*  改善了360多渠道打包方式中api兼容性的问题

ZipFile.getComment是ZIP文件注释写入，使用Java会导致APK文件被破坏，无法安装。这里是读取ZIP文件注释的问题，[Java ][Java 1]7里可以使用zipFile.getComment()方法直接读取注释，非常方便。但是[Android][]系统直到API 19，也就是4.4以上的版本才支持 ZipFile.getComment() 方法。由于要兼容之前的版本，所以这个方法也不能使用。改为：

public static boolean hasZipCommentMagic(File file) throws IOException {
                RandomAccessFile raf = null;
                try {
                    raf = new RandomAccessFile(file, "r");
                    long index = raf.length();
                    byte[] buffer = new byte[MAGIC.length];
                    index -= MAGIC.length;
                    // read magic bytes
                    raf.seek(index);
                    raf.readFully(buffer);
                    // check magic bytes matchedreturn isMagicMatched(buffer);
                } finally {
                    if (raf != null) {
                        raf.close();
                    }
                }
            }
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18

*  Android 7.0签名校验引起的安装失败

为了提高Android系统的安全性，Google从Android 7.0开始增加一种新的增强签名模式，从Android Gradle Plugin 2.2.0开始，构建系统在打包应用后签名时默认使用APK signature scheme v2，该模式在原有的签名模式上，增加校验APK的SHA256哈希值，如果签名后对APK作了任何修改，安装时会校验失败，提示没有签名无法安装，使用本工具修改的APK会无法安装，解决办法是在 signingConfigs 里增加 v2SigningEnabled false ，禁用新版签名模式，技术细节请看官方文档：[APK signature scheme v2][]

android {
        ...
        defaultConfig { ... }
        signingConfigs {
          release {
            storeFile file("myreleasekey.keystore")
            storePassword "password"
            keyAlias "MyReleaseKey"
            keyPassword "password"
            v2SigningEnabled false //禁用v2签名增强模式
          }
        }
      }
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
        
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13

### 优缺点 ###

使用APK注释保存渠道信息和MAGIC字节，从文件末尾读取渠道信息，速度飞快

实现为一个Gradle Plugin，支持定制输出APK的文件名等信息，方便CI集成

提供Java版和Python的独立命令行脚本，不依赖Gradle插件，支持独立使用   
缺点

没有使用Android的productFlavors实现，无法利用flavors条件编译的功能

**现360推出加固宝,方便进行签名与打包以及软件加固防解密**,操作比较简便易上手,有兴趣可以用一下

# 总结 #

原始多渠道打包：

渠道较少的情况下使用，每设置一次渠道id需要构建一次，完全是个体力活。
      
       
        1
       
      
       
        1

友盟多渠道打包：

打包：解压apk文件 -> 替换AndroidManifest.xml中的meta-data -> 压缩apk文件 -> 签名
    读取渠道号：直接通过Android的API读取meta-data
    特点：需要解压缩、压缩、重签名耗费时间较多，重签名会导致apk包在运行时有兼容性问题。
      
       
        1
        2
        3
       
      
       
        1
        2
        3

360多渠道打包

打包：直接写入渠道号到apk文件的末尾
    读取渠道号：直接读取data/app/<package>.apk文件末尾的渠道号
    特点：没有解压缩、压缩、重签名，没有兼容性问题，速度最快；写入的渠道号数据支持加密，安全可靠。
      
       
        1
        2
        3
       
      
       
        1
        2
        3

360多渠道打包plus(进阶版)

改善了360多渠道打包受android api19的影响，并扩展了java、python、gradle插件版，是目前第三方多渠道打包中速度最快最灵活的。
      
       
        1
       
      
       
        1

maven、gradle版

对于android studio而言基本上抛弃了maven的方式，那么对于gradle版我们可以通过productFlavors通过更加细腻的定制，不过打包构建过程还是比较耗时。
      
       
        1
       
      
       
        1

那么我们选择时可以按实际情况使用360多渠道打包plus，或者android studio gradle多渠道打包。需注意的是360多渠道打包plus无法通过android7.0签名校验，当然只要是通过后期修改apk文件的方式都不能通过android7.0的签名校验。

[Link 1]: http://blog.csdn.net/yancey_blog/article/details/52738817
[axmleditor.jar]: https://github.com/ntop001/AXMLEditor
[apktool]: https://ibotpeaches.github.io/Apktool/
[apk_packaging1.jpg]: /images/20220714/f4364e0cde114759b5ab2ce17ac63150.png
[Python]: http://lib.csdn.net/base/python
[Link 2]: https://github.com/umeng/umeng-muti-channel-build-tool
[Link 3]: http://lib.csdn.net/base/softwaretest
[Java]: http://lib.csdn.net/base/javaee
[Java 1]: http://lib.csdn.net/base/java
[Android]: http://lib.csdn.net/base/android
[20161006161832637]: /images/20220714/5666d92d5702474daeb09f60be5770bd.png
[seven456]: https://github.com/seven456
[Link 4]: http://lib.csdn.net/base/datastructure
[20161006161324292]: /images/20220714/9a6b414a87eb484fa42f0de2740eb698.png
[seven456_MultiChannelPackageTool]: https://github.com/seven456/MultiChannelPackageTool
[APK signature scheme v2]: https://developer.android.com/about/versions/nougat/android-7.0.html#apk_signature_v2