由于PhoneGap和Apache Cordova在底层上的一致性，本文主要讨论PhoneGap提供的额外工具，其他主题请参考：

1. 基于Apache Cordova开发移动应用程序

一个框架，支持通过标准的基于JavaScript的API，来开发跨平台的移动应用。PhoneGap同时支持基于Web、基于Native两种风格的混合应用，它通过联合使用Native元素和Web元素，来达到更加Native的look and feel。通过PhoneGap底层的Apache Cordova框架，我们可以使用很多设备的原生特性，例如GPS、罗盘、摄像头。

基于PhoneGap的混合应用有以下额外的特点：

1. 不能完整调用原生API：只有受限的、通用的基础API被Cordova框架支持
2. 平台差异化不足，应用界面长得差不多

后者是PhoneGap的底层框架，PhoneGap是后者的一个distribution。两者提供的命令行工具很类似，使用一套插件体系。PhoneGap提供了一些额外功能，包括：

1. PhoneGap Developer App
2. PhoneGap Desktop App
3. PhoneGap Enterprise
4. 云端构建功能

PhoneGap依赖于Node.js、NPM（Node.js目前自带）、git，准备好后，运行：

npm install -g phonegap@latest

安装结束后，即可运行命令

phonegap 

PhoneGap为Windows、Mac OS X提供了图形化界面，使用它可以方便的创建新的PhoneGap应用。可以到这里下载Windows的安装包。

该工具价值不大，使用PhoneGap CLI可以很容易的代替之。

PhoneGap提供了一个移动APP——PhoneGap Developer App（以下简称PGDA），可以方便的在设备上预览、测试PhoneGap应用。不需要任何插件的支持或者编译步骤，该APP就可以支持设备Native特性的访问。

该APP有安卓、IOS、WP三个版本，可以到对应的商店下载安装。

PGDA本质上就是一个Phonegap应用程序，只是它具有从远程服务器上同步最新Web代码的能力。PGDA默认自带了Cordova内置插件，如果你要使用第三方插件，必须自己构建PGDA。

PGDA的源码托管在：https://github.com/phonegap/phonegap-app-developer

下载源码后，可以参考如下方式添加新插件支持，并构建（以Android为例）：

cd phonegap-app-developer
# 添加NFC插件的支持
cordova plugin add phonegap-nfc
#构建Android平台
cordova build android

构建完毕后，文件platforms\android\build\outputs\apk\android-debug.apk即为最新的PGDA安装包，安装到设备即可。 

打开PhoneGap桌面版本，点击左侧的+号，即可创建新的PhoneGap应用。输入路径、名称、ID后，即可创建工程。新创建的工程的结构如下：

亦可导入既有的PhoneGap应用，Apache Cordova应用也是支持的，可以导入。

点击项目右侧的右侧的运行按钮，会启动一个HTTP服务，侦听3000端口。

打开移动设备，点击PGDA图标，输入上述HTTP服务的地址和端口，点击Connect，看到DEVICE IS READY字样，说明设备和HTTP服务器连接成功。在此设备界面上：

1. 四指轻触：刷新视图
2. 三指轻触：回到PGDA主界面

现在，可以打开

www/index.html

<h1>PhoneGap</h1>

命令格式：

phonegap [子命令] [选项]

phonegap create [options] <path> [id [name [config]]]

phonegap create project-dir cc.gmem.phonegap.study PhonegpStudy

phonegap run [<platforms>] [options] [-- [platform options]]

# 列出可用模板
phonegap template list

phonegap serve [options]

phonegap remote [command]

利用Adobe提供的PhoneGap云端服务，只需要上传PhoneGap应用程序的资产文件（HTML、CSS、JavaScript），后续的构建工作可以在云端完成。使用云构建服务，可以：

1. 避免本地维护各套平台SDK、甚至安装多套操作系统的麻烦
2. 加快开发周期，在云端可以更快的构建，并且构建结果可以推送到测试人员预安装的App中

云构建服务分为免费、收费版本，免费版本仅支持一个私有（闭源、商业）App。

自动重新加载时，PhoneGap CLI会在控制台上打印信息：

[phonegap] 200 /__api__/autoreload

自动重新加载的前提条件是，页面引用cordova的JavaScript文件：

<script type="text/javascript" src="cordova.js"></script>

此外，某些版本上的模拟器不能正常reload，可能是兼容性问题。

我的手机是越狱后的iOS 6.1.2，在AppStore下载的PGDA 1.5.12，无法连接到通过

phonegap serve

到GitHub上逐个下载预构建版本并安装测试，发现：

1. 1.5.x：全部不能使用
2. 1.4.0：可以连接但无法自动重新加载
3. 1.3.0：能够连接，也可以autoreload

很无语……现在安装1.3.0正常使用。

The post PhoneGap学习笔记 appeared first on 绿色记忆.

1. 目标平台：本文中会反复出现该名词，目标平台是指移动操作系统+移动应用SDK构成的移动应用支撑环境。有时也称作移动平台，或简称平台
2. 构建平台：在其上运行Cordova工具，生成目标平台应用程序的宿主操作系统
3. PhoneGap：目前作为Apache Cordova的一个发行版，它们的命令行非常相似。PhoneGap提供了一些更高级的组件，例如云端构建、设备端工具（PhoneGap Developer App）

可以选择三种方式来开发移动应用，它们各有特点：

1. 为特定的设备、操作系统构建。需要熟悉设备SDK，甚至特殊的开发语言：Objective-C/Swift (iOS)；Java (Android)；C# (Windows)
2. 安装到设备，作为本地程序运行
3. 使用原生的API和控件
4. 通常必须经过应用市场的验证才能被客户使用
5. 可以离线使用
6. 性能优秀

1. 在任何移动浏览器中运行
2. 支持受限的使用设备特性
3. 基于标准的Web技术构建，包括HTML、CSS、JavaScript
4. 需要支持多种屏幕尺寸
5. 需要Web服务器的支撑，不支持离线使用
6. 性能较差

所谓混合应用，就是结合了前两者的特性和优势的应用，混合应用可以分为两种风格：

1. 基于Web的混合应用（Web hybrid mobile apps）：APP运行在一个很薄的Native容器+WebView中，该容器仅作为访问Native特性的桥梁，所有UI组件均基于Web技术构建
2. 基于Native的混合应用（Native hybrid mobile apps）：包含很多的Native控件，以及1-N个WebView。常常使用Native控件做导航、并在提供应用内容的WebView之间进行切换

混合应用具有以下特性：

1. 安装到设备，作为本地程序运行
2. 应用逻辑主要在WebView（嵌入的Web浏览器）中运行
3. 大部分代码是跨平台的
4. 支持访问原生特性
5. 由于应用内容主要使用基于设备内置浏览器引擎，因此性能比起原生应用差

Apache Cordova是一个开源移动应用开发框架，它允许你使用标准的Web技术——HTML5、CSS3、JavaScript ——来进行跨平台开发，避免使用各移动平台Native的编程语言和SDK。基于Cordova的应用程序被包装在各平台的Wrapper中，使用标准兼容的API访问设备传感器、数据和其它Native特性。

Apache Cordova 工程依赖于一个命名为config.xml的配置文件，该配置文件影响应用程序的工作方式（例如是否对横屏做出响应）。

应用程序本身实现为网页，默认情况下是本地的一个index.html文件，该文件可能引用任何Web资源，例如JavaScript、CSS。应用程序被包装在Native的Wrapper中，作为WebView运行。该WebView作为更大的混合（Hybrid ）应用的一个组件，或者占据整个UI。

插件接口（plugin interface ）允许Cordova和Native组件之间进行通信，插件接口以JavaScript的形式提供，从而允许在网页上调用Native代码。理想情况下，各平台的API应该一致，在3.0中，官方插件提供标准化的设备API，而第三方插件可能提供一些特定于特殊平台的API。Cordova官方提供了自定义插件的开发文档。

从3.0开始，新创建的Cordova工程默认不包含任何插件，所有插件都需要手工添加。

Cordova 应用的开发工作流有两种：

1. 以Cordova CLI为中心跨平台工作流：如果需要应用在尽可能多的平台上运行，可以使用这种方式，该方式需要很少的平台特定开发工作量。CLI是3.0引入的，可以同时为多个平台构建工程的工具，它是Cordova跨平台工作流的核心。CLI会创建Cordova工程的初始结构、把Web资产文件拷贝到各平台的子目录下、对各平台进行必要的配置，然后运行脚本生成二进制程序。CLI也提供了为应用添加插件的公共接口
2. 以平台为中心的工作流：如果需要构建特定单个平台的应用，以及需要在底层基于平台SDK对代码进行修改，可以使用该方式。典型的例子是开发Native-based混合应用，需要把WebView和其他Native组件集成时。使用这种方式开发时，可以通过Plugman来添加插件

推荐以第1种方式开始，使用CLI创建Cordova工程，在必要时切换到第2种方式。针对平台的低级别Shell工具可以在工程的

platforms/*/cordova

使用Cordova的命令行接口（CLI），可以完成新工程的创建、针对各平台进行构建、并部署到设备（或模拟器）中运行。

在安装和使用CLI前，必须下载和安装相关目标平台的SDK和相关工具，如果不安装，在调用CLI进行应用构建时会收到错误提示，例如：

#没有安装完整Android SDK机器上的报错信息
Running command: cmd "/s /c "...\cordova-study\platforms\android\cordova\build.bat""
[Error: Please install Android target: "android-22".

Hint: Open the SDK manager by running: D:\Android\sdk\tools\android.BAT
You will require:
1. "SDK Platform" for android-22
2. "Android SDK Platform-tools (latest)
3. "Android SDK Build-tools" (latest)]
ERROR building one of the platforms: Error: cmd: Command failed with exit code 2
You may not have the required environment or OS to build this project

CLI支持的目标平台（构建平台）包括：

1. iOS（Mac）
2. Android (Mac, Linux, Windows)
3. BlackBerry 10 (Mac, Linux, Windows)
4. Windows Phone 8 (Windows)

可以看到如果要支持全部主要的目标平台，你需要在不同操作系统上运行CLI命令，这意味着你应该使用代码库（SVN/Git）来管理工程。

1. 安装Node.js
2. 安装Git客户端
3. 通过npm命令安装cordova模块：
   

   # 安装Cordova为全局模块
   npm install -g cordova
   #安装特定版本的Cordova
   npm install -g cordova@3.1.0-0.2.0
   
   #更新Cordova
   npm update -g cordova
   
   #显示版本信息
   cordova -v

执行下面的命令创建工程：

pushd D:\JavaScript\projects\cordova\5.4.1
# cordova-study在当前目录下创建的子目录，作为工程文件的容器
# cc.gmem.study.cordova 域名反转的包名，可能被生成的外部文件引用，例如Android包名
# CordovaStudy 应用程序的标题
# 第2/3个参数可以在config.xml中手工修改
cordova create cordova-study cc.gmem.study.cordova CordovaStudy

命令执行完毕后，生成如下目录结构： 

运行下面的命令添加对特定平台的支持：

#添加Android平台的支持
cordova platform add android
#输出如下：
Running command: cmd "/s /c "...\create.bat ...\cordova-study\platforms\android cc.gmem.study.cordova CordovaStudy --cli""
Creating Cordova project for the Android platform:
        #创建目标平台工程特定的文件
        Path: platforms\android
        Package: cc.gmem.study.cordova
        Name: CordovaStudy
        Activity: MainActivity
        Android target: android-22
Copying template files...
Android project created with cordova-android@4.1.1
#安装插件
Discovered plugin "cordova-plugin-whitelist" in config.xml. Installing to the project
Fetching plugin "cordova-plugin-whitelist@1" via npm
Installing "cordova-plugin-whitelist" for android


#添加iOS平台的支持，需要在安装了iOS SDK的Mac OS X上执行
cordova platform add ios
#添加Windows Phone 8平台的支持，需要在Windows上运行
cordova platform add wp8


#下面的命令示例了如何移除平台的支持
cordova platform remove blackberry10

#添加指定版本的cordova平台支持，并保存到config.xml中
cordova platform add android@3.7.0 --save

运行上述命令后，Cordova工程的platforms、plugins子目录出现一些下载/生成的文件：

前面我们说过，创建新工程可以从CLI命令行开始，在必要时切换到特定平台的开发工作中去。在此，就可以进行切换了：只需要把platforms子目录导入到Eclipse、XCode等IDE即可，然后以IDE为中心完成后续开发。

如果继续执行以CLI为中心的工作流，则需要继续了解下面的小节。

执行下面的命令可以构建应用程序的二进制文件并打包：

# 构建所有平台
cordova build
# 构建特定平台
cordova build ios

上述build命令实际上包含了两个步骤： 

# 准备阶段，会把Cordova源码拷贝、合并到平台的对应目录中
# 一旦执行完该命令，就可以用特定平台提供的SDK进行修改、编译
cordova prepare ios
# 编译
cordova compile ios

运行下面的命令重新构建特定平台的应用，并部署到模拟器中：

# 运行下面的命令后，Cordova会自动启动模拟器，并把APK安装到上面
# 如果有模拟器正在运行，则使用既有的模拟器
cordova emulate android
# APK安装完毕后，将自动运行

 或者，将启用了调试模式的手机连接到当前计算机，然后运行：

cordova run android

你可以使用Web技术修改Cordova生成的应用骨架，来开发漂亮的页面。但是如果想使用设备底层特性，则必须添加插件，利用插件可以访问核心Cordova API。第三方/自己开发的插件可以用来访问特殊的设备特性，要访问通用设备特性使用Cordova提供的的插件就足够了。官方插件和第三方插件的列表位于http://cordova.apache.org/plugins/。

下面的命令用来搜索插件：

#同时包含bar和code的插件
cordova plugin search bar code

下面的命令用来列出当前工程已添加的插件：

cordova plugin ls

下面的命令用来移除已经添加的插件：

cordova plugin rm cordova-plugin-console

下面的命令用来给应用程序添加插件：

#依据插件ID添加
cordova plugin add plugin-id
#添加特定版本的插件
cordova plugin add plugin-id@latest
cordova plugin add plugin-id@1.2.0

# 设备基本特性
cordova plugin add cordova-plugin-device
# 网络连接信息
cordova plugin add cordova-plugin-network-information
# 电池状态
cordova plugin add cordova-plugin-battery-status
# 加速度计
cordova plugin add cordova-plugin-device-motion
# 横屏切换
cordova plugin add cordova-plugin-device-orientation
# 地理位置信息
cordova plugin add cordova-plugin-geolocation
# 摄像头
cordova plugin add cordova-plugin-camera
# 媒体截屏
cordova plugin add cordova-plugin-media-capture
# 媒体回放
cordova plugin add cordova-plugin-media
# 访问设备或网络上的文件
cordova plugin add cordova-plugin-file
cordova plugin add cordova-plugin-file-transfer
# 通过振动或者对话框通知用户
cordova plugin add cordova-plugin-dialogs
cordova plugin add cordova-plugin-vibration
# 访问通讯录
cordova plugin add cordova-plugin-contacts
# 国际化
cordova plugin add cordova-plugin-globalization
# 启动画面支持
cordova plugin add cordova-plugin-splashscreen
# 打开新的应用内浏览器窗口
cordova plugin add cordova-plugin-inappbrowser
# 调试控制台
cordova plugin add cordova-plugin-console

CLI根据需要为各平台添加插件代码。Plugman可以为单个平台添加插件支持。 

如果插件没有在默认源（registry.cordova.io ）注册，通过下面的命令添加：

# 从Git的master分支下载插件
cordova plugin add https://github.com/someone/aplugin.git
# 从特定标记或者分支下载插件
cordova plugin add https://github.com/someone/aplugin.git#r0.2.0
# 如果插件（以及plugin.xml）在Git仓库的子目录下，可以
cordova plugin add https://github.com/someone/aplugin.git#:/sub/dir
# 也可以从本地文件系统添加插件
cordova plugin add ../local_plugin_dir

前面提到过，在以CLI为中心的跨平台开发工作流下，不应当修改platforms子目录。那么，如果如何实现平台差异化呢？例如为不同平台提供不同的样式表.css文件，这是很合理的需求。

Cordova提供了一种合并机制，在工程顶级目录下，可以添加一个merges目录，其子目录是各平台的名称，例如

merges/android

merges/android/css/index.css

www/css/index.css

merges中的文件如果在www下没有对应物，会直接复制到特定平台的资产目录下。

命令格式：

cordova 子命令 [选项]

# 显示run子命令的帮助信息
cordova run --help

cordova compile [PROD] [TARGET] [EXP] [PLATS] [-- POPTS]

cordova prepare && cordova compile

cordova run --emulator

cordova serve [PORT]

phonegap serve

首先，参考文章：基于Eclipse ADT和Maven的Android开发 完整Android开发环境的搭建。

由于Android平台官方的开发工具现在是Android Studio，并且基于Gradle构建，所以最好搭建好Gradle环境和Gradle的Eclipse插件。可参考文章：Gradle学习笔记。

通过CLI创建Cordova工程后，一旦添加了Android平台的支持，就可以把platforms/android子目录作为工程导入到Eclipse ADT或者Android Studio。

以Eclipse ADT为例，操作步骤为：

1. File ⇨ Import
2. 在弹出的对话框中选择 Android ⇨ Existing Android Code Into Workspace，点击下一步
3. 把Root Directory定位到Cordova工程的platforms/android目录，选择其中的两个工程，如下图：
   
4. 点击完成，工作区出现两个新的ADT工程，导入完毕

这两个工程就是普通的ADT工程。其中cordovalib是cordova-android的依赖库。在cordova-android上点击右键 ⇨ Run as ⇨ Android Application，即可打包并部署到设备上运行。

上述方式导入的工程结构比较混乱，如果后续开发脱离Cordova进行，建议清理其中不需要的目录和文件。如果不习惯基于Gradle进行构建，可以创建或者转换为Maven工程。

安装了Gradle的Eclipse插件后，可以把platforms/android子目录转换为Gradle工程：

1. File ⇨ Import
2. 在弹出的对话框中选择 Gradle ⇨ Gradle Project，点击下一步
3. 在弹出的对话框中，把Root folder定位到platforms/android子目录，然后点击右侧的Build Model按钮。Gradle从Maven仓库下载一些构件到Gradle缓存目录，完毕后显示如下画面：
4. 点击完成。你可以自由的修改Eclipse工程的名称

如果习惯于使用Maven进行构建工作，可以参考下面的步骤，把platforms/android子目录转换为Maven工程：

1. 参考：基于Eclipse ADT和Maven的Android开发创建Android的Maven工程，设工程根目录为

   %MVN_PROJECT_ROOT%

    。删除自动生成的Activity、res目录，并转换为android-maven-plugin 4.3.0标准的工程结构
2. 如果使用SVN，在目录%MVN_PROJECT_ROOT% 上设置属性svn:ignore为：
   

   target
   bin
   .*
   cli

3. 通过CLI创建对应的（同名同包）Cordova工程，添加必要的插件，设工程根目录为

   %CORDOVA_PROJECT_ROOT%

    
4. 创建Maven工程指向Cordova工程的符号链接：
   

   mklink /D %MVN_PROJECT_ROOT%\cli %CORDOVA_PROJECT_ROOT%

5. 另外创建一个Android的Maven工程“cordova-android”，project.properties中设置

   android.library=true

    ，表示这是一个库工程。设工程根目录为

   %MVN_LIB_ROOT%

    
6. 修改

   %MVN_PROJECT_ROOT%\pom.xml

    ，添加cordova-android的依赖，例如：
   

   <dependency>
       <groupId>org.apache.cordova</groupId>
       <artifactId>cordova-android</artifactId>
       <version>4.4.1-SNAPSHOT</version>
       <type>apklib</type>
   </dependency>

7. 修改Cordova工程的

   %CORDOVA_PROJECT_ROOT%\cli\platforms\android\build-extras.gradle

    文件，添加以下Tasks：
   

   task syncdown_src(type : Copy){
       from 'src'
       into '../../../src/main/java'
   }
   task syncdown_assets(type : Copy){
       from 'assets'
       into '../../../src/main/assets'
   }
   task syncdown_res(type : Copy){
       from 'res'
       into '../../../src/main/res'
   }
   task syncdown_libsrc(type : Copy){
       def dest = '../../../../cordova-android/src/main/java'
       if(file(dest).exists()){
           from 'CordovaLib/src'
           into dest
       }
   }
   task syncdown_manifest(type : Copy){
       from 'AndroidManifest.xml'
       into '../../../src/main'
   }
   task syncdown( dependsOn: [syncdown_src, syncdown_assets, syncdown_res, syncdown_libsrc, syncdown_manifest] )

8. 每当添加Cordova插件，或者修改Cordova工程中其它源码文件后，定位到

   %MVN_PROJECT_ROOT%\cli

   目录，执行：
   

   @echo off
   call cordova prepare 
   pushd platforms\android
   call gradle syncdown
   popd

   这会让所有修改从Cordova工程目录，同步到其Android平台子目录，然后再同步到Maven工程对应目录中。 

Android平台特定的命令行工具位于

platforms/android/cordova

###  构建工程  ###

#Apache Cordova CLI方式
cordova build android

#Android平台命令行工具
platforms/android/cordova/build --debug   #生成调试信息
platforms/android/cordova/build --release #对应用进行签名
#其它参数
# --ant 使用Ant进行构建
# --gradle 使用Gradle进行构建，Cordova 4.0以后的默认值
# --nobuild 不进行构建
# --prepenv 不进行构建，但是拷贝必要的构建脚本
# --versionCode=# 指定本次构建的版本号
# --minSdkVersion=# 指定本次构建要求的最低Android SDK版本代码
# --gradleArg=# 指定传递给Gradle的命令行参数
# --buildConfig 指定包含了构建配置的JSON文件


###  部署到模拟器  ###
# 需要首先配置并启动一台Android模拟器

#Apache Cordova CLI方式
cordova emulate android

#Android平台命令行工具
platforms/android/cordova/run --emulator
platforms/android/cordova/run --target=targetId #指定特定ID的模拟器
#当执行run时，默认会自动构建，可以通过参数-debug --release --nobuild控制此行为
platforms/android/cordova/run --emulator --nobuild

#通过Eclipse部署
#也可以在Eclipse中，Run As - Android Application方式部署应用



###  部署到真实设备  ###

#Apache Cordova CLI方式
cordova run android

#Android平台命令行工具
platforms/android/cordova/run --device



###  其他Android平台命令行工具  ###
platforms/android/cordova/log    #记录APP详细的运行日志
platforms/android/cordova/clean  #清理工程文件

使用Android命令行build、run时，可以通过

--buildConfig

{
     "android": {
         "debug": {
             "keystore": "android.keystore",
             "storePassword": "android",
             "alias": "mykey1", 
             "password" : "password",
             "keystoreType": ""
         },
         "release": {
             "keystore": "android.keystore",
             "storePassword": "", //Release的密码可以不写，等待命令行提示
             "alias": "mykey2",
             "password" : "password",
             "keystoreType": ""
         }
     }
 }

自4.0开始Gradle是Cordova默认的构建工具。

下表列出Cordova提供的Gradle工程属性，可以用于定制构建： 

storeFile=relative/path/to/keystore.p12
storePassword=SECRET1
storeType=pkcs12
keyAlias=DebugSigningKey
keyPassword=SECRET2
#密码是可选的，如果不提供，构建时会进行交互式的提示

如果需要扩展Gradle构建逻辑，可以创建一个

build-extras.gradle

build.gradle

# 此文件的内容被放在build.gradle的开始处

# 设置工程扩展属性
ext.cdvDebugSigningPropertiesFile = 'android-debug-keys.properties'

# 这里指定的闭包，会在build.gradle结尾处执行， 因为build.gradle的最后包含如下代码：
# if (hasProperty('postBuildExtras')) {
#     postBuildExtras()
# }
ext.postBuildExtras = {
    android.buildTypes.debug.applicationIdSuffix = '.debug'
}

有两种方式来打包Cordova应用，并部署到Android设备或者模拟器上测试：

1. 使用Maven：

   package android:deploy android:run

    
2. 使用ADT：在apk工程上面点击右键 Run As ⇨ Android Application

注意，必须让你的设备或者模拟器链接到当前机器上。

这两种方式都比较慢，每次部署都需要数十秒，非常浪费时间。因此可以使用PhoneGap提供的设备端工具，该工具可以免部署的运行Cordova应用。

应用启动后，会自动启用一个WebView，加载config.xml中指定的起始页（默认index.html），让HTML页面占据整个屏幕空间。

例如，对Android平台，系统会执行MainActivity，该Activity是CordovaActivity的子类：

public class MainActivity extends CordovaActivity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        // 加载HTML
        loadUrl(launchUrl);
    }
}

<!DOCTYPE html>
<html>
    <head>
        <!-- 内容安全策略 -->
        <meta http-equiv="Content-Security-Policy" 
            content="default-src 'self' data: gap: https://ssl.gstatic.com 'unsafe-eval'; 
                     style-src 'self' 'unsafe-inline'; 
                     media-src *">
        <!-- 禁止IOS的电话号码识别 -->
        <meta name="format-detection" content="telephone=no">
        <!-- 禁止Windows Phone 8+的触碰时高亮 -->
        <meta name="msapplication-tap-highlight" content="no">
        <!-- WARNING: for iOS 7, remove the width=device-width and height=device-height attributes -->
        <!-- 
            视口元标签：指定应用程序占用屏幕的多大空间，以及应用程序如何缩放（zoom） 
            minimum-scale、maximum-scale 最小/最大缩放比率 initial-scale 为初始缩放比率
            user-scalable 是否允许用户缩放
            width、height 界面的宽高
        -->
        <meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width">
        <link rel="stylesheet" type="text/css" href="css/index.css">
        <title>Hello World</title>
    </head>
    <body>
        <div class="app">
            <h1>Apache Cordova</h1>
            <div id="deviceready" class="blink">
                <p class="event listening">Connecting to Device</p>
                <p class="event received">Emulater is Ready</p>
            </div>
        </div>
        <!-- 
            该JS是 Apache Cordova 提供的，用于访问设备硬件（例如摄像头、GPS）的JavaScript API
            该JS只是一个占位符，没有对应的文件。该脚本在运行时由PhoneGap Developer App注入；或者在构建时由Cordova CLI注入
        -->
        <script type="text/javascript" src="cordova.js"></script>
        <script type="text/javascript" src="js/index.js"></script>
    </body>
</html>

var app = {
    // 程序入口点
    initialize: function() {
        this.bindEvents();
    },
    // 绑定事件监听器，例如'load', 'deviceready', 'offline',  'online'
    bindEvents: function() {
        document.addEventListener('deviceready', this.onDeviceReady, false);
    },
    //事件deviceready是Cordova专有的，该事件发生后，Cordova提供的设备API加载完毕并可用
    onDeviceReady: function() {
        app.receivedEvent('deviceready');
    },
    // 修改DOM内容
    receivedEvent: function(id) {
        var parentElement = document.getElementById(id);
        var listeningElement = parentElement.querySelector('.listening');
        var receivedElement = parentElement.querySelector('.received');

        listeningElement.setAttribute('style', 'display:none;');
        receivedElement.setAttribute('style', 'display:block;');

        console.log('Received Event: ' + id);
    }
};

app.initialize();

Cordova应该是基于单页面应用设计的。所谓单页面应用，是指不存在URL导航的Web应用。单页面引用仅在最初加载一次页面，后续的更新通过JavaScript、Ajax完成。

单页面应用有利于增强移动应用的性能，因为避免了重复加载各种资产文件（脚本、图片）。单页面应用对Cordova有额外的好处，因为Cordova应用必须等待deviceready事件，URL导航导致重复的事件等待。

Cordova开发者往往错误的假设，移动设备能够达到和桌面应用一样性能。实际上，尽管移动设备已经长足发展了近十年，在电池、性能方面，仍然无法和桌面应用比较。注意以下几个方面：

1. click vs touch：click事件被大量误用。大部分移动设备添加300ms的延迟，用以区分touch和touch hold。使用touchstart、touchend可能有很大的性能改善——避免频繁的UI更新和其它行为
2. CSS 变换 vs DOM操控：硬件加速的CSS变换比起基于JavaScript的动画，性能有极大的优势
3. 网络延迟：尽量使用Cordova支持的本地存储机制，避免反复通过网络获取数据、资源

使用Cordova提供的offline、online事件的支持，你可以识别出离线状态，并正确的响应用户。注意，这两种事件并不是非常可靠，有时候你应当使用Ajax来判断设备是否真正的断开网络了。

注意：苹果的商店拒绝不能正确处理离线状态的APP上架。

有几种存储方案可以供Apache Cordova应用使用：

1. LocalStorage：同步的基于键值对的存储
2. WebSQL：基于SQL语句的API，支持Android、iOS
3. IndexedDB：支持Windows 8、Windows Phone 8
4. cordova-plugin-file插件：缓存数据到本地文件系统

测试Cordova应用时，你可以使用真实设备、模拟器，甚至是桌面浏览器。但是，在多种真实设备上测试是很有必要的： 

1. 模拟器（Simulator）不能模拟一些真实存在的情况：例如低电池时，应用会出现某个问题，这个问题在模拟器上难以体现
2. 模拟器（Emulator）和真实设备的行为存在不一致：某些模拟器会导致页面显示混乱，但是在真实设备上没有这种问题。4.1.2的AVD，运行5.4版本Cordova的HelloWorld应用，就存在页面显示混乱的情况。你可能需要禁用Host GPU加速
3. Simulator往往比真实设备快很多，而Emulator则慢很多
4. 在不同OS的设备上测试是有必要的，应用的行为可能不符合预期

使用PGDA可以避免编译、打包、部署到设备的繁冗步骤，在开发阶段能够节约很多时间。

使用XCode可以调试Cordova应用Native的那一部分。

使用Safari的web inspector，你可以Debug Webview和Cordova应用的JavaScript代码，仅支持OS X和iOS6+。通过OS X中的Safari连接到设备（或模拟器），可以使用Safari的dev tools调试Cordova应用。

与Safari类似，Chrome Dev Tools也可以用来调试Cordova应用。需要Android 4.4、API 19+、Chrome 30+才可以进行调试。使用WebKit proxy，Chrome Dev Tools也可以调试iOS应用。

Ripple是一个基于Web的移动设备环境模拟器，用于快速开发基于Apache Cordova、Blackberry WebWorks等框架的移动Web应用。

综合性的移动应用调试工具，支持在现代移动设备（iOS、Android）上调试混合应用，对PhoneGap、Cordova提供非常好的支持。

该工具实质上是对Chrome Dev Tools的包装和增强。

具体参见：使用GapDebug调试Phonegap应用

除非特别说明所有事件均在

document

document.addEventListener("deviceready", onDeviceReady, false);
function onDeviceReady() {
    // 现在可以安全的使用Cordova设备API了
}

document.addEventListener("resume", onResume, false);
function onResume() {
   setTimeout(function() {
       alert(1);
   }, 0);
}

Cordova自带了一个最小化的API集合，工程可以通过插件添加额外的API。本节介绍Cordova核心插件的API。

本节中，使用样式区分不同的API类型：

1. 斜体：表示静态（static）成员
2. 下划线标注：类型定义（typedef）
3. 括号后缀：表示方法/函数

提供三个电池相关的事件，如上节所述

该插件定义了一个全局的

navigator.camera

camera.getPicture(
    onSuccess successCallback, 
    onError errorCallback, 
    CameraOptions options
)

options.sourceType == Camera.PictureSourceType.

successCallback

options.destinationType == Camera.DestinationType.

该插件确保

console.log()

console

位于Cordova工程根目录的配置文件config.xml，可以在全局上控制Cordova应用程序的行为：

1. 指定核心Cordova API特性
2. 启用Cordova插件
3. 进行平台相关的设置

config.xml指定的配置会影响所有应用程序和CordovaWebView实例。

当使用Cordova的命令行接口（CLI）构建工程时，该文件会被修改并拷贝到各平台的对应目录，例如

platforms/ios/AppName/config.xml

<?xml version='1.0' encoding='utf-8'?>
<!-- widget元素： id 当前应用程序的唯一标识，通常是域名倒写，在Android中对应了包名 version 主版本.次版本.补丁版本 -->
<widget id="cc.gmem.study.cordova" version="0.0.1" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0">
    <!-- 应用程序的正式名称，该名称会出现在设备的主屏幕，以及应用商店 -->
    <name>CordovaStudy</name>
    <!-- 应用程序描述和作者信息，会显示在应用商店 -->
    <description>
        A sample Apache Cordova application that responds to the deviceready event.
    </description>
    <author email="dev@cordova.apache.org" href="http://cordova.io">
        Apache Cordova Team
    </author>
    <!-- 指定应用的起始网页 -->
    <content src="index.html" />
    <!-- 指定应用使用的Cordova插件 -->
    <plugin name="cordova-plugin-whitelist" spec="1" />
    <!-- 指定应用可以和哪些外部域名进行交互，默认值允许与任何外部服务交互 -->
    <access origin="*" />
    <!-- Intent白名单 -->
    <allow-intent href="http://*/*" />
    <allow-intent href="https://*/*" />
    <allow-intent href="tel:*" />
    <allow-intent href="sms:*" />
    <allow-intent href="mailto:*" />
    <allow-intent href="geo:*" />
    <!-- platform元素只会拷贝到对应平台下的config.xml中 -->
    <platform name="android">
        <allow-intent href="market:*" />
        <!-- 平台特定的方向设置 -->
        <preference name="Orientation" value="sensorLandscape" />
    </platform>
    <platform name="ios">
        <allow-intent href="itms:*" />
        <allow-intent href="itms-apps:*" />
        <!-- IOS：同时设置portrait、landscape模式 -->
        <preference name="Orientation" value="all" />
    </platform>
    <!-- 以键值对的形式定义若干选项，键大小写不敏感 -->
    <preference>
        <!-- 是否隐藏设备顶部的状态栏 -->
        <preference name="Fullscreen" value="false" />
        <!-- 支持Android、IOS。是否禁止拖拽滚动超过顶部或者底部，如果不需要“下拉以刷新”之类的功能，可以禁止 -->
        <preference name="DisallowOverscroll" value="false" />
        <!-- 支持Android、Blackberry。应用的背景色 -->
        <preference name="BackgroundColor" value="0xff0000ff" />
        <!-- 支持Blackberry。隐藏键盘上方额外的工具栏 -->
        <preference name="HideKeyboardFormAccessoryBar" value="false" />
        <!-- 锁定方向，禁止响应设备的转动。可选值landscape、portrait、default -->
        <preference name="Orientation" value="default" />
    </preference>
    <!-- 
        如果使用CLI，添加的插件不会反应到feature元素，但是如果使用针对特定平台的config.xml，
        可以设置feature元素，以启用设备级别的API或者外部插件
    -->
    <!-- 在Android平台上启用Device API -->
    <feature name="Device">
        <param name="android-package" value="org.apache.cordova.device.Device" />
    </feature>
    <!-- 在IOS平台上启用Device API -->
    <feature name="Device">
        <param name="ios-package" value="CDVDevice" />
    </feature>
    <!-- 添加钩子，以扩展Cordova的功能 -->
    <hook type="after_plugin_install" src="scripts/afterPluginInstall.js" />
    
    <!-- 指定应用程序图标，platform/width/height/density都是可选的，density为Android专有 -->
    <icon src="res/ios/icon.png" platform="ios" width="57" height="57" density="mdpi" />
    <!-- 可以采用平台专有的方式指定图标 -->
    <platform name="android">
        <icon src="res/android/ldpi.png" density="ldpi" />
        <icon src="res/android/mdpi.png" density="mdpi" />
        <icon src="res/android/hdpi.png" density="hdpi" />
        <icon src="res/android/xhdpi.png" density="xhdpi" />
     </platform>
     <platform name="ios">
        <!-- iOS 8.0+ -->
        <!-- iPhone 6 Plus  -->
        <icon src="res/ios/icon-60@3x.png" width="180" height="180" />
        <!-- iOS 7.0+ -->
        <!-- iPhone / iPod Touch  -->
        <icon src="res/ios/icon-60.png" width="60" height="60" />
        <icon src="res/ios/icon-60@2x.png" width="120" height="120" />
        <!-- iPad -->
        <icon src="res/ios/icon-76.png" width="76" height="76" />
        <icon src="res/ios/icon-76@2x.png" width="152" height="152" />
        <!-- iOS 6.1 -->
        <!-- Spotlight Icon -->
        <icon src="res/ios/icon-40.png" width="40" height="40" />
        <icon src="res/ios/icon-40@2x.png" width="80" height="80" />
        <!-- iPhone / iPod Touch -->
        <icon src="res/ios/icon.png" width="57" height="57" />
        <icon src="res/ios/icon@2x.png" width="114" height="114" />
        <!-- iPad -->
        <icon src="res/ios/icon-72.png" width="72" height="72" />
        <icon src="res/ios/icon-72@2x.png" width="144" height="144" />
        <!-- iPhone Spotlight and Settings Icon -->
        <icon src="res/ios/icon-small.png" width="29" height="29" />
        <icon src="res/ios/icon-small@2x.png" width="58" height="58" />
        <!-- iPad Spotlight and Settings Icon -->
        <icon src="res/ios/icon-50.png" width="50" height="50" />
        <icon src="res/ios/icon-50@2x.png" width="100" height="100" />
     </platform>
     
     <!-- 指定启动画面，也可用使用Splashscreen插件，动态编程控制 -->
     <platform name="android">
        <!-- you can use any density that exists in the Android project -->
        <splash src="res/screen/android/splash-land-hdpi.png" density="land-hdpi"/>
        <splash src="res/screen/android/splash-land-ldpi.png" density="land-ldpi"/>
        <splash src="res/screen/android/splash-land-mdpi.png" density="land-mdpi"/>
        <splash src="res/screen/android/splash-land-xhdpi.png" density="land-xhdpi"/>

        <splash src="res/screen/android/splash-port-hdpi.png" density="port-hdpi"/>
        <splash src="res/screen/android/splash-port-ldpi.png" density="port-ldpi"/>
        <splash src="res/screen/android/splash-port-mdpi.png" density="port-mdpi"/>
        <splash src="res/screen/android/splash-port-xhdpi.png" density="port-xhdpi"/>
    </platform>

    <platform name="ios">
        <!-- images are determined by width and height. The following are supported -->
        <splash src="res/screen/ios/Default~iphone.png" width="320" height="480"/>
        <splash src="res/screen/ios/Default@2x~iphone.png" width="640" height="960"/>
        <splash src="res/screen/ios/Default-Portrait~ipad.png" width="768" height="1024"/>
        <splash src="res/screen/ios/Default-Portrait@2x~ipad.png" width="1536" height="2048"/>
        <splash src="res/screen/ios/Default-Landscape~ipad.png" width="1024" height="768"/>
        <splash src="res/screen/ios/Default-Landscape@2x~ipad.png" width="2048" height="1536"/>
        <splash src="res/screen/ios/Default-568h@2x~iphone.png" width="640" height="1136"/>
        <splash src="res/screen/ios/Default-667h.png" width="750" height="1334"/>
        <splash src="res/screen/ios/Default-736h.png" width="1242" height="2208"/>
        <splash src="res/screen/ios/Default-Landscape-736h.png" width="2208" height="1242"/>
    </platform>
</widget>

<!-- 
    应用程序是否保持后台运行，甚至在pause事件发生之后 
    设置为fasle不会在pause事件后终止应用，而是仅仅当应用位于后台时，暂停CordovaWebView中代码的执行
-->
<preference name="KeepRunning" value="true"/>
<!-- 加载页面超时的毫秒数 -->
<preference name="LoadUrlTimeoutValue" value="20000"/>
<!-- 启动屏幕，位于res/drawable-*中的资源名称，不带扩展名 -->
<preference name="SplashScreen" value="splash"/>
<!-- 启动屏幕图片显示的毫秒数 -->
<preference name="SplashScreenDelay" value="3000"/>
<!-- 控制通过InAppBrowser打开的页面，是否可以和通过默认浏览器打开的页面访问同一localStorage和WebSQL -->
<preference name="InAppBrowserStorageEnabled" value="true"/>
<!-- 默认为null，如果设置，那么在加载第一个页面时，显示指定的标题、消息以及一个spinner。标题和消息使用逗号分隔 -->
<preference name="LoadingDialog" value="My Title,My Message"/>
<!-- 默认为null，与上一个配置类似，但是用于除了第一个页面的所有其它页面 -->
<preference name="LoadingPageDialog" value="My Title,My Message"/>
<!-- 默认为null，出错时显示的页面 -->
<preference name="ErrorUrl" value="myErrorPage.html"/>
<!-- 是否在屏幕顶部显示标题 -->
<preference name="ShowTitle" value="false"/>
<!-- 设置应用的日志级别：ERROR, WARN, INFO, DEBUG, VERBOSE -->
<preference name="LogLevel" value="ERROR"/>
<!-- 设置Activity的android:launchMode属性 -->
<preference name="AndroidLaunchMode" value="singleTop"/>
<!-- 设置User Agent，默认不设置 -->
<preference name="OverrideUserAgent" value="Mozilla/5.0 My Browser" />

从Cordova4.3开始，支持保存（save ）、恢复（restore ）平台支持版本、插件版本信息。

当使用

--save

cordova platform

cordova plugin

cordova prepare

执行下面的命令，即可保存特定版本的平台：

# 命令格式
cordova platform add <platform[@<version>] | directory | git_url> --save
# 命令举例
cordova platform add android --save
cordova platform add android@3.7.0 --save    #后续不带@version添加平台，自动使用 3.7.0版本
cordova platform add android@https://github.com/apache/cordova-android.git​ --save
cordova platform add C:/path/to/android/platform --save

# 保存所有平台的版本
cordova platform save

运行此命令后，config.xml中出现类似下面的条目：

<engine name="android" spec="~4.0.0" />

执行下面的命令，可以更新特定平台的版本： 

# 命令格式
cordova platform update <platform[@<version>] | directory | git_url> --save

# 命令举例
cordova platform update android --save
cordova platform update android@3.8.0 --save
cordova platform update /path/to/android/platform --save

执行下面的命令，即可保存插件版本到config.xml：

# 命令格式
cordova plugin add <plugin[@<version>] | directory | git_url> --save

# 命令举例
cordova plugin add cordova-plugin-console --save
cordova plugin add cordova-plugin-console@0.2.13 --save     #后续不带@version添加此插件，自动使用0.2.13版本
cordova plugin add https://github.com/apache/cordova-plugin-console.git --save
cordova plugin add C:/path/to/console/plugin --save

# 保存所有插件的版本
cordova plugin save

运行此命令后，config.xml中出现类似下面的条目：

<plugin name="cordova-plugin-console" spec="~1.0.0" />

执行下面的命令，可以更新特定插件的版本： 

# 命令格式
cordova plugin update <plugin[@<version>] | directory | git_url> --save

# 命令举例
cordova plugin update cordova-plugin-console --save
cordova plugin update cordova-plugin-console@0.2.13 --save
cordova plugin update /path/to/console/plugin --save

移动应用的隐私问题是每个移动App都需要关注的内容，用户需要它们的私人信息被合理使用，并不泄漏。下面是一些被广泛接受的建议：

1. 隐私策略（Privacy Policy）：使用平白的语言声明你的App的隐私策略
2. 敏感信息的收集：在获取敏感信息，例如通讯录、地理位置、摄像机信息前，获得用户的许可
3. 与第三方共享敏感信息：如果你的App获取的信息需要与第三方网站/应用共享，应当获得用户许可
4. 仅在必要的时候才收集隐私信息

本节包含一些开发Cordova应用时，处理安全问题的最佳实践。

1. 不要使用自签名的网站证书：如果你的服务器使用SSL，务必使用知名CA签发的数字证书
2. 避免使用IFrame引用外部网页（不受你控制的第三方网站）：位于白名单中的网页，如果运行在IFrame中，它是可以访问Native Cordova Bridge的。引用外部链接，最好使用InAppBrowser，外部链接不会有机会执行Cordova API
3. 关于域名白名单：Android API 10以下、WP8中的IFrame和XMLHttpRequest，都不受域名白名单控制，这意味着任何网页都可以调用Cordova接口
4. 不要缓存敏感信息，例如用户名、密码
5. 避免使用

   eval()

    ，除非你确切知道脚本的内容

域名白名单（Domain whitelisting）机制用来控制Cordova应用对外部域名的访问。默认的，新创建的App被允许访问所有外部域名，在产品发布时，你必须确定需要访问哪些域名，并进行白名单配置。

对于Android和iOS，上述安全策略通过插件cordova-plugin-whitelist实现，具有更好的安全性和可配置性，推荐使用：

<!-- 
    导航白名单（Navigation Whitelist）
    控制WebView可以被导航到那些URL，仅应用到顶级导航 
-->
<!-- 允许连接到google.com-->
<allow-navigation href="http://google.com/*" />
<!-- 允许使用HTTP/HTTPS或者其它任何协议连接到google.com的所有子域 -->
<allow-navigation href="*://*.google.com/*" />
<!-- 允许导航到任意网站-->
<allow-navigation href="*" />
<!-- 上面一条等价于这三条：-->
<allow-navigation href="http://*/*" />
<allow-navigation href="https://*/*" />
<allow-navigation href="data:*" />


<!-- 
    Intent白名单（Intent Whitelist）
    控制App可以要求系统打开哪些URL，默认任何URL都不允许 
-->
<!-- 允许在一个浏览器窗口中打开网页 -->
<allow-intent href="http://*/*" />
<allow-intent href="https://*/*" />
<allow-intent href="http://google.com/*" />
<allow-intent href="*://*.example.com/*" />
<!-- 允许在短信应用中打开SMS链接 -->
<allow-intent href="sms:*" />
<!-- 允许拨打电话 -->
<allow-intent href="tel:*" />
<!-- 允许打开地图 -->
<allow-intent href="geo:*" />
<!-- 允许使用对应的App打开所有其它类型的URL -->
<allow-intent href="*" />


<!-- 
    网络请求白名单（Network Request Whitelist）
    控制哪些网络请求被允许：Ajax、images等
    注意，最好使用Content Security Policy（CSP），CSP更安全。这节的配置主要用于不支持CSP的老旧Webview
    默认Android允许访问https://ssl.gstatic.com/accessibility/javascript/android/，这确保TalkBack正常工作
-->
<!-- 允许对google.com执行Ajax、图片请求 -->
<access origin="http://*.google.com" />
<!-- 允许针对content URL的请求 -->
<access origin="content:///*" />
<!-- 允许任何请求 -->
<access origin="*" />

对于其它平台，Cordova应用依赖于config.xml中的

<access>

<!-- 允许访问google.com -->
<access origin="http://google.com" />
<!-- 允许访问HTTPS版本的google.com -->
<access origin="https://google.com" />
<!-- 允许访问maps.google.com -->
<access origin="http://maps.google.com" />
<!-- 允许访问google.com的所有子域名 -->
<access origin="http://*.google.com" />
<!-- 允许访问所有网站 -->
<access origin="*" />

参见：HTML知识集锦

CSP用于控制图片、Ajax、

<video>

<meta>

<!-- 较为安全的默认值 -->
<meta http-equiv="Content-Security-Policy"
    content="default-src 'self' data: gap: https://ssl.gstatic.com; style-src 'self' 'unsafe-inline'; media-src *">

<!-- 允许同源和google.com的所有内容-->
<meta http-equiv="Content-Security-Policy" content="default-src 'self' google.com">

<!-- 
    允许所有内容，除了：
    对于CSS，仅允许同源的CSS文件，以及内联的样式
    对于脚本，仅允许同源的JS文件，内联的JavaScript脚本，以及eval()
-->
<meta http-equiv="Content-Security-Policy"
    content="default-src *; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' 'unsafe-eval'">

<!-- 仅允许同源的、通过HTTPS的Ajax请求 -->
<meta http-equiv="Content-Security-Policy" content="default-src 'self' https:">

<!-- 允许来自google.com的IFrame -->
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; frame-src 'self' https://google.com">

钩子是Cordova Application、Plugin添加的特殊脚本，用于定制化Cordova的命令。可以在hooks目录添加钩子，也可以在config.xml、plugin.xml中声明钩子。钩子按照下面的顺序串行执行：

1. 来自/hooks目录的Application钩子
2. 来自config.xml的Application钩子
3. 来自plugins/.../plugin.xml的插件钩子

目前支持的钩子类型有：

1. after_build
2. after_compile
3. after_clean
4. after_docs
5. after_emulate
6. after_platform_add
7. after_platform_rm
8. after_platform_ls
9. after_plugin_add
10. after_plugin_ls
11. after_plugin_rm
12. after_plugin_search
13. after_plugin_install  仅执行被安装插件声明在plugin.xml中的钩子
14. after_prepare
15. after_run
16. after_serve
17. before_build
18. before_clean
19. before_compile
20. before_docs
21. before_emulate
22. before_platform_add
23. before_platform_rm
24. before_platform_ls
25. before_plugin_add
26. before_plugin_ls
27. before_plugin_rm
28. before_plugin_search
29. before_plugin_install  仅执行被安装插件声明在plugin.xml中的钩子
30. before_plugin_uninstall  仅执行被卸载插件声明在plugin.xml中的钩子
31. before_prepare
32. before_run
33. before_serve
34. pre_package 仅支持Windows、Windows Phone平台

如果把钩子存放在hooks目录，必须遵从严格的命名规定：

hooks/钩子类型/脚本文件.js

hooks/after_prepare/cordova-syncdown.js

在config.xml、plugin.xml中声明钩子的方式如下：

<hook type="before_build" src="scripts/appBeforeBuild.bat" />
<hook type="before_build" src="scripts/appBeforeBuild.js" />
<hook type="before_plugin_install" src="scripts/appBeforePluginInstall.js" />

一般使用NodeJS来编写钩子，Node模块定义的方式如下：

module.exports = function( ctx )
{
}

其中ctx包含很多上下文信息： 

{
  "hook": "after_prepare",
  "scriptLocation": "after_prepare/script.js",
  "cmdLine": "/path/to/cordova arguments",
  "opts": {
    "projectRoot":"/path/to/project",
    "cordova": {
      "platforms": ["android"],
      "plugins": ["com.plugin.withhooks"],
      "version": "0.21.7-dev"
    },
    "plugin": {
      "id": "com.plugin.withhooks",
      "pluginInfo": {
        ...
      },
      "platform": "android",
      "dir": "/path/to/project/plugins/com.plugin.withhooks"
    }
  },
  "cordova": {} //cordova object
}

修改$CORDOVA_PROJECT_ROOT/platforms/android/cordova/lib/build.js 中如下变量的值：

var distributionUrl = 'distributionUrl=../../../gradle-2.2.1-all.zip';

然后，把本地磁盘的 gradle-2.2.1-all.zip拷贝或者链接到$CORDOVA_PROJECT_ROOT/platforms 即可。执行

cordova prepare

让Gradle使用本地Maven仓库中的构件，避免不必要的下载动作

修改$CORDOVA_PROJECT_ROOT/platforms/android/build.gradle中的内容：

repositories {
    mavenLocal()
    //添加上面一行的内容
    mavenCentral()
}

The post 基于Apache Cordova开发移动应用程序 appeared first on 绿色记忆.

ANDROID_HOME=/home/alex/Android/Sdk
PATH=$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools:$PATH

# 安装必要的软件
sudo apt-get install qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils
# 添加当前用户到组
sudo adduser alex kvm
sudo adduser alex libvirtd

# 启动AVD管理器，新建模拟器，注意一定要选择Atom的镜像
android avd

Android Studio（包括Jetbrains、WebStorms等IDE），在Ubuntu下字体渲染过于单薄，可以使用修改过的Open JDK：

# 可选启用HUD
sudo add-apt-repository ppa:danjaredg/jayatana
sudo apt-get update
sudo apt-get install jayatana
# 安装带Font fix的JDK版本
sudo add-apt-repository ppa:no1wantdthisname/openjdk-fontfix
sudo apt-get update
sudo apt-get install openjdk-7-jdk

修改Jetbrains的启动脚本，设置上面安装的Open JDK为JAVA_HOME，并设置以下JVM参数：

-Dawt.useSystemAAFontSettings=lcd
-Dswing.aatext=true
-Dsun.java2d.xrender=true
-Dsun.java2d.pmoffscreen=false

下面是.desktop文件的示例：

[Desktop Entry]
Encoding=UTF-8
Version=1.0
Type=Application
Name=Android Studio
Icon=jetbrains-studio.png
Path=/home/alex
Exec=/usr/lib/jvm/java-1.7.0-openjdk-amd64/bin/java -Xbootclasspath/a:/home/alex/Android/ide/as/1.5/bin/../lib/boot.jar -classpath /home/alex/Android/ide/as/1.5/bin/../lib/bootstrap.jar:/home/alex/Android/ide/as/1.5/bin/../lib/extensions.jar:/home/alex/Android/ide/as/1.5/bin/../lib/util.jar:/home/alex/Android/ide/as/1.5/bin/../lib/jdom.jar:/home/alex/Android/ide/as/1.5/bin/../lib/log4j.jar:/home/alex/Android/ide/as/1.5/bin/../lib/trove4j.jar:/home/alex/Android/ide/as/1.5/bin/../lib/jna.jar:/usr/lib/jvm/java-1.7.0-openjdk-amd64/lib/tools.jar -Xms256m -Xmx1280m -XX:MaxPermSize=350m -XX:ReservedCodeCacheSize=225m -XX:+UseConcMarkSweepGC -XX:SoftRefLRUPolicyMSPerMB=50 -da -Djna.nosys=true -Djna.boot.library.path= -Djna.debug_load=true -Djna.debug_load.jna=true -Dsun.io.useCanonCaches=false -Djava.net.preferIPv4Stack=true  -Dawt.useSystemAAFontSettings=lcd -Dswing.aatext=true -Dsun.java2d.xrender=true -Dsun.java2d.pmoffscreen=false -Djb.vmOptionsFile=/home/alex/Android/ide/as/1.5/bin/studio64.vmoptions -XX:ErrorFile=/home/alex/java_error_in_STUDIO_%p.log -Djb.restart.code=88 -Didea.paths.selector=AndroidStudio1.5 -Didea.platform.prefix=AndroidStudio com.intellij.idea.Main
StartupNotify=false
StartupWMClass=jetbrains-studio
OnlyShowIn=Unity;
X-UnityGenerated=true

The post Android Studio知识集锦 appeared first on 绿色记忆.

Gradle是近年来流行起来的自动化构建工具，它具有以下特性：

1. 灵活、通用的构建功能，类似Ant
2. 基于约定的构建框架，类似Maven
3. 强大的多工程构建支持
4. 支持基于Apache Ivy的依赖管理，现已使用Gradle自己的依赖处理引擎（dependency resolution engine）
5. 完整的支持既有的Maven或者Ivy构件仓库，且不需要pom.xml或者ivy.xml就可以进行依赖管理
6. 整合型构建工具：
   1. 支持Ant任务，Gradle可以直接引入Ant工程，并在运行时将Ant targets转换为Gradle tasks
   2. 可以自动的把Maven的pom.xml转换为Gradle脚本
7. 基于Groovy的构建脚本。构建脚本可以很容易的维护和重用
8. 用于描述构建的丰富的领域模型
9. Gradle Wrapper：运行在没有安装Gradle的机器上运行Gradle构建

Gradle的核心是一个基于Groovy的、扩展的DSL（Domain Specific Language），而不是向Maven、Ant那样，通过XML去描述构建步骤，具有非常好的灵活性。

1. Gradle Daemon性能增强，让构建速度最快有75%的提升，默认启用
2. 更好的IDE支持
3. 改进并行任务执行
4. 初步的Java 9支持
5. 新的plugins DSL，用于启用插件，代替原先的

   apply plugin

   ：
   

   plugins {
       id 'my.special.plugin' version '1.0' apply false
   } 

6. 改进增量构建
7. 更快的依赖解析
8. 改进eclipse-wtp插件
9. 插件库升级

1. 支持依赖的并行下载
2. 改进构建缓存
3. 添加Google的Maven仓库的快捷方式：
   

   repositories {
       google()
   }

4. 支持使用Gradle属性来配置日志级别，属性名org.gradle.logging.level，支持的值：quiet, warn, lifecycle, info, debug，默认lifecycle

5. 对删除文件的Task进行更好的建模。一个Task可以使用 @Destroys 注解，明确声明自己会删除文件：

   class RemoveTempDirs extends DefaultTask {
       @Destroys
       FileCollection tempDirs
   
       @TaskAction
       void removeDirs() {
           project.delete(tempDirs)
       }
   } 

1. 更快的构建速度
2. 更细粒度的传递性依赖管理
3. 内存使用更高效
4. 新的Gradle调用选项
5. 新的Task/Plugin API

即Gradle Wrapper，是一段脚本，此脚本调用你声明的版本的Gradle，如果目标版本不存在，则从网络上下载。

使用gradlew可以保证构建过程的一致性，但是网络差的话你就得静静的等待下载完成。

要生成gradlew相关的文件，需要本机已经安装任意版本的Gradle。执行命令

gradle wrapper

生成的gradlew文件包括：

1. gradle/wrapper/gradle-wrapper.properties 配置文件
2. gradle/wrapper/gradle-wrapper.jar 包含用于下载Gradle发行版的代码
3. gradlew, gradlew.bat Shell脚本和Windows批处理脚本

#Tue Jun 25 10:21:26 CST 2019
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
# 从何处下载
# 后缀 -all 表示包含源码，-bin 表示不包含源码
distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip

如果下载缓慢，可以手工拷贝，存放到

~/.gradle/wrapper/dists

执行下面的命令升级到指定版本：

./gradlew wrapper --gradle-version 5.4.1

gradlew的命令行调用格式和gradle完全一致。 

1. 安装Gradle需要JDK/JRE，版本在6.0+。Gradle内置了Groovy库，因此后者不需要
2. 到官网下载Gradle，并解压到某个目录，该目录设置为环境变量

   GRADLE_HOME

    
3. 将

   $GRADLE_HOME/bin

    添加到环境变量PATH中
4. 打开终端，运行

   gradle -v

    验证安装是否成功

可以从Nodeclipse提供的Update Site：http://www.nodeclipse.org/updates/gradle-ide-pack/ 安装Gradle插件。

此站点中杂项内容非常多，可以根据需要，选择性的安装：

打开Window ⇨ Preferences ⇨ Gradle：

1. Gradle Distribution 点选 Folder，填写

   %GRADLE_HOME%

    对应的目录
2. Gradle User Home 点选 Directory，填写

   %USERPROFILE%\.gradle

    

打开Window ⇨ Preferences ⇨ Gradle ⇨ Arguments：

1. Java Home 点选Workspace JRE，选择一个已安装的JRE
2. 默认JVM参数可以根据需要调整

打开Window ⇨ Preferences ⇨ Gradle EnIDE：

1. Gradle Home to use：填写

   %GRADLE_HOME%

    对应的目录

打开Window ⇨ Preferences ⇨ Desktop Environment：

1. 点选 Custom Desktop Environment
2. Start Shell设置为Console2，例如

   D:\Programs\Console2\Console.exe -d ${resource_path}

    

打开File ⇨ New ⇨ Other，选择Gradle/Gradle Project，即可创建Gradle工程，Sample project选择Java Quickstart，点击完成。

初次创建Gradle IDE会去下载一些东西，完毕后，形成类似下面的工程结构：

可以看到，默认配置下Gradle沿用了Maven的工程目录习惯。除了把pom.xml换成build.gradle，Maven工程和Gradle工程的结构完全相同。

Eclipse工程结构和元数据完全根据build.gradle导出，这个和Maven也是类似的。工程根目录右键 ⇨ Gradle ⇨ Refresh All，可以根据当前的build.gradle更新Eclipse工程结构。

要构建Gradle工程，可以工程根目录右键 ⇨ Run As ⇨ Gradle Build。

命令格式：

//可以同时指定多个Task
gradle [option...] [task...]

用法示例：

# 依次调用 compile 和 test 任务
# 它们所依赖的任务会根据依赖图的顺序被依次调用，每个任务只会调用一次
# 只需要声明任务之间的依赖，不需要人工控制任务执行顺序，是相对于Maven的优势
gradle compile test

# 使用-x 排除某个任务
gradle dist -x test

# 默认情况下，一旦有一个任务失败，Gradle就会终止执行，下面的选项禁止此行为
gradle run --continue

# 简化任务名：不需要输入完整，只需要足够避免歧义的前缀
gradle ru
# 简化任务名：驼峰式首字母，下面的命令调用gradle compTest
gradle cT

# Gradle默认依据当前目录下的build.gradle，使用-b可以选择构建其它脚本
gradle -q -b subdir/myproject.gradle hello

# 使用-p，可以选择构建的目录
gradle -q -p subdir hello

# 获取子工程列表
gradle -q projects

# 列出工程中所有任务
gradle tasks
gradle -q tasks --all   #同时显示任务依赖关系

# 显示任务的详细信息
gradle help --task taskName

# 显示工程中所有依赖库的列表
gradle dependencies  #输出依据依赖配置（Dependencies Configuration）分组
# 显示api子工程的所有依赖列表
gradle -q dependencies api:dependencie
# 显示api子工程的、testCompile配置的所有依赖列表
gradle -q api:dependencies --configuration testCompile
# 显示某个特定依赖库的情况，显示groovy依赖库的情况
gradle -q api:dependencyInsight --dependency groovy --configuration compile

# 显示工程属性列表
gradle properties
gradle -q api:propertie #子工程属性列表

# 记录构建日志
gradle run --profile   # 日志存放到build/reports/profile 

# 以特定的工程属性来构建
gradle hello -PskipHello

# 设置JVM属性
gradle hello -Djava.io.tempdir=/tmp

# 丢弃已经编译的脚本缓存
gradle  --recompile--scripts 

# 显示图形界面
gradle --gui 

除了通过gradle命令行参数

-P

gradle.properties

gradlePropertiesProp=gradlePropertiesValue
# 对于根工程，可以设置JVM系统属性，这些属性以systemProp.开头
systemProp.system=systemValue

build.gradle

在当前目录下创建一个UTF-8编码的build.gradle文件，或者通过Eclipse创建一个Gradle工程。打开build.gradle文件，输入下面的内容：

//可以声明工程属性
description = 'Hello project'

//声明一个名为hello的task
//新任务默认是org.gradle.api.DefaultTask的实例
task hello {
    //闭包指定了hello的action
    doLast {
        println 'Hello world!'  //任何Groovy脚本都支持
    }
}

//上述任务也可以用下面的快捷声明方式
task hello << {
    println 'Hello world!'
}

然后，打开终端，pushd到当前目录，运行命令：

gradle -q hello

Hello world!

使用下面的脚本可以指定默认任务，这样，如果

gradle

defaultTasks 'hello', 'run'

对于构建中的每个工程，Gradle都创建了一个

org.gradle.api.Project

build.gradle

apply plugin: 'java'

println this.name     //当前对象——当前工程——的name属性
println name          //自动委托给当前对象
println project.name  //this.project == this，预定义属性
//上面三个语句打印一样的结果

除了上面的name以外，你还可以访问很多Project的属性，例如： 

Project包含很多常用的方法，可以在构建脚本中使用：

每个构建脚本都自动实现

org.gradle.api.Script

在构建脚本中，你可以声明两种变量：

1. 局部变量 ( local ) ：只在局部作用域可见，使用关键字

   def

    声明，例如：
   

   def dest = "dest"
   task copy(type: Copy) {
       form "source"
       into dest
   }

2. 扩展属性 ( extra )：Gradle领域模型中所有增强对象（包括但不限于：projects, tasks, source sets）都可以添加扩展属性，扩展属性在任何地方可见。使用ext脚本块可以同时声明多个属性。下面是一个示例：
   

   ext {
       //为Project添加属性
       springVersion = "3.1.0.RELEASE"
       emailNotification = "build@master.org"
   }
   //也可以这样写
   ext.springVersion = "3.1.0.RELEASE"
   springVersion = "3.1.2.RELEASE"  //声明以后再修改，不需要ext关键字
   
   //这样写会报错，自定义的外部属性，必须首先使用ext声明
   hibernateVersion = "3.6.10.Final"
   
   //设置所有源码集的purpose属性
   sourceSets.all { ext.purpose = null }
   
   sourceSets {
       //分别设置每个源码集的属性
       main {
           purpose = "production"
       }
       test {
           purpose = "test"
       }
       plugin {
           purpose = "production"
       }
   }
   
   task printProperties << {
       println springVersion
       println emailNotification
       sourceSets.matching { it.purpose == "production" }.each { println it.name }
   }

Gradle大量使用了Groovy提供的灵活语法特性和DSL支持。整个构建脚本都是合法的Groovy代码，虽然有时看起来更像是XML那样的配置文件：

//下面的脚本，更像是配置文件
dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile project(':shared')
}

实际上dependencies是Project对象的一个方法，它的签名如下：

public interface Project{
    void dependencies(Closure configureClosure);
}

可以看到，该方法的入参是一个闭包，我们可以把上面的脚本改写的更像C-Style的代码：

dependencies({
    //这里是闭包体，其包含了两个方法调用：
    compile( [ group: 'commons-collections', name: 'commons-collections', version: '3.2' ] )
    testCompile( project(':shared') )
    //那么，闭包里面调用的方法，是哪个对象的呢？是this也就是闭包本身吗？不是……
    //根据Groovy的规则，闭包里面的变量，其Scope由闭包的delegate属性指定，因此上面的调用实际上是：
    delegate.testCompile( project(':shared') )
    //delegate已经由Gradle自动设置为dependencies
})

我们还可以把上述脚本改写为等价的Java语句： 

Closure<Object> c = new Closure<Object>(){

    public Object call( Object... args ){
    
        assert delegate == project.dependencies
        
        Map<String,String> map = new HashMap<String,String>();
        map.put( 'group',   'commons-collections' );
        map.put( 'name',    'commons-collections' );
        map.put( 'version', '3.2' );
        delegate.compile( dep );
        
        delegate.testCompile( project(':shared') )
        
    }
}
c.delegate = project.dependencies
project.dependencies( c );

可以把其它脚本的内容包含到当前构建脚本中：

println "configuring $project"
task hello << {
    println' 'hello form other srcipt'
}

apply from: 'other.gradle'  //包含其它脚本

 其它脚本中定义的任务，可以直接使用：

gradle -q hello

依赖管理是任何一种构建工具的关键特性，Gradle提供了易于理解的、和Maven/Ivy兼容的依赖管理机制。Gradle的依赖管理具有以下特点：

1. 传递性依赖管理
2. 支持非受管的（non-managed）依赖：依赖可以仅仅是位于版本控制工具或者共享磁盘上的文件
3. 支持定制化的依赖定义：可以在构建脚本中描述依赖的层次
4. 完全可定制的依赖解析机制（Dependency Resolution）
5. 与Maven和Ivy完全兼容
6. 与既有的依赖管理工具，例如Maven和Ivy集成

依赖管理分为两部分的内容：

1. 依赖项（dependencies）：当前工程在构建或者运行时需要的东西
2. 发布项（publications）：当前工程的构建的产出，这些产出可能需要上传到仓库

对于依赖项，Gradle采用了类似Maven的方式进行声明，而不像Ant那样指定绝对路径。依赖项的所在位置（远程仓库或者本地目录）另外声明。对于发布项，行为依赖于配置，可能是发布到本地目录，或者远程仓库。

Gradle把依赖按照依赖配置（dependency configuration）分组。每个分组具有一个名称和若干其它属性，分组可以继承其它分组。某些插件会自动引入一些依赖配置，例如Java插件添加了：

除了插件自动引入的依赖配置以外，你还可以在构建脚本中自行添加。自定义依赖配置在很多情况下有用，例如添加一个既不在编译，也不在测试时需要的“运行时”依赖（典型的例子是JDBC驱动程序）到归档文件中。

下面示例了如何声明依赖配置：

configurations {
    compile {
        description = 'compile classpath'
        transitive = true //是否启用传递性依赖
    }
    runtime {
        extendsFrom compile
    }
}

每一个依赖项声明的格式为：

dependencies{
    // 依赖配置名称 依赖项规格说明
}

依赖项规格是什么形式取决于依赖的类型：

dependencies {
    //可以使用group name version字段来指定
    runtime group: 'hibernate', name: 'hibernate-core', version: '3.6.7'
    //也可以使用分号分隔的group:name:version指定
    runtime 'hibernate:hibernate-core:3.6.7','springframework:spring-aop:2.5'
    //可以控制传递性依赖
    runtime('hibernate:hibernate:3.0.5') {
        transitive = true
    }
    //仅构件标记（Artifact only notation），不去下载模块描述符（例如pom.xml），仅仅下载构件本身
    runtime "org.groovy:groovy:2.2.0@jar"
    //使用分类器字段
    otherConf group: 'test', name: 'service', version: '1.0', classifier: 'jdk14'
}

project(':shared')

dependencies {
    runtime files('libs/a.jar', 'libs/b.jar')
    runtime fileTree(dir: 'libs', include: '*.jar')
}

runtime module(group: 'org.apache.ant', name: 'ant', version: '1.9.4') {
    dependencies "org.apache.ant:ant-launcher:1.9.4@jar",
                     "org.apache.ant:ant-junit:1.9.4"
}

dependencies {
    compile gradleApi()
}

dependencies {
    compile localGroovy()
}

configurations {
    //为指定的依赖配置指定传递性依赖的排除规则
    compile.exclude module: 'commons'
    //为所有的依赖配置指定传递性依赖的排除规则
    all*.exclude group: 'org.gradle.test.excludes', module: 'reports'
}

dependencies {
    compile("org.gradle.test.excludes:api:1.0") {
        exclude module: 'shared' //为单个依赖项指定传递性依赖的排除规则
    }
}

Gradle必须知道从哪里下载外部依赖，这是由仓库配置来指定的：

repositories {
    //Maven本地仓库，寻找本地仓库的逻辑与Maven相同
    mavenLocal()
    //Maven中心仓库
    mavenCentral()
    //JCenter仓库
    jcenter()
    //其它Maven远程仓库
    maven {
        //可以指定身份验证信息
        credentials {
            username 'user'
            password 'password'
        }
        url "http://repo.mycompany.com/maven2"
        //如果上面的URL找不到构件，则在下面找
        artifactUrls "http://repo.mycompany.com/jars"
    }
    //Ivy远程仓库
    ivy {
        url "http://repo.mycompany.com/repo"
    }
    //Ivy本地仓库
    ivy {
        url "../local-repo"
    }
    //扁平布局的文件系统仓库
    flatDir {
        dirs 'lib'
    }
    flatDir {
        dirs 'lib1', 'lib2'
    }
}

除了可以发布到本地目录外，Gradle还支持发布构建的产出到Ivy、Maven仓库：

uploadArchives {
    repositories {
        //发布到扁平结构的目录
        flatDir {
            dirs 'repos'
        }
        //发布到Ivy仓库
		ivy {
		    credentials {
		        username "username"
		        password "pw"
		    }
		    url "http://repo.mycompany.com"
		}
		//发布到Maven仓库
		mavenDeployer {
            repository(url: "file://localhost/tmp/myRepo/")
        }
    }
}

 task关键字本质上是Project对象的一组方法：

Task task(String name) throws InvalidUserDataException
Task task(String name, Closure configureClosure)
Task task(Map<String,?> args, String name) throws InvalidUserDataException
Task task(Map<String,?> args, String name, Closure configureClosure)

 下面列举了不同风格的Task定义：

// 操作符“<<”被Task重载过，它接受一个闭包，该闭包可以对当前Task进行任意操作
// 直接使用不带引号的hello0，会被解释为this.hello0，Gradle可能进行了Groovy元编程，让不存在的变量指定作为当前project的属性看待

// 不带括号
task hello0 << {
    description 'Hello task'   // 可以给Task添加描述
    println "hello"
}
// 带括号
task(hello1) << {
    println "hello1"
}
// 任务名带引号
task('hello2') <<
{
    println "hello2"
}
//指定任务类型
task('copy', type: Copy) {
    //闭包的delegate是task对象，注意Gradle的这种风格，与上面章节dependencies中的闭包delegate指向是一个风格
    from(file('srcDir'))
    into(buildDir)
}
//这样也可以
tasks.create(name: 'hello') << {
    println "hello"
}

首先，任何Task都作为Project的属性看待：

task hello
//作为当前工程的属性来获得Task的引用
println hello.name
println project.hello.name

也可以通过

org.gradle.api.tasks.TaskContainer

task hello
//作为TaskContainer的属性访问
println tasks.hello.name
println tasks['hello'].name

project(':projectA') {
    task hello
}

//也可以调用getByPath()方法
//路径根部的:可以省略
println tasks.getByPath('hello').path  //:hello
println tasks.getByPath(':hello').path //:hello
println tasks.getByPath('projectA:hello').path  //:projectA:hello
println tasks.getByPath(':projectA:hello').path //:projectA:hello

 下面实例了指定Task的类型为

org.gradle.api.tasks.Copy

//Copy任务用来拷贝文件到目标目录中，支持过滤和重命名

//指定任务类型
task myCopy(type: Copy)

//同时设置属性
Copy myCopy = task(myCopy, type: Copy)
myCopy.from 'resources'
myCopy.into 'target'
myCopy.include('**/*.txt', '**/*.xml', '**/*.properties')

//闭包方式，再次注意闭包的delegate指向是当前task，delegate在Minimalist Gradle Editor中常常显示为关键字
task copy(type: Copy) {
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
}

//声明任务intro依赖于hello
task intro(dependsOn: 'hello') << { //如果被依赖任务在后面定义，则这里引用的任务名必须加引号
    println "I'm Gradle"
}
//被依赖的任务可以在后面定义
task hello << {
    println 'Hello world!'
}
//访问Task的方法也可以添加依赖
intro.dependsOn hello
//也可以通过闭包添加依赖
intro.dependsOn {
    tasks.findAll { task -> task.name.startsWith('lib') }
}

project('projectA') {
    //要依赖其它项目中的任务，必须指定任务的路径
    task taskX(dependsOn: ':projectB:taskY') << {
        println 'taskX'
    }
}
project('projectB') {
    task taskY << {
        println 'taskY'
    }
}

task copy(type: Copy)
task copy(overwrite: true) << { //必须设置overwrite为true
    println('I am the new one.')
}

Gradle提供几种方式，来绕过某个任务的执行： 

task hello << {
    println 'hello world'
//只有当工程没有属性“skipHello”的时候，才会执行hello
hello.onlyIf { !project.hasProperty('skipHello') }
//运行gradle hello -q -PskipHello 不会打印任何信息

//也可以使用StopExecutionException异常跳过任务
hello.doFirst{ //添加如下逻辑到Task最前面
     if (true) { throw new StopExecutionException() }
}

//还可以设置enabled属性，为false则不会执行
hello.enabled = false

Gradle判断任务是否已经是最新状态的依据是：如果任务的输入没有变化，那么当前任务不需要执行（也就是up-to-date）。更进一步说，Gradle的判断规则如下：

1. Task执行前，获得输入文件的散列值
2. Task执行完毕后，存储输出文件的散列值
3. Task执行前，如果输入、输出的散列值和上一次执行相比，没有变化，那么任务是up-to-date 

可以看到，如果任务没有输出，那么它永远不会被看做是up-to-date的。如何声明任务的输入输出呢？

task transform {
    ext.srcFile = file('mountains.xml')
    ext.destDir = new File(buildDir, 'generated')
    
    //下面两行定义了当前任务的输入和输出
    inputs.file srcFile
    outputs.dir destDir
    
    doLast {
       //Task的逻辑
    }
}

上述脚本设置了Task的inputs、outputs属性，如果没必要执行，那么Gradle会自动跳过此任务。

对于复杂的场景，可以调用

TaskOutputs.upToDateWhen()

//动态创建4个任务task1 ... task3
4.times { counter ->
    task "task$counter" << {
        println "I'm task number $counter"
    }
}

//基于规则的动态任务
//对于任何pingXxx，都作为任务看待
tasks.addRule("Pattern: ping<ID>") { String taskName ->
    if (taskName.startsWith("ping")) {
        task(taskName) << {
            println "Pinging: " + (taskName - 'ping')
        }
    }
}
//执行命令 gradle -q pingServer1
//输出 Pinging: Server1

//这些动态任务甚至还可以用做任务依赖
task groupPing {
    dependsOn pingServer1, pingServer2
}

类似于Java的

finally

task taskX << {
    throw new RuntimeException()
}
task taskY << {
    println 'taskY'
}

taskX.finalizedBy taskY
//运行 gradle -q taskX
//输出 taskY

由于大多数构建都需要操作文件，因此Gradle定义了一些额外的文件操作API。

/************************ 文件定位 ***************************/
// 使用一个相对路径
File configFile = project.file('src/config.xml')
// 使用一个绝对路径
configFile = file('file:/some/path.xml')
configFile = file('F:/config.xml')



/************************ 文件集合 ***************************/
FileCollection collection = files(
    'src/file1.txt',
    new File('src/file2.txt'),
    ['src/file3.txt', 'src/file4.txt'] //会被自动展开
)
//迭代集合
collection.each {File file ->
    println file.name
}
//类型转换
List list = collection as List
String path = collection.asPath
File file = collection.singleFile
//添加、去除文件元素
def union = collection + files('src/file3.txt')
def different = collection - files('src/file3.txt')


/************************ 文件树 ***************************/
//从相对目录创建
FileTree tree = fileTree(dir: 'src/main')
tree.include '**/*.java'
tree.exclude '**/Abstract*'
//从归档文件创建
FileTree zip = zipTree('someFile.zip')
FileTree tar = tarTree('someFile.tar')
//遍历
tree.each {File file ->
    println file
}
//过滤
FileTree filtered = tree.matching {
    include 'org/gradle/api/**'
}
//合并
FileTree sum = tree + fileTree(dir: 'src/test')


/************************ 复制文件 ***************************/
//各种文件来源
task copyTask(type: Copy) {
    //复制目录下所有文件
    from 'src/main/webapp'
    //复制单个单独文件
    from 'src/staging/index.html'
    //从一个任务的输出复制
    from copyTask
    //从一个任务的outputs属性复制
    from copyTaskWithPatterns.outputs
    //复制归档文件中的内容
    from zipTree('src/main/assets.zip')
    //最终指定目标目录
    into { getDestDir() }
}
//文件过滤
task copyTaskWithPatterns(type: Copy) {
    from 'src/main/webapp'
    into 'build/explodedWar'
    include '**/*.html'
    include '**/*.jsp'
    exclude { details -> details.file.name.endsWith('.html') }
}
//复制的过程中重命名
task rename(type: Copy) {
    //闭包指定重命名规则
    rename { String fileName -> fileName.replace('-staging-', '') } 
    //使用正则表达式指定映射规则
    rename(/(.+)-staging-(.+)/, '$1$2')
}
//处理文件内容
task filter(type: Copy) {
    //替换文件中的标记，标记必须是@tokenName@的形式
    expand(copyright: '2009', version: '2.3.1')
    expand(project.properties)
    //使用闭包处理每一行
    filter { String line -> "[$line]" }
    //使用闭包删除行
    filter { String line ->  line.startsWith('-') ? null : line  }
}


/************************ 同步两个目录 ***************************/
task libs(type: Sync) {
    from configurations.runtime
    into "$buildDir/libs"
}


/************************ 创建归档文件 ***************************/
task zip(type: Zip) {
    from 'src/dist'
    into('libs') {
        from configurations.runtime //指定依赖配置类型
    }
    baseName = 'customName' //指定归档文件名
}

Gradle支持以下日志记录级别：

在打印日志的同时，还可以指定命令行参数：

1. -s  --stacktrace：打印调用栈
2. -S  --full-stacktrace：打印完整调用栈

可以向标准输出打印日志：

println 'A message which is logged at QUIET level'

或者通过

logger

logger.quiet('An info log message which is always logged.')
logger.error('An error log message.')
logger.warn('A warning log message.')
logger.lifecycle('A lifecycle info log message.')
logger.info('An info log message.')
logger.debug('A debug log message.')
logger.trace('A trace log message.')

还可以使用外部日志工具：

import org.slf4j.Logger
import org.slf4j.LoggerFactory

Logger slf4jLogger = LoggerFactory.getLogger('some-logger')
slf4jLogger.info('An info log message logged using SLF4j')

就像Maven一样，Gradle核心本身也不能做多少有意义的事情，实际的构建工作都是由插件完成的。Gradle允许插件：

1. 扩展Gradle的DSL模型，例如可以配置新的DSL元素
2. 应用“约定由于配置”原则，为工程提供缺省配置
3. 引入新的默认任务集

Gradle插件分为两类：

1. 脚本插件：本质上是额外的构建脚本，可以进一步的配置构建逻辑
2. 二进制插件：是接口

   org.gradle.api.Plugin

    的实现，以编程的的方式操控构建

使用方法

Project.apply()

/** 应用一个脚本插件 **/
// 实际上就是include一段脚本
apply from: 'other.gradle'

/** 应用二进制插件 **/
apply plugin: 'java'  //基于短名
apply plugin: JavaPlugin //基于插件类，org.gradle.api.plugins包内的插件不需要全名
//通过构建脚本块可以引入插件依赖，并使用插件
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:0.4.1"
    }
}
apply plugin: "com.jfrog.bintray"

Gradle构建分为三个独立的阶段：

1. Initialization：Gradle支持多工程构建。在初始化阶段，Gradle会确定有哪些工程参与构建，并为它们创建Project实例
2. Configuration：在此阶段，所有的Project对象被合理配置，每个Project的构建脚本（build script，即build.gradle）被执行
3. Execution：Gradle依据命令行参数、当前所在目录决定需要执行的Task的子集。Task的全集在Configuration阶段已经生成

下面示意构建脚本的不同部分在哪个阶段执行：

println '该代码在配置阶段执行'
task configured {
	println '该代码在配置阶段执行'
}
task test << {
	println '该代码在执行阶段执行'
}
task testBoth {
	doFirst {
	  println '该代码在执行阶段执行，最先执行'
	}
	doLast {
	  println '该代码在执行阶段执行，最后执行'
	}
	println '该代码在配置阶段执行'
}

在初始化阶段，Gradle必须确定进行的单工程还是多工程构建（参见下一章）。多工程的设置总是存放在settings.gradle，Gradle自动的寻找该文件的顺序如下：

1. 在当前目录下寻找
2. 在同级的、名为master的目录中寻找
3. 到父目录中寻找

如果找到settings.gradle，Gradle寻找被构建工程是否存在于settings.gradle所声明的工程树中，如果是，则执行多工程构建。否则，执行单工程构建。找不到settings.gradle则一定执行单工程构建。

注意，上述自动寻找settings.gradle的逻辑，仅在多工程满足下面条件之一时发生：

1. 工程物理位置与工程树结构对应
2. 或者，使用扁平目录结构，并且用master目录表示主工程

否则，你必须在settings.gradle所在目录执行Gradle命令以触发多工程构建。

在初始化结束之后，如果时单工程构建，其过程很简单。Gradle会寻找命令行传入的任务名，并把每个任务作为单独的构建执行。

在生命周期各关键点前后，Gradle会发布多种事件（通知），你可以在构建脚本中对这些事件进行处理：

allprojects {
	afterEvaluate { project ->
		println '$it evaluated'
	}
}

tasks.whenTaskAdded { task ->
    task.ext.srcDir = 'src/main/java'
}

gradle.taskGraph.beforeTask { Task task ->
	println "executing $task ..."
}

gradle.taskGraph.afterTask { Task task, TaskState state ->
	if (state.failure) {
		println "FAILED"
	}
}

所谓多工程构建，是指在执行单次Gradle命令时，同时完成多个工程（一个root工程，外加若干个子工程，每个子工程也可以具有自己的子工程）的构建。必须通过

settings.gradle

org.gradle.api.initialization.Settings

假设有一个包含四个子工程的工程，结构如下：

multiproject/
  api/                      #生成一个JAR包，提供WebService客户端的功能
  services/webservice/      #WebService服务端
  shared/                   #其它三个工程依赖该工程
  services/shared/

要启用多工程的支持，必须在工程集的根目录添加

settings.gradle

include "shared", "api", "services:webservice", "services:shared"

 根目录通常作为工程的容器，其中可以通过

subprojects

//所有子目录下的工程都获得下列配置信息：
subprojects {
    apply plugin: 'java'
    apply plugin: 'eclipse-wtp'

    repositories {
       mavenCentral()
    }

    dependencies {
        testCompile 'junit:junit:4.12'
    }

    version = '1.0'

    jar {
        manifest.attributes provider: 'gradle'
    }
}
//注意，由于是在subprojects段设置，因此根工程不会获得这些配置

可以声明子工程之间的依赖：

dependencies {
    compile project(':shared')
}

上面的设置可以确保shared总是在api前面构建，因为后者依赖于前者。 

默认的，Gradle使用全量配置方式：在任何Task执行之前，所有工程都被配置完毕。如果工程数量达到上百个，这会导致配置阶段耗费的时间过于漫长。对不参与本次构建的工程进行配置是不必要的，因此，Gradle 1.4引入了按需配置（Configuration on demand）模式，按需配置仅仅去配置那些与被请求执行任务相关的工程。在未来，按需配置可能变为默认或者唯一的配置模式。

在按需配置模式下，工程按照下面的规则配置：

1. 根工程总是被配置，这保证典型的公共配置脚本被支持（allprojects和subprojects脚本块）
2. 如果Gradle命令没有指定目标，则当前目录对应的工程被配置。这保证工程默认任务（Default tasks）可以正常工作
3. 依赖工程被配置，如果projectA在编译时依赖于projectB，那么构建projectA会导致projectB也被配置
4. 依赖任务所在工程被配置，例如

   taskA.dependsOn(":projectB:taskB1")

    导致构建taskA时projectB被配置
5. 通过命令行指定Task的路径，那么路径中牵涉到的工程都会被配置，例如

   gradle projectA:projectB:someTask

    导致projectB被配置

在配置文件

gradle.properties

org.gradle.configureondemand

以一个简单的多工程为例，根工程root包含一个子工程sub0：

root/
  build.gradle
  settings.gradle
  sub0/

settings.gradle的内容如下：

include 'sub0'

Closure cl = { task -> println "I'm $task.project.name" }
task hello << cl
project(':sub0') {
    task hello << cl
}
# 在根工程目录运行gradle -q hello输出如下：
# I'm root
# I'm sub0
# 注意，所有子工程同名Task会自动执行

其实，Gradle允许在任何一个工程的构建脚本中访问所有工程，只要调用

project(projectName)

下面的脚本块可以为所有工程添加公共行为：

allprojects {
    task hello << { task -> println "I'm $task.project.name" }
}

下面的脚本则为所有子工程添加公共行为：

subprojects {
    hello << { println "I'm $it.project.name" }
}

还可以依据各种条件进行过滤，针对符合条件的工程添加行为：

//根据子工程的名称进行过滤
configure(subprojects.findAll {it.name != 'sub1'}) {
    hello << { println '$it.project.name' }
}

当在根工程目录执行

gradle taskA

Gradle支持指定Task的绝对路径：

gradle -q :hello   //根工程的hello任务
:sub0:hello        //sub0工程的hello任务
hello              //当前工程的hello任务

如果路径以分号开始，则表示是绝对路径（相当于根）。根工程是唯一不需要以名称指代的工程。 

要确定Task的执行顺序，可以使用

dependsOn

//跨工程的任务依赖
task consume(dependsOn: ':producer:produce') << {
    println("Consuming message: ${rootProject.producerMessage}")
}

被依赖的Task总是先被执行。

库依赖（lib  dependency）是一种特殊的执行依赖。以Java构建为例，工程构建时，要求作为库的Jar已经生成好（此Jar可能传递性的依赖于其它Jar）并且添加到当前工程的Classpath中。如果这些库作为多工程构建的子工程存在，这就意味着工程之间存在依赖，这种依赖使用

dependencies

subprojects {
    // 子工程公共属性
    apply plugin: 'java'
    group = 'cc.gmem.study.gradle'
    version = '1.0'
}

project(':api') {
    configurations {
        spi  //声明一个依赖配置（dependency configurations）
    }
    dependencies {
        compile project(':shared') //声明库依赖：编译时依赖于shared工程
    }
    task spiJar(type: Jar) {
        baseName = 'api-spi'
        dependsOn classes
        from sourceSets.main.output
        include('org/gradle/sample/api/**')
    }
    //声明产出构件
    artifacts {
        spi spiJar
    }
}

project(':services:personService') {
    dependencies {
        compile project(':shared') //声明库依赖
        compile project(path: ':api', configuration: 'spi') //声明库依赖，并指定配置
        testCompile "junit:junit:4.12", project(':api')
    }
}

如果要禁止依赖工程的构建，可以使用gradle命令的

-a

Gradle自带了很多插件，这些插件可以完成不同领域的构建任务。Gradle从一开始就很好的支持Java的构建，支持编译、打包、单元测试都构建动作。 

类似与Maven，Gradle的Java插件也是遵从“约定优于配置”的理念，因而Java插件生成了类似Maven的工程结构。

要添加Java插件的支持，在build.gradle中需要声明：

apply plugin: 'java'

1. 自动设置src/main/java为Java源码目录，src的其它子目录布局和Maven一致
2. 自动添加若干可用的Task，运行

   gradle tasks

    可以看到这些Task的详细说明

下表列出Java插件提供的常用任务：

与Maven类似，默认有src/main|test/java|resourcs目录，其它源码集存放在：

src/sourceSetName/java

src/sourceSetName/resources

sourceSets {
    main {
        java {
            srcDir 'src/java'
        }
        resources {
            srcDir 'src/resources'
        }
    }
}

Gradle维护一个和Maven Repository类似的依赖库，默认位于

%USERPROFILE%/.gradle/caches/

repositories {
    mavenCentral()
}

使用下面的方式声明当前工程的依赖库：

dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

Java插件默认给工程添加了很多属性，通过命令

gradle properties

sourceCompatibility = 1.5
version = '1.0'

也可以在jar的manifest中添加属性：

jar {
    manifest {
        attributes 'Implementation-Title': 'Gradle Quickstart',
                   'Implementation-Version': version
    }
}

或者在测试阶段添加一个系统属性：

test {
    systemProperties 'property': 'value'
}

可以声明把构建结果发布到仓库中，下面示例了如何发布到本地目录：

uploadArchives {
    repositories {
       flatDir {
           dirs 'repos'
       }
    }
}

添加插件：

apply plugin: 'eclipse'

gradle eclipse

Annotation processing是Java 1.5引入的功能，允许在编译期进行代码检查、代码生成等操作。

要让Gradle能自动调用注解处理器，可以使用net.ltgt.apt插件：

buildscript {
  repositories {
    maven {
      url "https://plugins.gradle.org/m2/"
    }
  }
  dependencies {
    classpath "net.ltgt.gradle:gradle-apt-plugin:0.21"
  }
}

apply plugin: "net.ltgt.apt"

然后，执行gradle build会调用注解处理器。

如果使用Intellij IDEA作为开发工具，可以将插件更换为：

apply plugin: "net.ltgt.apt-idea"

这样，如果注解处理器生成了源代码，这些源代码的目录自动变为source root。

task fatJar( type: Jar ) {
    manifest {
        attributes 'Implementation-Title': project.name,
                   'Implementation-Version': version,
                   'Main-Class': 'cc.gmem.yun.alcm.repository.source.GrpcServer'
    }
    baseName = project.name + '-all'
    from {
        configurations.compile.collect {
            it.isDirectory() ? it : zipTree( it ).matching {
                it.exclude(
                    'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA', 'META-INF/DEPENDENCIES', 'META-INF/INDEX.LIST',
                    'META-INF/LICENSE*', 'META-INF/NOTICE*', 'META-INF/README*'
                )
            }
        }
    }
    with jar
} 

如果你希望把构件安装到Maven本地仓库，则需要此插件：

apply plugin: 'maven'

安装此插件后，可以使用如下任务：

-Dmaven.repo.local=the/path/of/the/folder

需要使用到插件：

apply plugin: 'maven-publish'

publishing {
    publications {
        maven( MavenPublication ) {
            // 源码在哪
            from components.java
            // 发布JavaDocs和源码
            artifact javadocJar
            artifact sourcesJar

            // 编辑POM内容
            pom {
                name = project.group + ":" + project.name
                url = 'https://github.com/grpc/grpc-java'
                afterEvaluate {
                    description = project.description
                }

                scm {
                    connection = 'scm:git:https://github.com/grpc/grpc-java.git'
                    developerConnection = 'scm:git:git@github.com:grpc/grpc-java.git'
                    url = 'https://github.com/grpc/grpc-java'
                }

                licenses {
                    license {
                        name = 'Apache 2.0'
                        url = 'https://opensource.org/licenses/Apache-2.0'
                    }
                }

                developers {
                    developer {
                        id = "grpc.io"
                        name = "gRPC Contributors"
                        email = "grpc-io@googlegroups.com"
                        url = "https://grpc.io/"
                        organization = "gRPC Authors"
                        organizationUrl = "https://www.google.com"
                    }
                }

                withXml {
                    if ( !( project.name in
                        [
                            "grpc-stub",
                            "grpc-protobuf",
                            "grpc-protobuf-lite",
                        ] ) ) {
                        asNode().dependencies.'*'.findAll() { dep ->
                            dep.artifactId.text() in [ 'grpc-api', 'grpc-core' ]
                        }.each() { core ->
                            core.version*.value = "[" + core.version.text() + "]"
                        }
                    }
                }
            }
        }
    }
    // 远程仓库配置
    repositories {
        maven {
                credentials {
                    if ( rootProject.hasProperty( 'pacloudUsername' ) && rootProject.hasProperty( 'pacloudPassword' ) ) {
                        username = rootProject.pacloudUsername
                        password = rootProject.pacloudPassword
                    }
                }
                def releaseUrl = 'https://nexus.pacloud.io/repository/maven-releases/'
                def snapshotUrl = 'https://nexus.pacloud.io/repository/maven-snapshots/'
                url = version.endsWith( 'SNAPSHOT' ) ? snapshotUrl : releaseUrl
            }
        }
    }
}

执行下面的命令，完成打包和发布：

gradle sourceJar
gradle publishToMavenLocal

Gradle提供了Groovy插件：

apply plugin: 'eclipse'
apply plugin: 'groovy'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.codehaus.groovy:groovy-all:2.3.7'
    testCompile 'junit:junit:4.11'
}

该插件引入了以下任务： 

Groovy工程的目录布局与Java工程类似，新引入src/main/groovy、src/test/groovy目录存放Groovy源码。

如果要改变默认工程目录布局，可以：

sourceSets {
    main {
        groovy {
            srcDirs = ['src/groovy']
        }
    }

    test {
        groovy {
            srcDirs = ['test/groovy']
        }
    }
}

Gradle提供了两个和Web应用相关的插件：

1. War插件：在Java插件的基础上进行扩展，支持构建war包 
2. Jetty插件：允许发布War到Jetty容器

要添加War插件，可以：

apply plugin: 'war'
//注意，该插件会自动引入Java插件

运行

gradle build

War插件引入以下任务：

Web资源，例如JavaScript、CSS、HTML、JSP等，默认存放到src/main/webapp目录中。

War插件引入了两个新的依赖配置：

下面的脚本示例了如何定制War插件的属性：

configurations {
   moreLibs
}

repositories {
   flatDir { dirs "lib" } //把lib目录作为依赖仓库
   mavenCentral()
}
dependencies {
    providedCompile "javax.servlet:servlet-api:2.5"
}

war {
    from 'src/rootContent' // 添加文件集到war中 
    webInf { from 'src/additionalWebInf' } // 添加文件夹到WEB-INF目录下
    classpath fileTree('additionalLibs') // 添加文件夹
    classpath configurations.moreLibs // 添加一个配置到WEB-INF/lib目录下
    webXml = file('src/someWeb.xml') // 拷贝文件为WEB-INF/web.xml
}

Jetty插件继承自War插件，可以通过下面的脚本添加该插件：

apply plugin: 'jetty'

运行

gradle jettyRunWar

Jetty插件引入以下任务：

下面的脚本示例了如何定制Jetty插件的属性：

jetty {
    contextPath '上下文路径，默认war的名称'
    httpPort '监听端口，默认8080'
    stopPort '管理端口'
    stopKey  '要求Jetty停止时，传递给他的key'
}

Gradle是当前Android官方IDE—— Android Studio内置的构建工具，你可以脱离AS，直接通过命令行调用Gradle，完成Android工程的构建。

通过编写构建脚本， 你可以配置Android构建的如下几个方面：

1. 构建变体（Build variants）：可以生成多个不同配置的APK，例如Debug/Release配置，又例如针对不同的体系结构（x86、arm）
2. Android库依赖
3. Manifest条目：可以在构建变体配置中覆盖AndroidManifest.xml中某些元素的取值。如果需要创建多个具有不同应用名称、最小SDK版本要求、目标SDK版本的APK，可以设置Manifest条目。如果有多个Manifest文件，会根据buildType、productFlavor、/main Manifest、library Manifest的优先顺序自动合并
4. 签名：可以指定数字签名参数，在构建过程中对APK进行签名
5. ProGuard：允许配置ProGuard，对APK进行混淆、裁剪和优化

Android Studio区分工程（Project）、模块（两个概念）：

1. 工程：表示一个顶级的Android开发结构（相当于Gradle的根工程），一个工程中可以包含多个模块（相当于Gradle子工程）
2. 模块：表示一个可以独立构建、测试、调试的组件

AS支持以下类型的模块：

1. Android Application Module：包含手机、电视 或手表的程序代码和资源，依赖于Library Module。构建系统为此类模块生成APK归档
2. Android Library Module：可重用的Android程序代码和资源。构建系统为此类模块生成AAR（Android ARchive）归档
3. App Engine Module：包含用于与Google App Engine集成的代码和资源
4. Java Library Module：包含可重用的Java代码。构建系统为此类模块生成JAR归档

AS为工程和每个模块都生成Gradle构建脚本（build.gradle），这些脚本完全遵守Gradle的规范。

Android Studio工程包含了一个Gradle Wrapper，此Wrapper包含一个Gradle jar、一个属性文件、Windows/Linux的Shell脚本。使用Gradle Wrapper可以确保总是运行 

local.properties

可以指定Android工程的依赖，以及所有模块的公共依赖：

//构建本身的依赖配置
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        //使用特定版本的Gradle
        classpath 'com.android.tools.build:gradle:1.0.1'
    }
}
//针对Android工程和所有模块的依赖配置
allprojects {
   repositories {
       jcenter()
   }
}

每个模块都可以有自己的构建脚本，要对模块启用Android构建的支持，必须应用android插件：

//注意，不得同时应用java插件，会导致构建错误
apply plugin: 'android'
//或者：
apply plugin: 'com.android.application'

可以在构建脚本中覆盖src/main/AndroidManifest.xml中的设置，或者对打包选项进行定制：

android {
    //Android 基本设置
    compileSdkVersion 16
    buildToolsVersion "23.0.2"
    
    //覆盖AndroidManifest.xml中的manifest properties设置
    defaultConfig {
        applicationId "cc.gmem.androidstudy"
        minSdkVersion 15
        targetSdkVersion 16
        versionCode 1
        versionName "1.0"
    }
    //构建类型设置
    //默认情况下，Android插件同时创建两个构建类型：Debug、Release。两者的主要区别是：
    //Debug使用自动创建的密钥签名，而Release版本在构建时不签名
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
        debug {
            debuggable true
            //设置ApplicationId，这样设备上可以同时安装Debug版本和Release版本的APK
            applicationIdSuffix ".debug"
        }
        //从debug衍生一个构建类型
        jnidebug {
            initWith(buildTypes.debug)
            packageNameSuffix ".jnidebug"
            jniDebuggable true
        }
    }
}
//声明一些依赖项
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:16.+'
}

对于每个新创建的构建类型，Android插件自动创建Task：

assemble<BuildTypeName>

Android插件默认使用如下的工程结构：

如果默认工程结构不能满足需要，可以使用如下脚本定制：

android {
    sourceSets {
        //此闭包修改源码集的默认设置
        main {
            manifest.srcFile 'AndroidManifest.xml' //指定Manif文件名称
            //指定子目录位置
            java.srcDirs = ['src']
            resources.srcDirs = ['src']
            aidl.srcDirs = ['src']
            renderscript.srcDirs = ['src']
            res.srcDirs = ['res']
            assets.srcDirs = ['assets']
        }
        androidTest.setRoot('tests') //把整个androidTest源码集移动到tests目录
    }
}

Android插件自动引入以下Task：

默认的，Debug构建的keystore存放在

$HOME/.android/debug.keystore

android {
    signingConfigs {
        debug {
            storeFile file("debug.keystore")
        }
        //创建新的签名配置
        myConfig {
            storeFile file("other.keystore")
            storePassword "android"
            keyAlias "androiddebugkey"
            keyPassword "android"
        }
    }

    buildTypes {
        foo {
            //应用签名配置
            signingConfig signingConfigs.myConfig
        }
    }
}

The post Gradle学习笔记 appeared first on 绿色记忆.

Android Studio目前作为Android官方的IDE，它使用Gradle作为构建工具，对Android平台引入的新特性都能够很快的支持。相比之下，Eclipse ADT则更新缓慢，与最常用的构建工具——Maven的集成主要依靠开源界的个人开发者的力量，因而问题较多。

使用Android Studio进行Android开发的确是理想的选择，但是，对于长期习惯于Eclipse + Maven的开发团队来说，Android Studio + Gradle的组合有不小的学习、转换成本。况且很多团队同时负责Android和传统的JavaEE开发，难以摆脱对大量Eclipse、Maven插件的依赖，使用Android Studio后团队需要同时熟悉两套开发工具。

我们团队采用了Eclipse ADT + Maven的组合，本文记录开发环境的搭建过程，开发过程中遇到的问题及其解决方案，备忘并供各位参考。

安装Eclipse ADT或者Android Studio之一，都会自动安装Android SDK管理工具。亦可下载独立安装包。

安装完毕后，设置如下环境变量：

1. ANDROID_HOME

    设置为Android SDK安装位置，例如D:\Android\sdk

2. PATH

    中添加

   %ANDROID_HOME%\tools

    、

   %ANDROID_HOME%\platform-tools

    

%ANDROID_HOME%目录下的AVD Manager.exe、SDK Manager.exe分别是Android模拟器管理工具、SDK管理器。打开SDK管理器，根据需要安装SDK版本和工具。通常需要安装：最新的、以及项目需要的Android版本的SDK Platform、ARM/Intel的System Image、Google APIS、Sources for Android SDK。以及Extra下的全部项目。

如果使用模拟器开发调试，并且你的机器是基于Intel的Windows，则应该在下载完毕后，安装位于extras\intel\Hardware_Accelerated_Execution_Manager目录下的HAXM，可以在很大程度上提高模拟器的性能。

Maven中心仓库中，更新Android SDK构件的速度非常慢，这可能是因为Android官方不使用Maven作为构建工具的原因。

我们可以使用Maven Android SDK Deployer补充Android的Maven构件，该工具可以批量的安装Android SDK组件到Maven仓库，其本质上是一个Maven工程，运行时需要Maven 3.1.1+支持。

使用该工具前，设置好ANDROID_HOME，打开%ANDROID_HOME%\SDK Manager.exe：

1. 下载所需版本的SDK Platform。检查对应的%ANDROID_HOME%\platforms\android-N目录存在（N为SDK数字版本号）
2. 下载所需版本的Addon Google APIs。检查对应的%ANDROID_HOME%\add-ons\addon-google_apis-google-N目录存在

下载完毕后，执行下面的命令安装SDK组件到Maven仓库：

cd D:\Android\tools
rem 从GitHub下载maven-android-sdk-deployer
git clone https://github.com/simpligility/maven-android-sdk-deployer.git maven-android-sdk-deployer
cd maven-android-sdk-deployer
rem 安装4.1版本的SDK组件到Maven仓库
set M2_HOME=D:\JavaEE\maven\3.3
rem 如果要安装所有SDK版本的构件到Maven仓库，你需要预先下载所有版本的Android SDK，并执行mvn install
mvn install -P 4.1

Maven Android SDK Deployer依照下面的规则命名SDK组件对应的Maven构件

ADT相关的全局设置位于Window ⇨ Preferences ⇨ Android下：

# 设置模拟器联网时使用的代理 
-http-proxy 192.168.0.89:8086  
# 设置模拟器使用的DNS服务器
-dns-server 178.79.131.110,223.5.5.5

在Eclipse中，打开Window ⇨ Android Virtual Devices Manager，看到如下界面：

点击右侧按钮Start，可以启动既有的模拟器。

点击右侧按钮Create，创建一个模拟器，参数设置如下：

点击OK，即可完成模拟器创建。

本节介绍两种创建ADT工程的方法，推荐使用第二种方式，以便获得Maven工程的诸多优势。

在不使用Maven的情况下，可以直接创建Android应用工程。点击Eclipse菜单：File ⇨ New ⇨ Android Application Project，弹出如下对话框：

各字段说明如下：

1. Application Name：应用程序的名称，会显示在应用商店、设置（Settings）程序中
2.  Project Name：即Eclipse工程的名称
3. Package Name：作为一个应用程序（不管版本如何变迁）的唯一标识符，同时也作为Java的包名
4. Minimum Required SDK：运行时需要的SDK最低版本，版本越低则可用特性越少
5. Target SDK：此应用可支持的最高SDK版本，用于提示低于/等于此版本的运行时系统，不去执行兼容性行为
6. Compile With：使用哪个已安装的SDK版本来编译程序。通常使用最近的SDK，或者支持所有你想直接使用（不通过反射）的API的某个SDK
7. Theme：应用程序的基本主题风格

填写好上述字段后，点击 Next，显示如下对话框：

如果取消勾选Create custom launcher icon、Create activity，则可以结束向导，完成工程创建。否则，后面两个步骤分别用来定制应用图标、选择一个指定布局方式的Activity。

勾选Mark this project as a library，则当前工程被作为Android库看待。

# 目标SDK版本，此版本的SDK讲作为当前工程的依赖库
target=android-22
# 当前工程是否为一个Android Library工程
android.library=true
# 使用的Proguard设置
proguard.config=proguard-project.txt

可以直接创建Maven Project，由m2e-android负责生成ADT工程结构：

1. 点击Eclipse菜单：File ⇨ New ⇨ Maven Project，在第二步选择groupId为de.akquinet.android.archetypes、artifactId为android-quickstart的Maven原型。如果搜索不到此原型，点击Add Archetype添加
2. 点击Next，输入Group Id、Artiface Id等信息，并填写原型属性：
   1. platform为目标Android SDK版本
   2. android-plugin-version为android-maven-plugin的版本
3. 点击Finish，完成工程创建

注意：原型android-quickstart是基于android-maven-plugin 3.x的，android-maven-plugin 4.x工程目录结构变化较大，需要手工调整。调整步骤可以参考迁移到4.x版本。也参考下面的完整POM手工创建工程。

为便于表述，本节后续内容称此Maven工程为apk工程。

需要注意的地方：

1. 如果使用3.8.x版本的android-maven-plugin，Eclipse可能提示错误：“Plugin execution not covered by lifecycle configuration: com.jayway.maven.plugins.android.generation2:android-maven-plugin:3.8.2:consume-aar (execution: default-consume-aar, phase: compile)”。consume-aar是android-maven-plugin添加的用来支持Android新的库归档格式（AAR）的Goal，但是m2e-android、ADT暂时均不支持AAR，这是出现错误的原因。修改工程的POM可以屏蔽此错误
   

   <pluginManagement>
       <plugins>
           <plugin>
               <groupId>org.eclipse.m2e</groupId>
               <artifactId>lifecycle-mapping</artifactId>
               <version>1.0.0</version>
               <configuration>
                   <lifecycleMappingMetadata>
                       <pluginExecutions>
                           <pluginExecution>
                               <pluginExecutionFilter>
                                   <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                                   <artifactId>android-maven-plugin</artifactId>
                                   <versionRange>${android.plugin.version}</versionRange>
                                   <goals>
                                       <goal>consume-aar</goal>
                                   </goals>
                               </pluginExecutionFilter>
                               <action>
                                   <ignore />
                               </action>
                           </pluginExecution>
                       </pluginExecutions>
                   </lifecycleMappingMetadata>
               </configuration>
           </plugin>
       </plugins>
   </pluginManagement>

   修改POM完毕后，工程右键 ⇨ Maven ⇨ Update Project，工程不再报错。 

2. 广泛使用的3.8版本的android-maven-plugin对高版本的Android SDK支持存在问题，如果在POM中修改了

   <sdk><platform>16</platform></sdk>

    元素中的版本号，例如修改为22，会无法正常生成/更新ADT工程元数据和AndroidManifest.xml，需要手工介入：
   1. 修改project.properties：

      target=android-22

       
   2. 修改AndroidManifest.xml中的SDK版本声明：
      

      <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="22" />

下面是apk工程完整的pom.xml（使用 4.3.0版本的android-maven-plugin）：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>cc.gmem.study</groupId>
    <artifactId>cordova-study</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>apk</packaging>
    <name>cordova-study</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <android.plugin.version>4.3.0</android.plugin.version>
    </properties>

    <dependencies>
        <!-- 安卓SDK依赖，原型默认生成的是groupId为com.google.android的依赖项，但是5.0+以上的构件始终没有加入到中心仓库 -->
        <!-- 因此这里手工修改为Maven Android SDK Deployer生成的构件 -->
        <dependency>
            <groupId>android</groupId>
            <artifactId>android</artifactId>
            <version>5.1.1_r2</version>
            <scope>provided</scope>
        </dependency>
        <!-- 添加一个apklib/aar依赖，依赖项必须位于当前Workspace中 -->
        <dependency>
            <groupId>org.apache.cordova</groupId>
            <artifactId>cordova-android</artifactId>
            <version>5.4.1-SNAPSHOT</version>
            <type>apklib</type>
        </dependency>
    </dependencies>
    <build>
        <finalName>${project.artifactId}</finalName>
        <!-- 如果不指定，默认执行的生命周期阶段或者目标 -->
        <defaultGoal>package android:deploy android:run</defaultGoal>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>com.simpligility.maven.plugins</groupId>
                    <artifactId>android-maven-plugin</artifactId>
                    <version>${android.plugin.version}</version>
                    <extensions>true</extensions>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>com.simpligility.maven.plugins</groupId>
                <artifactId>android-maven-plugin</artifactId>
                <configuration>
                    <sdk>
                        <!-- 指定Android SDK版本，Update Project可能无效，需要手工修改AndroidManifest.xml、project.properties文件 -->
                        <platform>22</platform>
                    </sdk>
                    <!-- 控制dex命令的执行 -->
                    <dex>
                        <jvmArguments>
                            <jvmArgument>-Xms256m</jvmArgument>
                            <jvmArgument>-Xmx512m</jvmArgument>
                        </jvmArguments>
                        <incremental>true</incremental>
                        <optimize>false</optimize>
                    </dex>
                    <!-- 设置android:run目标的行为 -->
                    <run>
                        <debug>true</debug>
                    </run>
                    <!-- true使用Debug keystore签名，false不签名，both同时创建签名/不签名的apk -->
                    <sign>
                        <debug>true</debug>
                    </sign>
                    <!-- 是否跳过代码精简、混淆处理 -->
                    <proguard>
                        <skip>true</skip>
                    </proguard>
                    <!-- 是否跳过测试 -->
                    <test>
                        <skip>true</skip>
                    </test>
                    <!-- 部署前先卸载既有版本 -->
                    <undeployBeforeDeploy>true</undeployBeforeDeploy>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Android Maven工程可能引用几种不同格式的库：

1. jar：在Eclipse Package Explorer视图中，显示在Maven Dependencies目录下
2. apklib：在Eclipse Package Explorer视图中，显示在Android Dependencies目录下
3. aar：在Eclipse Package Explorer视图中，显示在Android Dependencies目录下

下面的片段示例了如何引用apklib格式的库：

<dependency>
    <groupId>org.apache.cordova</groupId>
    <artifactId>cordova-android</artifactId>
    <version>5.4.1-SNAPSHOT</version>
    <type>apklib</type>
</dependency>

注意，ADT不支持直接把apklib库作为lib使用（该库格式并非Android官方提出），你必须：

1. 在当前Eclipse工作区中创建groupId、artifactId、version与依赖项一致的Android库工程（打包方式设置为apklib）
2. 把Maven仓库中的apklib库作为zip格式解包，提取出资源：src目录内为Java源码，存放到apklib工程的src/main/java中。assets、res、AndroidManifest.xml等目录和文件覆盖到Android库工程根目录下
3. 在apk工程上点击右键，Maven ⇨ Update Project

如果不执行上述步骤，在POM中添加apklib依赖后，你可能收到错误提示：dependency=[**:**:apklib:**:compile] not found in workspace。

ADT同样也不支持aar库，你也需要在当前Eclipse工作区中创建Android库工程，步骤和apklib类似：

1. 在当前Eclipse工作区中创建groupId、artifactId、version与依赖项一致的Android库工程（打包方式设置为aar）
2. 把Maven仓库中的aar库作为zip格式解包，提取出资源：
   1. assets、res、AndroidManifest.xml等目录和文件覆盖到Android库工程根目录下
   2. classes.jar、libs下所有jar一律作为Android库工程的依赖处理，可以在Maven仓库中识别这些jar的对应构件，缺失的手工添加为构件
3. 在apk工程上点击右键，Maven ⇨ Update Project

可重用的Android库有几种打包格式：

1. jar：这种格式只能包含Java类，不能包含Android资源
2. apklib：maven-compiler-plugin定义的一种打包格式，这种格式可以包含Java类和Android资源
3. aar：Google官方在2013年提出的库格式，与apklib一样，同时可以包含Java类和Android资源。两者的主要区别是，aar把所有类放在classes.jar中，而apklib把所有类的源码放在src目录下

第一种格式不需赘述，下面说明如何创建第二种格式的Maven工程：

1. 点击Eclipse菜单：File ⇨ New ⇨ Maven Project，在第二步选择groupId为de.akquinet.android.archetypes、artifactId为android-library-quickstart的Maven原型。如果搜索不到此原型，点击Add Archetype添加：
2. 点击Next，输入Group Id、Artiface Id等信息，并填写原型属性，点击完成

下面是apklib工程完整的pom.xml（使用 4.3.0版本的android-maven-plugin）：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.apache.cordova</groupId>
    <artifactId>cordova-android</artifactId>
    <version>5.4.1-SNAPSHOT</version>
    <packaging>apklib</packaging>
    <name>cordova-android</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <android.plugin.version>4.3.0</android.plugin.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>android</groupId>
            <artifactId>android</artifactId>
            <version>5.1.1_r2</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>${project.artifactId}</finalName>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>com.simpligility.maven.plugins</groupId>
                    <artifactId>android-maven-plugin</artifactId>
                    <version>${android.plugin.version}</version>
                    <extensions>true</extensions>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>com.simpligility.maven.plugins</groupId>
                <artifactId>android-maven-plugin</artifactId>
                <configuration>
                    <sdk>
                        <platform>22</platform>
                    </sdk>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>build-helper-maven-plugin</artifactId>
                <version>1.9.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>attach-artifact</goal>
                        </goals>
                        <configuration>
                            <artifacts>
                                <artifact>
                                    <!-- 同时打一个jar格式的包 -->
                                    <type>jar</type>
                                    <file>${project.build.directory}/${project.build.finalName}.jar</file>
                                </artifact>
                            </artifacts>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

一般只有再正式发布（Release）时才需要对APK进行正式的签名，开发期间只需要使用Debug Keystore即可。因此，最好是新建一个Maven Profile，在必要时启用：

<profiles>
    <profile>
        <id>sign</id>
        <properties>
            <!-- 密钥对和Keystore可以通过Keystore Explorer进行生成和管理 -->
            <jarsigner.keystore>D:\JavaEE\keystores\gmem.keystore</jarsigner.keystore>
            <!-- 密码可以通过命令行指定，例如mvn -Djarsigner.storepass=password -->
            <jarsigner.storepass>passwd</jarsigner.storepass>
            <jarsigner.alias>*.gmem.cc</jarsigner.alias>
            <jarsigner.keypass>passwd</jarsigner.keypass>
        </properties>
        <build>
            <plugins>
                <plugin>
                    <!-- 该插件提供了基于jarsigner签名或者验证签名（verify）工程构件和附件的能力 -->
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jarsigner-plugin</artifactId>
                    <version>1.4</version>
                    <executions>
                        <execution>
                            <id>signing</id>
                            <goals>
                                <goal>sign</goal>
                            </goals>
                            <phase>package</phase>
                            <configuration>
                                <!-- 扫描待处理构件的基目录，支持Ant风格的包含/排除模式 -->
                                <archiveDirectory></archiveDirectory>
                                <!-- 基目录下哪些构件需要被处理，支持Ant风格的包含/排除模式 -->
                                <includes>
                                    <include>target/*.apk</include>
                                </includes>
                                <!-- 是否移除构件上既有的签名 -->
                                <!-- 需要移除既有的、通过Debug keystore进行的签名 -->
                                <removeExistingSignatures>true</removeExistingSignatures>
                                <!-- Release版的keystore和alias的信息 -->
                                <keystore>${jarsigner.keystore}</keystore>
                                <storepass>${jarsigner.storepass}</storepass>
                                <alias>${jarsigner.alias}</alias>
                                <keypass>${jarsigner.keypass}</keypass>
                                <!-- 传递给jarsigner命令行的额外参数 -->
                                <!-- JDK 7+出现INSTALL_PARSE_FAILED_NO_CERTIFICATES错误，添加： -->
                                <arguments>
                                    <argument>-sigalg</argument>
                                    <argument>MD5withRSA</argument>
                                    <argument>-digestalg</argument>
                                    <argument>SHA1</argument>
                                </arguments>
                                <!-- 是否显示冗余的信息 -->
                                <verbose>true</verbose>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

使用下面的命令启用此Profile并执行构建：

mvn install -Psign

如果使用该插件的4.x版本，需要注意：

1. 插件的groupId已经改变为

   com.simpligility.maven.plugins

    
2. lifecycle-mapping的配置不需要了，consume-aar这个Goal已经废弃
3. AndroidManifest.xml需要存放到src/main/目录下
4. 资产文件需要从assets转移到src/main/assets
5. 资源文件需要从res转移到src/main/res

Update Project后，Android Maven Plugin会自动生成文件和目录的链接，以便ADT能够识别：

可能是android-maven-plugin和Maven运行时的兼容性问题。点击Window ⇨ Preferences，定位到Maven ⇨ Installations，选择一个小于3.2.5版本的Maven即可。

The post 基于Eclipse ADT和Maven的Android开发 appeared first on 绿色记忆.

APK包的res目录下，会有一些drawable开头的子目录，用来存放针对不同像素密度屏幕的资源文件：

可能原因是，APK被重复签名多次。删除掉META-INF目录下的签名文件、签名块文件后，重新签名即可。

APK包反向工程工具。

apktool if|install-framework [options] <framework.apk>

apktool [-q OR -v] d[ecode] [options] <file_apk>

apktool [-q|--quiet OR -v|--verbose] b[uild] [options] <app_path>

进行.dex格式、.smali格式、.class格式之间的转换。

# 转换apk中的.dex为Java的class文件，这些class文件打包在apk_to_decompile-dex2jar.jar中
d2j-dex2jar -f ~/path/to/apk_to_decompile.apk 

命令格式：

adb [子命令] [选项]

列出设备、连接/断开设备：

针对设备的子命令：

# 列出已安装的包
adb shell pm list packages
# 得到指定包的APK路径
adb shell pm path com.huawei.mw
# 拷贝出APK包
adb pull /data/app/com.huawei.mw-1/base.apk

JRE自带密钥数据库管理工具。用于加密密钥对、X.509证书链、受信任证书的管理。该工具支持基于DES算法的密码管理。

一个密钥数据库（keystore）可以包含多个密钥条目，以别名（alias）进行唯一区分。

命令格式：

keytool [commands]

{-rfc} {-infile infile} {-outfile outfile} {-alias alias} {-sigalg sigalg}
{-dname dname} {-startdate startdate {-ext ext}* {-validity valDays}
[-keypass keypass] {-keystore keystore} [-storepass storepass]
{-storetype storetype} {-providername provider_name}
{-providerClass provider_class_name {-providerArg provider_arg}}
{-v} {-protected} {-Jjavaoption} 

{-alias alias} {-keyalg keyalg} {-keysize keysize} {-sigalg sigalg}
[-dname dname] [-keypass keypass] {-startdate value} {-ext ext}*
{-validity valDays} {-storetype storetype} {-keystore keystore}
[-storepass storepass]
{-providerClass provider_class_name {-providerArg provider_arg}}
{-v} {-protected} {-Jjavaoption}

{-alias alias} {-file cert_file} [-keypass keypass] {-noprompt} {-trustcacerts}
{-storetype storetype} {-keystore keystore} [-storepass storepass]
{-providerName provider_name}
{-providerClass provider_class_name {-providerArg provider_arg}}
{-v} {-protected} {-Jjavaoption}

# 生成一个密钥对，并添加到数据库中
keytool -genkeypair -v -keystore ~/Android/Keystores/alexwong.keystore 
    -alias development -keyalg RSA -keysize 2048 -validity 36500

对JAR文件进行签名，或者执行签名校验 —— 签名是否有效、签名后的JAR是否完整。

被签名后的JAR文件，仅仅是在META-INF目录中多了两个额外的文件：

1. 以.SF为扩展名的签名文件
2. 以.DSA、.RSA或者.EC为扩展名的签名块文件

命令格式：

# 进行签名
jarsigner [ options ] jar-file alias
# 校验签名
jarsigner -verify [ options ] jar-file [alias ...]

# 签名一个APK（JAR）文件
jarsigner -keystore ~/Android/Keystores/alexwong.keystore -storepass simple
    -keypass simple -signedjar android-signed.apk android.apk  development

The post Android知识集锦 appeared first on 绿色记忆.