宋志辉
探索云世界
宋志辉
我竭尽全力
命令行工具分成SDK工具和平台工具。 SDK工具 SDK工具跟随SDK安装包安装并随时更新。 Virtual Device 工具 1、 Android Virtual Device Manager 提供了一个图形化的图形用户接口，你可以创建和管理运行在Android虚拟机中的AVD。 2、 Android Emulator 基于QEMU的设备虚拟机，允许你在实时的Android运行环境中调试和测试你的应用。 3、 mksdcard 帮助你创建一个磁盘镜像 Development 工具 1、 Hierarch Viewer 可以方便的查看应用布局。 2、 SDK Manager 允许你管理SDK包。 3、 sqlite3 允许你访问由Android应用创建的SQLite数据文件。 Debugging 工具 1、 Android Monitor 整合到Android Studio中提供logcat，内存，CPU，GPU和网络等功能，为应用提供调试和分析。 2、 adb 一个强大的命令行工具，让你与虚拟机或物理设备进行通信，它同样可以访问设备的shell 3、 ADB Shell命令 可以执行高级的命令行操作 4、 Dalvik Debug Monitor Server（DDMS） 调试你的Android应用 5、 Device Monitor 独立的工具，图形化的用户界面，为Android应用提供调试和分析工具。 6、 Systrace 帮助你分析显示性能问题。 7、 traceview 提供了一个查看你的应用执行日志的图形化视图 8、 Tracer for OpenGL ES 允许你捕获OpenGL ES命令和帧图像。 Build 工具 1、 JOBB 允许你用OOB格式加密和解密APK expansion文件 2、 ProGuard 压缩，优化和模糊你的代码 3、 aipalign 优化apk文件 Image工具 1、 Draw 9-patch 允许你非常容易的创建NinePatch图片。 2、 etc1tool PNG图片工具 Platform工具 平台工具在你更新SDK平台时都会进行更新。每个平台工具都保持了与之前平台的兼容性。如下： 1、 bmgr 一个备份的shell工具。 2、 logcat 提供了收集和查看系统调试输出的机制。 本文作者：宋志辉 个人微博：点击进入
Android Device Monitor是一个独立的工具，可以对Android应用进行调试和分析。Android Device Monitor无需安装整合在一个IDE中，比如像Android Studio，提供如下工具： 1、 DDMS 2、 Tracer for OpenGL ES 3、 Hierarchy Viewer 4、 Systrace 5、 Traceview 6、 Pixel Perfect magnification viewer 运行Android Device Monitor 1、 在Android Studio中，选择Tools > Android > Android Device Monitor，或者点击工具栏。 2、 在命令行，找到SDK的 tools目录，输入如下命令： Monitor 本文作者：宋志辉 个人微博：点击进入
Android Monitor包含GPU Monitor，它将可视化的显示渲染窗体的时间。GPU Monitor可以帮助你： 1、 迅速查看UI窗体生成 2、 辨别是否渲染管道超出使用线程时间 在GPU Monitor中显示一个运行的应用 1、 打开一个项目 2、 在物理设备或者虚拟机中运行应用 3、 显示Android Monitor 4、 点击Monitors表示并且显示GPU Monitor 本文作者：宋志辉 个人微博：点击进入
Android Monitor包含一个CPU Monitor，可以让你非常方便的监测你的应用的CPU的使用。它显示试试的CPU使用。 在CPU Monitor显示正在运行的应用 1、 打开一个项目 2、 在物理设备或虚拟机中运行应用 3、 显示Android Monitor 4、 点击Monitors并且显示CPU Monitor。 如图： 本文作者：宋志辉 个人微博：点击进入
Android Monitor提供了一个Memory Monitor，所以你可以非常容易的监测应用性能和内存使用，可以发现无用的对象，本地内存泄漏和连接设备的内存使用。Memory Monitor显示你的应用如何分配内存，并且用可视化的方式展示出来： 1、 根据时间显示一个图形的可用和已分配的Java内存 2、 根据时间显示垃圾处理事件 3、 初始化垃圾处理事件 Memory Monitor工作流程 为了检测和优化你的内存使用，典型的工作流程是运行你的应用，然后执行如下操作： 1、 使用Memory Monitor检测应用来查看垃圾处理是否对性能造成影响。 2、 如果你在短时间内看到很多垃圾回收事件，可以进行相关的分析 3、 开始分配跟踪来确定是否你的代码有问题。 在Memory Monitor显示一个运行的应用 通过以下步骤，将运行在特定的设备或虚拟机中查看应用： 1、 打开一个项目 2、 在物理设备或虚拟机中运行应用 3、 显示Android Monitor 4、 点击Monitors标签并显示Memory Monitor 本文作者：宋志辉 个人微博：点击进入
Android Monitor帮助你监测你的应用的性能，以帮助你合理的进行优化，调试，提升。如下功能： 1、 Log消息，系统定义的或者开发者定义的。 2、 内存，CPU和GPU使用情况。 3、 网络情况（只能在物理设备中使用） Android Monitor提供了多种工具来查看应用的实时信息。当你的运行时，它会捕获数据，并且保存到一个文件中，你可以在多个视图进行分析。你也可以在应用运行的时候进行截图和录像。 Log消息 .查看Log消息，实时的或历史数据。可以帮助你进行调试。（logcat Monitor）。 性能监控 可以可视化的查看你的应用。包含的工具： 1、 Memory Monitor 计算内存使用，找到未使用的对象，本地内存泄漏，连接设备的内存使用。 2、 CPU Monitor 实时显示CPU使用。 3、 GPU Monitor 可视化显示渲染一个UI窗体花费时间。 4、 Network Monitor 分析网络请求，包含你的应用如何以及何时传递数据。 数据分析 Android Monitor允许你在你的应用的运行时捕获多种类型的数据，并且保存到文件中，可以方便的进行查看： 1、 HPROF 查看和分析 显示类，每个类的实例 2、 Allocation Tracker 捕获你的应用的数据分配。 3、 Method Trace 4、 系统信息 截图和录像 前章已经阐述 本文作者：宋志辉 个人微博：点击进入
显示图像包含四个步骤。简单来说，CPU对比显示列表，GPU渲染图片显示，内存存储图片和数据，电池提供点力能源。每个部分的硬件都有限制，超过这个限制会导致应用运行较慢，显示性能差，或者耗电。 为了查找造成这些问题的原因，你需要深层的查找原因，使用工具来收集你的应用执行时的数据。用列表和图像的方式呈现，进行理解和分析，从而优化你的代码。 Android Studio和你的设备提供了优化工具来记录和可视化你的应用渲染，计算，内存和耗电量情况。 注意：当你使用优化工具时，需要禁用Instant Run。 本文作者：宋志辉 个人微博：点击进入
Android Monitor允许你从设备中录制一段MP4格式的视频，最长允许3分钟。 录制视频 在硬件设备中录制视频： 1、 打开一个项目 2、 在设备中运行应用 3、 显示Android Monitor 4、 准备录制 5、 在Android Monitor中点击Screen Record 6、 点击 Start Recording开始录制 7、 点击 Stop Recording停止录制 8、 在Save As对话框，保存为MP4文件 本文作者：宋志辉 个人微博：点击进入
Android Monitor允许你截取连接的设备或者虚拟机的屏幕，保存为PNG格式。 设备截图 1、 打开一个项目 2、 在设备或虚拟机中运行应用 3、 显示Android Monitor 4、 切换到你想要截屏的界面 5、 在Android Monitor工具栏中点击Screen Capture 6、点击Save保存图片。 本文作者：宋志辉 个人微博：点击进入
Android Studio在Android Monitor中包含了一个logcat的tab，可以打印系统事件，比如垃圾回收发生时，实时打印应用消息。 为了显示需要的信息，你可以创建过滤器，更改需要显示多少信息。设置优先层，显示应用打印的消息，或者搜索日志。默认情况下。Logcat监视器显示最近运行的app的日志输出。 当一个应用抛出一个异常，Logcat监视器会显示一条相应的消息。 编写Log消息 可以打印如下日志： 1、 Log.e（String，String）（输出错误） 2、 Log.w（String，String）（警告） 3、 Log.i（String，String）（信息） 4、 Log.d（String，String）（调试） 5、 Log.v（String，String）（verbose） Logcat消息格式 如下格式： date time PID-TID/package priority/tag: message 在logcat监视器中显示一个运行的应用 1、 打开一个项目 2、 在设备或虚拟机中运行你的应用 3、 显示Android监视器 4、 点击logcat标签 默认情况下，logcat监视器仅仅显示你的设备或虚拟机中你的运行的应用的日志信息： 设置日志级别 有如下级别： 1、 Verbose ：显示所有日志消息。 2、 Debug ：显示在开发过程中有用的日志消息。 3、 Info ：显示一些普通的信息 4、 Warn ：显示警告信息。 5、 Error ：显示错误日志消息。 6、 Assert ：显示开发者期望不会发生的事。 本文作者：宋志辉 个人微博：点击进入
Android Studio包含了一个调试器，允许你调试运行在Android虚拟机或连接的Android设备的应用。通过Android Studio的调试器，你可以： 1、 选择你调试设备的app 2、 为你的代码设置断点 3、 在运行时检测变量和表达式 4、 截图和录像 通过点击工具栏中的Debug按钮来开始调试，Android Studio生成一个APK，并且使用调试key进行签名，安装到选定的设备中运行并打开调试Debug窗口。 如果点击Debug后，在Select Deployment Target窗口没有出现任何设备，你需要连接一台设备或者创建一个虚拟机。 如果你的app已经运行在一个连接的设备或虚拟机中，你可以通过如下方式开始运行： 1、 点击Attach debugger to Android process 2、 在Choose Process 对话框，选择进程。 3、 点击OK Debug窗口出现。 4、 点击Terminate结束调试。 使用系统日志 系统日志显示了你调试app时的系统信息。这些消息包含你app运行在设备中的信息。如果你想用系统日志来调试你的app，确保你写了打印日志的相关代码。 在你的代码中打印日志消息 在你的代码中打印日志消息，使用Log类。如下： import android.util.Log; ... public class MyActivity extends Activity { private static final String TAG = MyActivity.class.getSimpleName(); ... @Override public void onCreate(Bundle savedInstanceState) { if (savedInstanceState != null) { Log.d(TAG, "onCreate() Restoring previous state"); /* restore state */ } else { Log.d(TAG, "onCreate() No saved state available"); /* initialize app */ } } } 在开发过程中，你可以捕获异常并打印stack trace到系统日志： void someOtherMethod() { try { ... } catch (SomeException e) { Log.d(TAG, "someOtherMethod()", e); } } 查看系统日志 在Android DDMS工具窗口中查看系统日志： 1、 在调试模式启动你的APP 2、 点击Android Monitor 3、 如果在Logcat视图中系统日志是空的，点击Restart。 Android DDMS工具窗口给你从Android Studio中访问DDMS某些特性的权限。 系统日志显示来自Android服务和其他Android应用的消息。通过以下方式进行过滤： 1、 显示特定进程的日志消息，在Devices视图中选择相应进程，然后点击Click Show Logcat from Selected Process。如果你的Devices视图没出点，点击Android DDMS工具窗口右边的Restore Devices View，这个按钮仅仅在你隐藏了Devices窗口时才可用。 2、 也可以根据log level来过滤 3、 也可以在输入框中输入特定的字符串，点击回车。 断点 Android Studio支持多种不同的断点来触发不同的调试动作。最常用的是行断点，应用在特定的行停止。暂停时，你可以检查变量，表达式，也可以单步执行来确定运行错误的原因。 添加一个行断点，可以按照以下方式： 1、 找到你需要执行到暂停的行，点击代码编辑器的左边，或者将光标移动到指定的行，店家Ctrl+F8。 2、 如果你的应用已经运行，直接单击Attach debugger to Android process。 当你的代码执行到断点的位置，Android Studio暂停了你的应用的执行。你可以使用调试器中的工具来查找错误的原因。 查看和配置断点 查看所有的断点和配置断点设置，点击Debug窗口左边的View Breakpoints，如图： Breakpoints窗口允许你开启和禁用左边列表的每个断点。如果断点被禁用，Android Studio在到达这个断点时不会停止。 本文作者：宋志辉 个人微博：点击进入
默认情况下，在你的Gradle构建设置中有两种构建类型：一种是为了调试你的应用，debug类型；一种是构建最终的发布版本，release类型。无论你使用哪种模式，你的app必须在安装到设备或虚拟机中之前进行签名。当时debug类型时，使用一个调试key，当时release类型时，使用一个release key。 无论你使用debug或者release类型来构建，你需要运行和构建你的模块。这将会创建一个apk文件，你可以安装文件到你的虚拟机或者设备中。当你使用debug构建类型，apk文件会自动的被SDK工具用debug key进行签名。当你使用release构建类型的时候，apk文件是没有签名的，你必须手动用你的key对apk进行签名。 注意：当你使用ant并且在Windows中安装JDK，默认安装到Program Files中。因为包含空格，可能会导致ant失败。为了修复这个问题，你可以通过如下方式什么JAVA_HOME变量： set JAVA_HOME=c:\Progra~1\Java\<jdkdir> 更简单的方式，是将JDK安装到没有空格的目录。比如： c:\java\jdk1.7 你可以声明你的项目使用Gradle版本，如下： gradle wrapper --gradle-version version-number 在调试模式构建 为了方便测试和调试，你可以在debug模式构建你的APP并安装在虚拟机中。在调试模式，构建工具自动用一个debug的key为你的应用签名并且aipalign进行优化。 为了在debug模式进行构建，打开命令行，找到你的项目的根目录，在windows下，执行： gradlew.bat assembleDebug 在Mac OS或Linux平台，输入如下命令： $ chmod +x gradlew $ ./gradlew assembleDebug 在Release模式构建 在windows运行如下命令： > gradlew.bat assembleRelease 在Mac OS或者Linux平台，运行如下命令： $ ./gradlew assembleRelease 这是未签名版本的生成方式。 本文作者：宋志辉 个人微博：点击进入
当应用代码和库代码代码超过64K限制时，早期版本的构建系统会出现如下提示： Conversion to Dalvik format failed: Unable to execute dex: method ID not in [0, 0xffff]: 65536 最近版本的构建系统会出现如下提示，指出同样的错误： trouble writing output: Too many field references: 131000; max is 65536. You may try using --multi-dex option. 其实都是相同的问题，只是提示方式不一样。 关于64K限制 APK文件包含由DEX文件组成的可执行的字节码文件，包含运行app编译后的代码。DEX文件有一个65535个方法的限制，如果超过这个限制，会在构建的时候报错。这些方法包含Android Framework方法，库方法和你自己写的方法。因为65535=64*1024，所以这个限制又被称为64K限制。 Android5.0之前的版本的多dex支持 在Android5.0之前，使用Dalvik运行时来执行应用代码。默认情况下，在每个APK中，Dalvik限制一个classes.dex 字节码文件。为了突破这个限制，你可以使用multidex support library。 注意：如果你的项目配置多dex的最小SDK版本为20甚至更低，Android Stuido将禁用Instant Run。 Android5.0及以上的版本的多dex支持 Android5.0（API level 21）或更高的版本，使用ART运行时在执行应用代码。原生的支持从APK文件中直接载入多个dex文件。 避免64K限制 下面的方法可以帮助你减少dex方法的限制： 1、 查看你的app的直接的或间接的依赖： 尽量减少不必要的依赖的引用。 2、 通过ProGuard来减少未使用的代码： 通过配置ProGuard来启用ProGuard，确保你在发布版本的时候启用了压缩。 用Gradle来配置你的应用的多dex 在Android SDK Build Toos 21.1或更高的版本中，Android的Gradle插件在你的构建配置中提供了multidex的支持。在尝试配置你的multidex之前，确保你的Android SDK Build Tools和Android Support Repository升级到最新版本。 设置你的开发的app使用multidex，你需要对你的开发项目作出一些改动，遵循如下几步： 1、 更改你的Gradle构建配置来启用multidex。 2、 更改你的manifest来添加MultiDexApplication类。 更改你的build.gradle文件配置来添加支持库并且启用multidex输出，如下： android { compileSdkVersion 21 buildToolsVersion "21.1.0" defaultConfig { ... minSdkVersion 14 targetSdkVersion 21 ... // Enabling multidex support. multiDexEnabled true } ... } dependencies { compile 'com.android.support:multidex:1.0.0' } 在AndroidManifest.xml中，添加MultiDexApplication类： <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.android.multidex.myapplication"> <application ... android:name="android.support.multidex.MultiDexApplication"> ... </application> </manifest> 当你添加如上配置到你的app中，Android 构建工具生成一个主要的dex文件（classes.dex）和支持多个（classes2.dex，classes3.dex）。构建系统将它们打包到一个APK中发布。 多Dex支持库的局限 Multidex支持库有一些你需要了解的局限： 1、 在某种情况下可能会导致ANR问题，如果第二个dex文件过大的话。为了防止这个问题发生，你需要使用ProGuard来进行压缩。 2、 在Android4.0极其早期版本中会遇到一些问题。 3、 应用的multidex配置会需要更大的内存分配，这在Dalvik虚拟机中会导致崩溃。 4、 其他复杂的情形。 优化Multidex开发构建 Multidex配置会显著的增加构建时间，因为构建系统必须来衡量将那些类放到住Dex文件中，那些类放到第二个dex文件中。这就意味着会拖慢开发进程。 为了有效减缓构建multidex输出的时间，你需要使用Android 插件创建两个variantion： 一个开发flavor和一个生产flavor。 如下： android { productFlavors { // Define separate dev and prod product flavors. dev { // dev utilizes minSDKVersion = 21 to allow the Android gradle plugin // to pre-dex each module and produce an APK that can be tested on // Android Lollipop without time consuming dex merging processes. minSdkVersion 21 } prod { // The actual minSdkVersion for the application. minSdkVersion 14 } } ... buildTypes { release { runProguard true proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } } dependencies { compile 'com.android.support:multidex:1.0.0' } 本文作者：宋志辉 个人微博：点击进入
为了让你的APK文件尽可能的小，你需要在构建的时候开启压缩来移除无用的代码和资源。 代码压缩可在ProGuard中使用，可以检测和清除无用的类，变量，方法和属性，甚至包括你引用的库。ProGuard同样可以优化字节码，移除无用的代码，并且模糊剩下的类，变量和方法。代码模糊可以让增加APK逆向工程的成本。 资源压缩可在Andorid的Gradle插件中使用，可以清除你打包的APP中无用的资源，包含你引用的库中的无用的资源。 压缩你的代码 为了启用ProGuard的代码压缩，需要在build.gradle中添加minifyEnabled true。 需要注意的是，代码压缩会拖慢构建速度，所以，如果可能的话，尽量避免在debug构建是使用。 如下： android { buildTypes { release { minifyEnabled true proguardFiles getDefaultProguardFile(‘proguard-android.txt'), 'proguard-rules.pro' } } ... } 注意：Android Studio在使用Instant Run时会禁用ProGuard。 自定义哪些代码需要保留 在很多情况下，ProGuard很难正确的去分析，它可能会清除你的app需要的代码。 1、 当你的app从AndroidManifest.xml中引用一个类时 2、 当你的app调用一个JNI方法 3、 当你的app使用反射来控制代码 为了避免这个问题，需要使用-keep，如下： -keep public class MyClass 同样，可以添加@Keep注解来实现。 压缩你的资源 资源压缩需要跟代码压缩一起才能正常使用。在代码压缩出去所有的无用的代码之后，才能辨别哪些资源仍然未被使用。如下： android { ... buildTypes { release { shrinkResources true minifyEnabled true proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } } 自定义哪些资源需要保留 如果这里有些特别的资源你需要保留或丢弃，在你的项目中创建一个包含标签的XML文件，用tools:keep指明需要保留的资源，用tools:discard指明需要丢弃的文件。 比如： <?xml version=1.0" encoding="utf-8"?> <resources xmlns:tools="http://schemas.android.com/tools" tools:keep="@layout/l_used*_c,@layout/l_used_a,@layout/l_used_b*" tools:discard="@layout/unused2" /> 本文作者：宋志辉 个人微博：点击进入
每个版本的build variant代表了你可以构建的每一个版本。虽然你未直接配置build variants，你可以通过配置build type和product flavor。 比如，一个demo的product flavor可以声明不同的特性和设备需求，比如自定义源码，资源和最小的API。但是debug的build type却有不同构建和打包设置，比如调试选项和签名文件。 配置Build Types 你可以在模块的build.gradle文件里的android{}区块中来创建和配置构建类型。当你创建一个新的模块的时候，Android Studio自动为你创建debug和release。虽然debug构建类型不出现在构建配置文件中，Android Studio通过debuggable true来配置。这会允许你在一个安全的Android设备中调试app，并且使用一个通用的debug的keystore对APK进行签名。 如果你想添加或更高确定的设置，你可以添加debug构建类型到你的配置中。接下来的例子声明为debug构建类型声明了一个applicationIdSuffix。并且配置一个jnidebug构建类型，设置其根据debug构建类型进行初始化。 android { ... defaultConfig {...} buildTypes { release { minifyEnabled true proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } debug { applicationIdSuffix ".debug" } /** * The 'initWith' property allows you to copy configurations from other build types, * so you don't have to configure one from the beginning. You can then configure * just the settings you want to change. The following line initializes * 'jnidebug' using the debug build type, and changes only the * applicationIdSuffix and versionNameSuffix settings. */ jnidebug { // This copies the debuggable attribute and debug signing configurations. initWith debug applicationIdSuffix ".jnidebug" jniDebuggable true } } } 配置Product Flavor 创建product flavor跟创建构建类型相同：将其添加到productFlavors{}区块中，并且配置你需要的设置。Product flavors支持defaultConfit，这是因为defaultConfig属于ProfuctFlavor类。这就意味着你可以为所有的Flavors在defaultConfig{}提供基本的配置。每个flavor可以复写任何这些默认值。比如applicationId。 注意：你仍然需要在manifest文件中的package属性中来声明包名。 以下是一个代码示例，创建一个demo和full的product flavor，并设置了他们自己的applicationId和versionName。 android { ... defaultConfig {...} buildTypes {...} productFlavors { demo { applicationId "com.example.myapp.demo" versionName "1.0-demo" } full { applicationId "com.example.myapp.full" versionName "1.0-full" } } } 在你创建和配置你的product flavor之后，点击消息提示条中出现的Sync Now按钮。在同步完成后，Gradle根据你的构建类型和product flavor自动创建build variants，并且用＜product-flavor＞。比如，如果你创建demo和full两个product flavor，并且保持debug和release为默认，Gradle则会创建以下build variants： 1、 demoDebug 2、 demoRelease 3、 fullDebug 4、 fullRelease 为Build Variants创建Source Sets 默认情况下，Android Studio创建main/ source set和目录在所有的build variants中共享。然而，你可以创建新的source sets来控制Gradle编译和特定的build types，product flavors和build variants。例如，你可以在main/ source set中定义基本的功能，使用product flavor source sets来改变你的app的东西，包括权限和日志等。 Gradle希望你通过确定的方式来组织source set文件和目录。 Android的Gradle插件提供了一个非常有用的Gradle 任务来显示你如何为乜咯build type，product flavor和build variants来组织你的文件。比如，以下的报告部分描述了Gradle希望找到debug 的build type的特定的文件： ------------------------------------------------------------ Project :app debug Compile configuration: compile build.gradle name: android.sourceSets.debug Java sources: [app/src/debug/java] Manifest file: app/src/debug/AndroidManifest.xml Android resources: [app/src/debug/res] Assets: [app/src/debug/assets] AIDL sources: [app/src/debug/aidl] RenderScript sources: [app/src/debug/rs] JNI sources: [app/src/debug/jni] JNI libraries: [app/src/debug/jniLibs] Java-style resources: [app/src/debug/resources] 为了生成和查看你的构建配置的报告，遵循如下： 1、 点击右面的IDE窗口 2、 找到MyApplication > Tasks > android，双击sourceSets 3、 查看报告，点击IDE窗口底部的Gradle Console 当你创建一个新的build variant，Android Studio不会为你创建一个source set 目录，但是会给你一些选项来帮助你。比如，为你的debug构建类型创建java/目录： 1、 打开项目面板，选择Project视图 2、 找到MyProject/app/src 3、 右键单击src目录，选择New > Folder > Java Folder 4、 在下拉中找到Target Source Set，选择debug 5、 点击Finish Android Studio为你的debug构建类型创建一个source set目录，然后创建一个java/目录到里面。你同样可以让Android Studio为特定的build variant创建的新的文件来创建相应的目录。比如，为你的debug构建类型创建一个values XML文件： 1、 在Project面板中，右键单击src目录，选择New > XML > Values XML File 2、 输入XML文件名字，或者保持默认。 3、 在下拉中找到Target Source Set，选择debug 4、 点击Finish 因为debug构建类型是针对特定的source set，Android Studio在创建XML文件时自动创建必要的目录。如图： 本文作者：宋志辉 个人微博：点击进入
Android构建系统编译你的app资源和源码并且打包到APK中，你可以用来测试，部署，签名和发布。Android Studio使用Gradle，一个高级的构建套件，来自动化和管理构建进程，同时可以允许你灵活的自定义构建配置。每个构建配置可以定义它自己的代码和资源集合。 Gradle和Android插件独立于Android Studio运行。这就意味着你可以在你的机器上在命令行、Android Studio、或者没有安装Android Studio的机器中构建你的Android APP。 Android构建系统的灵活性允许你在不修改你的APP核心代码的情况下运行自定义的构建配置。 构建进程 构建进程包含很多工具和进程来帮助将你的项目转化为APK（Android Application Package）。构建进程非常灵活。 遵循如下几步： 1、 编译器将你的源码转化为DEX（Dalvik Executable）文件，包含Android设备中可以运行的字节码和其他编译的资源文件。 2、 APK打包工具将DEX文件和编译后的资源打包到一个单独的APK中，但是在你安装和部署之前，APK必须进行签名。 3、 APK打包工具会用debug key或者release key对你的APK进行签名。 4、 在你生成最终的APK之前，打包工具只用aipalign工具来优化你的代码。这可以在app运行时降低内存。 自定义构建配置 Build Types 构建类型定义在构建和打包app是Gradle使用的一些属性配置。在不同的开发周期是不同的。比如，debug 构建类型开启调试选项并且使用debug key对APK进行签名。而release 构建类型可能需要压缩、模糊并且使用release key对APK进行签名。为了构建你的app，你必须至少声明一种类型。 Product Flavors Product flavors代表发布给用户的不同版本的APP。比如，免费和付费的APP版本。你可以通过定制Product flavors来使用不同的代码和资源，同时共用所有版本APP可复用的部分。Product Flavors是可选的，你必须手动创建它们。 Build Variants Build variant是build type和product flavor混合的产物。这是Gradle用来构建你的app的相关配置。通过使用build variant，你可以在开发中构建你的product flavor的debug版本，或者product flavor的签名的发布版本。虽然你没有直接配置build variant，你可以通过配置build type和product flavor来实现对build variant的配置。创建额外的build type或者product flavor同样可以创建额外的build variant。 Mainfest Entries 你可以在build variant配置里声明manifest文件里的一些属性值。这些值会腹泻manifest文件中已经存在的值。 Dependencies 构建系统管理项目的依赖，从本地的依赖到远程的依赖。这个可以让你方便的对依赖进行管理。 Signing 构建系统允许你在构建配置中声明签名设置，这可以在你构建的时候自动的对你的APK进行签名。构建系统不会对release版本进行签名，除非你定义一个签名配置。 ProGuard 构建系统允许你为每一个build variant声明一个不同的ProGuard规则文件。 构建配置文件 创建自定义的配置需要你对一个或多个构建配置文件进行更改，或者build.gradle文件。这些文本使用DSL来描述和控制构建逻辑。 当你创建一个新的项目时，Android Studio自动为你创建一些文件，如图： 这是一些Gradle构建配置文件，作为Android应用标准项目结构的一部分。 Gradle设置文件 gradle.settings文件位于项目的根目录下，来通知Gradle在构建你的应用的时候需要包括哪些模块，大部分项目如下： include ‘:app’ 顶层的构建文件 位于项目根目录的build.gradle文件，定义了可以应用于你的项目的所有模块的构建配置。默认情况下，顶层的构建文件在buildscript{}中定义Gradle repositories和依赖，这可以应用到项目的所有的模块中。如下： /** * The buildscript {} block is where you configure the repositories and * dependencies for Gradle itself--meaning, you should not include dependencies * for your modules here. For example, this block includes the Android plugin for * Gradle as a dependency because it provides the additional instructions Gradle * needs to build Android app modules. */ buildscript { /** * The repositories {} block configures the repositories Gradle uses to * search or download the dependencies. Gradle pre-configures support for remote * repositories such as JCenter, Maven Central, and Ivy. You can also use local * repositories or define your own remote repositories. The code below defines * JCenter as the repository Gradle should use to look for its dependencies. */ repositories { jcenter() } /** * The dependencies {} block configures the dependencies Gradle needs to use * to build your project. The following line adds Android Plugin for Gradle * version 2.0.0 as a classpath dependency. */ dependencies { classpath 'com.android.tools.build:gradle:2.0.0' } } /** * The allprojects {} block is where you configure the repositories and * dependencies used by all modules in your project, such as third-party plugins * or libraries. Dependencies that are not required by all the modules in the * project should be configured in module-level build.gradle files. For new * projects, Android Studio configures JCenter as the default repository, but it * does not configure any dependencies. */ allprojects { repositories { jcenter() } } 模块构建文件 模块的build.gradle文件，位于//目录下，允许你对特定的模块进行构建配置。配置这些构建设置允许你提供自定义的打包选项，比如额外的build type和product flavor，复写mainfies中的设置或者顶层build.gradle文件的配置。代码如下： /** * The first line in the build configuration applies the Android plugin for * Gradle to this build and makes the android {} block available to specify * Android-specific build options. */ apply plugin: 'com.android.application' /** * The android {} block is where you configure all your Android-specific * build options. */ android { /** * compileSdkVersion specifies the Android API level Gradle should use to * compile your app. This means your app can use the API features included in * this API level and lower. * * buildToolsVersion specifies the version of the SDK build tools, command-line * utilities, and compiler that Gradle should use to build your app. You need to * download the build tools using the SDK Manager. */ compileSdkVersion 23 buildToolsVersion "23.0.3" /** * The defaultConfig {} block encapsulates default settings and entries for all * build variants, and can override some attributes in main/AndroidManifest.xml * dynamically from the build system. You can configure product flavors to override * these values for different versions of your app. */ defaultConfig { /** * applicationId uniquely identifies the package for publishing. * However, your source code should still reference the package name * defined by the package attribute in the main/AndroidManifest.xml file. */ applicationId 'com.example.myapp' // Defines the minimum API level required to run the app. minSdkVersion 14 // Specifies the API level used to test the app. targetSdkVersion 23 // Defines the version number of your app. versionCode 1 // Defines a user-friendly version name for your app. versionName "1.0" } /** * The buildTypes {} block is where you can configure multiple build types. * By default, the build system defines two build types: debug and release. The * debug build type is not explicitly shown in the default build configuration, * but it includes debugging tools and is signed with the debug key. The release * build type applies Proguard settings and is not signed by default. */ buildTypes { /** * By default, Android Studio configures the release build type to enable code * shrinking, using minifyEnabled, and specifies the Proguard settings file. */ release { minifyEnabled true // Enables code shrinking for the release build type. proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } /** * The productFlavors {} block is where you can configure multiple product * flavors. This allows you to create different versions of your app that can * override defaultConfig {} with their own settings. Product flavors are * optional, and the build system does not create them by default. This example * creates a free and paid product flavor. Each product flavor then specifies * its own application ID, so that they can exist on the Google Play Store, or * an Android device, simultaneously. */ productFlavors { free { applicationId 'com.example.myapp.free' } paid { applicationId 'com.example.myapp.paid' } } } /** * The dependencies {} block in the module-level build configuration file * only specifies dependencies required to build the module itself. */ dependencies { compile project(":lib") compile 'com.android.support:appcompat-v7:22.0.1' compile fileTree(dir: 'libs', include: ['*.jar']) } Gradle属性文件 Gradle也包括两个属性文件，在项目的根目录。你可以用来声明Gradle构建套件的设置： Gradle.properties 这里你可以设置全局Gradle设置。 Local.properties 为你的构建系统配置本地环境属性，比如SDK安装位置。因为这个文件的内容是Android Studio自动生成的，针对本地的开发环境，所以你不需要手动更改这个文件或者将其添加到你的版本控制系统中。 使用Gradle同步项目 当你更改了你的项目中的构建配置文件之后，Android Studio需要你同步你的项目，这样你就可以导入你的项目配置并且运行一些检测来确保你的配置不会导致创建构建错误。 同步你的项目文件，在你更改之后，会有个提示框，点击Sync Now。如果发现问题，Android Studio会报错： Source Sets Android Studio为每个模块合理的组织代码和资源。一个模块的main目录包含了代码和资源。 本文作者：宋志辉 个人微博：点击进入
当你构建一个Android应用时，在发布给用户之前，在物理设备上测试一下你的应用是非常必要的。 你可以使用Android设备作为运行、调试和测试应用的环境。包含在SDK中的工具让你在编译完成后在设备中安装和运行应用更加方便。你可以直接从Android Studio中安装你的应用到设备中，或者用ADB在命令行安装。 开启设备中的开发者选项 Android设备提供了一系列的可以让你访问手机的开发者选项，可以让你： 1、 开启USB调试模式 2、 迅速的捕获bug 3、 在屏幕上显示CPU使用情况 4、 绘制调试信息。 为了访问设置，打开系统设置中的开发者选项。在Android4.2或更高的版本中，开发者选项默认是隐藏的。找到Settings > About phone，点击Build number几次，可以显示出来。返回之前的屏幕，找到开发者选项即可。 设置一个设备的开发环境 在开始之前，执行如下几步： 1、 查看build.gradle中是否设置为可调式的。如下： android { buildTypes { debug { debuggable true } 2、 找到Settings > Developer options，开启调试模式。 3、 设置你的系统能够侦测到设备（安装驱动）。 本文作者：宋志辉 个人微博：点击进入
Android虚拟机Monitor一个设备并且显示在你的开发计算机上。它可以允许你在不适用硬件设备的情况下开发、测试你的Android应用。虚拟机支持Android手机，Android Wear和平板和Android TV设备。因为它有一些预定义的设备类型，所以你可以迅速的启动，同样你可以创建你自己的设备。 虚拟机是一个快速、强大和多功能。它比一个连接的物理设备更快的传递信息，提升开发进程。 关于Android虚拟机 当你运行你的项目的时候可以在虚拟机中运行你的项目，或者直接拖动一个APK到虚拟机中安装。就像在一个物理设备中一样，你在虚拟设备中安装了一个app之后，它会保留直到卸载或者替换。 Android虚拟机特性预览 Android虚拟机配置 虚拟机用Android Virtual Device（AVD）来决定外观、功能和虚拟设备的系统镜像。AVD允许你定义多个虚拟设备。 每个AVD可以视为单独的设备，有它用户数据、SD卡等等。当你通过AVD配置运行虚拟机，它会自动从AVD目录自动载入用户数据和SD卡数据。默认情况下，虚拟机将用户数据，SD卡数据和缓存保存在AVD目录下。 系统镜像 Android虚拟机运行了一个完整的Android系统栈，从最底层的内核，到一些预装的应用。在你创建AVD的时候，你可以选择你需要的Android镜像版本。 依赖和先决条件 Android虚拟机需要以下先决条件： 1、 Android Studio 2.0或更高 2、 SDK Tools 25.0.10 或更高 不支持 Android虚拟机支持一个设备的大部分特性，但是不包括以下这些： 1、 WiFi 2、 Bluetooth 3、 NFC 4、 SD卡 5、 设备连接耳机 6、 USB 在Android虚拟机中运行APP 在可以在一个Android Studio项目中运行一个app。或者，你可以直接运行安装在虚拟机中的app。以下方式打开虚拟机： 1、 打开Android Studio ，选择Run 然后出现Select Deployment Target对话框 2、 在Select Deployment Target对话框，选择一个已经存在的虚拟机，点击OK 3、 在你的虚拟机中测试你的app。 本文作者：宋志辉 个人微博：点击进入
默认情况下，Android Studio可以通过简单的点击就会将新的项目部署到虚拟机或者物理设备中。在Instant Run的帮助下，你可以将更改的方法或资源文件直接推送到一个运行的app而无需构建一个新的APK，所以看起来像实时的。 构建和运行你的app，点击Run’app’。Android Studio会让你选择一个部署目标（一个虚拟机或者一个连接的设备），使用Gradle进行构建，构建完成后将部署到目标上。 如果你使用Android虚拟机来运行你的app，你需要有一个Android Virtual Device（AVD）。如果没有可以先创建一个，然后再运行app。点击Select Deployment Target对话框中的Create New Emulator，跟随虚拟设备配置向导定义你想要的虚拟机的信息。 如果你使用一个物理Android设备，你需要在设备中开启USB调试。 选择和构建不同的模块 如果你的项目除了默认的app模块还有多个模块，你可以通过如下方式构建指定模块： 在Project视图中选择这个模块，然后点击Build > Make Module （模块名称） Android Studio使用Gradle对模块进行构建。一旦构建完成，你可以运行和调试。 改变运行或调试配置 运行和调试配置控制模块的运行、部署、启动Activity，目标设备，虚拟机设置，logcat选项等等。默认的运行和调试配置运行项目默认的Activity，使用Select Deployment Target对话框来选择目标设备。 更改构建变量 默认情况下，在你点击Run‘app’的时候，Android Studio构建你的app的调试版本，为了调试版本。 改变Android Studio得构建变量，可以在Build > Select Build Variant，在下拉菜单中选择。默认情况下，新的项目默认有debug和release两个选项。 监控构建进程 你可以通过点击Gradle Console来查看构建进程的细节。控制台显示的是为了构建你的应用Gradle执行的每个任务。 生成APK 当你点击Run ‘app’，Android Studio生成一个调试APK并且部署到目标设备中。在你生成一个app正式版进行发布之前，你必须学会如何对app进行签名。 关于Instant Run Instant Run是Android Studio 2.0引入的，Instan Run可以显著减少应用的部署时间。虽然第一次部署需要花费很多时间构建完成，但是Instan Run可以将你的更改迅速的应用的app中而无需安装一个新的APK。 只有你的APK是debug，并且Gradle 的Android插件版本是2.0.0或高于，最小sdk版本是15或更高时，才能使用。 当你部署一个app时，一个黄色闪电图标出现在Run按钮上，提示Instant Run会在你下次点击这个按钮时会把更新推送到设备或虚拟机，而无需安装一个新的APK，仅仅是推送更新，在大部分时候，甚至不需要更新就可以立刻显示效果。 Instant Run通过热部署，暖部署或者冷部署将最新的代码和资源，Instant Run会根据你的更改类型来决定部署类型。 使用Rerun 当你的代码更改会影响初始化，比如应用的onCreate方法的更改。你需要重启你的应用来使更改生效。点击Rerun。 如果你需要部署一个干净的构建，在主菜单中选择Run > Clean and Rerun ‘app，或者在点击Rerun时按住Shift键。这会停止正在运行的app，部署一个新的APK到你的目标设备中。 禁用Activity自动重启 当你执行热部署的时候，你的应用保持运行，但是Android Studio会自动重启当前的activity。以下可以禁止这个默认设置： 1、 打开Settings或者Preferences对话框 2、 导航到Build、Execution、Deployment>Instant Run 3、 取消Restart activity on code changes 的打钩。 禁用后，你可以通过选择Run > Restart Activity手动启动。 为Instant Run配置和优化你的项目 Android Studio在使用Gradle Android插件2.0.0或更高版本的项目中默认开启Instant Run。为了更新一个存在的项目的Gradle插件到最新版本，可以执行如下几步： 1、 打开Settings 或者Preferences对话框 2、 导航到Build、Execution，Execution, Deployment > Instant Run并且选择Update Project 如果没有出现，说明已经是最新版本。 通过配置DEX资源来提升构建时间 当你部署了一个应用，Android Studio允许你的app使用Instant Run来推送代码和资源更新。虽然，在应用运行的时候推送更新更加迅速，但是第一次需要花费一定时间来构建。你可以通过一些DexOptions来提升构建进程： MaxProcessCount： 设置DEX进程的最大数。 javaMaxHeapSize： 设置最大分配的内存 Instant Run的限制 Instant Run设计成在大部分情形下提升你构建和部署进程的速度。然而，在某些时候可能不适用。 部署到多个设备 Instan Run根据目标设备的API不同使用不同的技术来实现热部署，冷部署。因为这个原因，当应用同时部署到多个设备，Android Studio会暂时关闭Instant Run。 多个DEX 如果你在build.gradle中设置multiDexEnabled true和minSdkVersion 20或更低，并且你部署的目标设备运行Android4.4或更低，Android Studio禁用Intant Run。 如果你的minSdkVersion为21或更高，Instant Run自动配置你的应用的多dex。 使用第三方插件 Android Studio在使用Instant Run时会暂时禁用Java Code Coverage Library（JaCoco）和ProGuard。这不影响你的构建。 禁用Instant Run 通过如下方式禁用Intant Run： 1、 打开Settings或者Preferences对话框 2、 导航到Build, Execution, Deployment > Instant Run 3、 取消选定Enable Instant Run. 本文作者：宋志辉 个人微博：点击进入
如果你的应用支持多语言，你需要合理的管理你的翻译的string资源。Android Studio 提供了翻译编辑器来使查看和管理翻译的资源更加容易。 关于翻译编辑器 翻译后的资源在你的项目里保存在不同目录下的不同XML文件中。手动查找和编辑这些文件非常困难。因为你的应用可能因为疏忽而导致有些翻译被遗漏。 翻译编辑器允许你在一个地方方便的查看和更新你所有的string资源。编辑器给你一个视图来查看所有的你的翻译的资源，让更改和添加甚至查找遗漏的翻译更加方便。 运行翻译编辑器 执行以下步骤： 1、 在Android Studio左边的Project窗口，选择Android视图。 2、 打开res文件夹，然后打开values文件夹 3、 如果找到string.xml文件夹，打开这个文件夹 4、 邮件单击strings.xml（不是文件夹），选择Open Translations Editor 管理String资源 翻译编辑器提供了查看所有你的string资源的视图和当前的本地化翻译。可以在视图中进行操作。 本文作者：宋志辉 个人微博：点击进入
Draw 9-patch工具是一个所见即所得编辑器，允许你创建可以自动改变大小来适应视图的内容和屏幕的大小。 以下是使用Draw 9-path工具快速创建一个NinePatch图片。 1、 在命令行中，找到你的sdk/tools目录，运行draw9patch来运行Draw 9-patch工具 2、 拖动你的PNG文件到Draw 9-patch窗口（或者选择File > Open 9-patch…来定位文件） 左边是你的绘制区域，在这里你可以编辑可伸缩的部分和内容区域，右边的是预览区域，可以对你拉伸后的图片进行预览。 3、 在一像素宽度的边界绘制线条来定义伸缩区域和内容区域，右键单击擦除之前的线条。 4、 完成后，选择File > Save 9-patch… 你的图片将会保存为.9.png文件名。 可选控制： 1、 Zoom：调整绘制区域的缩放级别 2、 Patch scale：调整预览区域的图片尺寸 3、 Show patches：预览可拉伸的区域 4、 Show content：预览内容区域 5、 Show bad patches：显示绘制不正确的区域 本文作者：宋志辉 个人微博：点击进入
Android Studio包含一个Vector Asset Studio的工具，可以帮助你添加Material图标和导入SVG（Scalable Vector Graphic）文件到你的项目中作为向量drawable资源。使用向量drawable资源来代替图片可以减少APK的大小，因为同样一个文件可以在不损失图片质量的情况下改变大小来适应不同分辨率的屏幕。旧版本的Android不支持向量drawable，Vector Asset Studio可以在构建的时候，帮助你把向量drawable转化成不同大小的图片。 关于Vector Asset Studio Vector Asset Studio会将向量图片以XML文件描述的形式添加到项目中。维护一个XML文件要比维护多个分辨率的图片要简单很多。 Android4.4（API level 20）或更低的版本不支持向量drawable。如果过你的最小API level低于20，在使用Vector Asset Studio时有两个选项：生成PNG文件（默认）或者使用Support Library。 为了保持向后兼容，Vector Asset Studio生成向量drawable的栅格化图片。向量和栅格化资源会一起打包到APK文件中。在Java代码中，你可以视为向量资源为Drawable或者在XML代码中卫@drawable；当你的应用运行的时候，会根据当前系统的API版本来决定是使用向量资源还是栅格图片。 再者，为了使用Android Support Library 23.2或更高版本，你可以在build.gradle文件中添加一些声明。 支持的向量图片类型 谷歌material design规范提供了material图标，你可以直接应用于你的Android应用中。Vector Asset Studio帮助你选择，导入和更改material图标的大小。 Vector Asset Studio也可以帮助你导入你自己的SVG文件。SVG是一个基于XML的W3C的标准。Vector Asset Studio支持必要的标准，但并不是所有的特性。当你声明一个SVG文件，Vector Asset Studio告诉你是否支持这个图片代码。如果这个SVG代码不支持，它将这个文件转化为包含VectorDrawable代码的XML文件。 SVG文件的思考 一个向量drawable对于一个简单的图标是可以的。Material图标提供了非常好的图片类型的例子，转换成向量drawable也非常好。但是，很多app运行图标包含太多细节，所以它们比较适合用栅格化图片。 向量图片的初始化载入要比栅格化图片花费更多的CPU资源。之后，内存使用和性能两者是相同的。建议将向量图片限制为最大200*200 dp，否则，将会花费大量时间绘制。 虽然向量drawable支持一个或多个颜色，在许多情况下图标颜色都是黑色的（android:fillColor=”#FF000000”），利用这个特性，你可以在布局中使用的向量drawable中添加一个tint。图标颜色颜色将变成tint颜色。如果图标颜色不是黑色，图标颜色可能与tint颜色混合。 运行Vector Asset Studio 为了打开Vector Asset Studio，通过如下方式： 1、 在Android Studio中，打开一个Android应用项目。 2、 在Project窗口中，选择Android视图。 3、 右键单击res文件夹，选择New > Vector Asset。 Vector Asset Studio显示： 导入一个向量图像 Vector Asset Studio帮助你导入一个向量图像到你的app项目中。 添加一个material图标 1、 在Vector Asset Studio中，选择Material Icon 2、 选择Choose 3、 选择一个material图标并点击OK 图标出现在Vector Drawable Preview中。 4、 可选的，你可以更改资源名称，大小，透明度和RTL镜像设置。 5、 点击Next 6、 可选的。更改模块和资源目录。 7、 点击完成。 Vector Asset Studio添加一个定义了向量drawable的一个XML到你的项目的app/src/main/res/drawable/ 文件夹中。 8、 构建项目。 如果你的最小API level 是Android4.4或者更低，而且没有添加Support Library，Vector Asset Studio生成PNG文件，你不可以修改这些文件。 导入一个SVG文件 在打开Vector Asset Studio之后，你可以通过如下方式导入一个SVG文件： 1、 在Vector Asset Studio中，选择Local SVG file 文件必须是在本地。如果是在网上，你需要先下载到本地。 2、 点击需要导入的图片 图片显示在Vector Drawable Preview。 然而，如果SVG文件包含不支持的特性，将会在Vector Asset Studio的底部报出一个错误，如下： 3、 可选的。更改资源的名称、大小、透明度等设置 4、 点击Next 5、 可选的。更改模块和资源目录。 6、 点击Finish。 7、 构建项目。 如果你的最小API level 是Android4.4或者更低，而且没有添加Support Library，Vector Asset Studio生成PNG文件，你不可以修改这些文件。 添加一个向量Drawable到布局中 在一个布局文件中添加任何可以使用图标的控件，比如ImageButton，ImageView等等，指向一个向量资源。比如：下面的布局中在一个按钮中显示向量资源。 设置一个向量资源到控件中，执行如下几步： 1、 打开一个项目，导入一个向量资源 2、 在Project窗口的Android视图中，双击一个布局XML文件，比如content_main.xml 3、 点击Design 打开布局编辑器 4、 从Palette窗口中拖动ImageButton控件到布局编辑器中。 5、 在Properties窗口，定位到ImageButton的src属性，点击… 6、 在Resources对话框中，选择Project，导航到Drawable文件夹，选择一个向量资源。点击OK。 向量资源显示在ImageButton布局中。 7、 为了更改图片的颜色，可以设置tint属性。 如果你没有使用Support Library，ImageButton代码如下： <ImageButton android:id="@+id/imageButton" android:src="@drawable/ic_build_24dp" android:tint="@color/colorAccent" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_below="@+id/textView2" android:layout_marginTop="168dp" /> 在代码中使用一个向量Drawable 你可以在代码中用普通的方式来调用一个向量资源。当你运行一个app时，会根据你的API版本来判断显示向量或者栅格化图片。 在大部分情况下，你可以通过@drawable或Drawable访问向量资源。如下： <ImageView android:layout_height="wrap_content" android:layout_width="wrap_content" android:src="@drawable/myimage" /> 如下： Resources res = getResources(); Drawable drawable = res.getDrawable(R.drawable.myimage); 如下： if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { VectorDrawable vectorDrawable = (VectorDrawable) drawable; } else { BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable; } 修改由Vector Asset Studio生成的XML代码 你可以修改向量资源的XML代码，但是不是PNG文件和在构建时生成的XML代码。但是，这种方式并不推荐。 本文作者：宋志辉 个人微博：点击进入
Android Studio包含一个叫主题编辑器的可视的助手，可以提供以下功能： 1、 创建和更改你的app主题 2、 为不同的资源适应主题 3、 普通的UI颜色更改的实时显示 主题编辑器 这一节描述如何访问主题编辑器。 访问主题编辑器 这里有两种方式来打开主题编辑器： 1、 在一个打开的样式XML文件，比如styles.xml，在窗口的右上角点击Open editor 2、 在Tools菜单，点击Android > Theme Editor 主题编辑器概览 主题编辑器的主屏幕分成两部分。左边显示的特定的UI元素，比如app bar或者一个按钮。编辑器右边显示的是当前被预览的主题。 主题和颜色 主题编辑器允许你创建新的主题，更改现有的主题并且更改组成组成主题的颜色。 创建新的主题 创建一个新的主题，跟随如下几步： 1、 在主题编辑器右侧，打开Theme下拉菜单 2、 单击Create New Theme 3、 在New Theme对话框中，输入新的主题的名字 4、 在Parent theme name列表中，单机选择要继承的父主题 重命名主题 重命名主题，可以遵循如下几步： 1、 在主题编辑器右侧，打开Theme下拉菜单 2、 单击Rename theme-name 3、 在Rename对话框，输入一个新的主题名字 4、 （可选）查看效果，可以点击Preview 5、 如果想应用更改，点击Refactor 更改颜色资源 要想更改一个已经存在的颜色资源，比如colorPrimary，跟随如下几步： 1、 选择资源名称左边的色块，会弹出Resources对话框，这个对话框左边会显示一个颜色列表，在右边显示选中资源的设置和信息。 2、 为主题资源设置一个颜色 本文作者：宋志辉 个人微博：点击进入
Android Studio提供了一个高级的布局编辑器，允许你拖拽控件，在编辑XML之后可以实时预览。 在布局编辑器中，你在文字视图和设计视图直接来回切换。 在文字视图中编辑 你可以在文字视图中编辑你的布局文件，这一节描述文字视图可用的一些特性。 预览 当你在文字视图中编辑室，你可以通过点击窗口右边的Preview面板来在设备中预览布局。在Preview面板，你可以在面板顶部更改多个选项来更改预览，包括预览设备，布局主题，平台版本等等。如图： 要想在多个设备中模拟预览布局，在设备下拉框选择Preview All Screen Sizes。 当你点击预览图片，布局编辑器自动高亮并且定位到相应的位置。 交互错误检测和恢复 当你编辑文字试图中的XML布局文件时，Android Studio会实时提示错误并提供帮助。 比如，假设你添加了一个按钮，却拼成Buttonn。Android Studio会通过显示一个如下的错误来帮你纠正它。 Android Studio可以提示你补充遗漏的信息。比如，假设你添加一个Fragment到你的XML文件中。首先，Android Studio显示了一个自动完成的提示。一旦确定你添加一个fragment，Android Studio会显示一个带链接的错误来提示你补充遗漏的属性。点击Automatically add all missing attributes可以帮助你添加丢失的属性。如图： 选择一个主题 通过点击主题图标来为你的app选择一个主题。 这会打开Select Theme对话框，在这里你可以选择合适的主题并在右边选择合适的。如图： 本地化 Android Studio提供了内建的本地化支持。当你点击本地化按钮，选择一个特定的语言，可以实时预览。如图： 在设计视图中编辑 你可以通过点击窗口地步的Design来切换到图形编辑器视图。如图： 多API版本预览渲染 Android Studio支持多API版本渲染，当你在设计视图中点击Android版本，Android Studio允许你同时多个API预览你的Android布局。如图： 截图 当你在一个连接的设备上运行你的app的时候，你可以通过点击设计视图中的相机图标完成对app界面的截图。 本文作者：宋志辉 个人微博：点击进入
使用像Lint这样的代码检测工具可以帮助你发现问题和提升代码，但是代码检测在有些地方很难应用。例如，Android的资源ID，使用一个int类型来表示字符、图像、颜色或者其他资源类型所以代码检测工具不能分辨这是一个字符串资源，还是一个颜色资源。这种情况下，即使你使用代码检测工具，你的app可能会渲染失败或者不能运行。 注解允许你为Lint这样的代码检测工具提供提示来帮助Lint检测更深层次问题。当你使用代码检测工具的时候，注解可以帮助你检测问题，比如空指针异常和资源类型冲突。 Android支持多种注解，允许你在方法，参数和返回值中使用，比如： 1、@Nullable 可以为空 2、@NonNull 不可以为空 3、@StringRes 提示Lint为String资源 4、@DrawableRes 提示Lint为Drawable资源 5、@ColorRes 提示Lint为Color资源 6、@InterpolatorRes 提示为Interpolator资源 7、@AnyRes 提示为任何类型的资源 8、@UiThread 在主线程中调用 这里仅仅列出部分的注解。 添加基本注解 为了添加注解到你的代码中，首先需要添加一个依赖： 1、 选择File > Project Structure 2、 在Project Structure中选择相应的模块，点击Dependencies标签 3、 单击+导入一个Library dependency 4、 在Choose Library Dependency对话框，选择support-annotations，点击OK 在build.gradle文件中自动更新了support-annotations依赖。 你也可以手动添加： dependencies { compile ‘com.android.support:support-annotations:23.3.0’ } 如果你在一个library中添加注解，并打包成AAR，注解将会以XML格式保存在annotations.zip文件中。 添加空的注解 添加@Nullable和@NonNull注解来检测给定的变量，参数或者返回值是否为空。比如，一个值为null的本地变量通过参数传递给添加了@NonNull注解的参数，构建代码回生成一个警告。如下： import android.support.annotation.NonNull; … @NonNull @Override public View onCreateView(String name, @NonNull Context context, @NonNull AttributeSet attrs) { … } … 判空分析 Android Studio运行一个判空分析，并且自动添加相关的注解到你的代码中。可以检测： 1、 调用方法是否返回null 2、 方法不能返回null 3、 变量不能为null 4、 变量不能保持一个null值 添加资源注解 比如，添加@StringRes注解可以检测一个资源参数是否包含R.string。在代码检测的时候，如果R.string没有通过参数进行传递，则生成一个警告。 如下： import android.support.annotation.StringRes; public abstract void setTitle(@StringRes int resId); 添加线程注解 线程注解检测一个方法事是否运行在特定的线程，支持如下线程注解： 1、@UiThread 2、@MainThread 3、@WorkerThread 4、@BinderThread 注意：@UiThread和@MainThread是可以互换的 添加值约束注解 使用@IntRange、@FloatRange和@Size注解来验证传递参数的值。 @IntRange注解验证参数值是否在特定的范围内，如下示例确保alpha参数范围在0到255之间。 public void setAlpha(@IntRange(from=0,to=255) int alpha) { … } @FloatRange注解检测参数值是否在一定的浮点范围内。下面这个示例确保alpha参数为0.0到1.0的参数: public void setAlpha(@FloatRange(from=0.0, to=1.0) float alpha) {…} @Size注解检测集合、数组或字符串的大小，比如，使用@Size(min=1)注解来判断集合是否为空，使用@Size（2）注解来验证一个数组是否包含两个值。以下示例确保location数组包含至少一个元素： int[] location = new int[3]; button.getLocationOnScreen(@Size(min=1) location); 添加权限注解 使用@RequiresPermission注解来验证调用方法调用时的权限。为了检查是否用到很多权限中的某个权限，使用anyOf属性，检测是否用到多个权限，使用allOf属性。如下： @RequiresPermission(Manifest.permission.SET_WALLPAPER) public abstract void setWallpaper(Bitmap bitmap) throws IOException; 另外一个示例： @RequiresPermission(allOf = { Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE}) public static final void copyFile(String dest, String source) { … } 添加结果检测注解 使用@CheckResults注解来验证一个方法的结果或者返回值是否被使用。如下： @CheckResult(suggest=”#enforcePermission(String,int,int,String)”) public abstract int checkPermission(@NonNull String permission, int pid, int uid); 添加调用super 注解 使用@CallSuper注解来验证重写方法是否调用了父类的方法。如下： 本文作者：宋志辉 个人微博：点击进入
为了测试你的Android应用符合功能需求。最重要的是确保你的代码没有结构性问题。结构差的代码影响你的Android应用的可靠性，让你的代码难以维护。比如，如果你的XML资源文件包含未使用的明明空间，这会花费空间和不必要的进程。其他机构行问题，比如是哟个过时的API调用，如果设备API版本不兼容，可能导致运行失败。 概览 Android Studio提供了一个称为Lint的代码扫描工具，可以非常容易的帮你辨别和纠正代码的结构性质量问题，而无须你执行app或者编写测试用例。工具检测到的每个错误都会标明严重程度一个描述信息，这样你就可以迅速的确定优先级。你也可以将在你项目中无关紧要的错误进行忽略。这个工具有相应的命令行接口，所以你可以非常容易的整合到你的测试进程中。 Lint工具通过检测你的Android项目源代码来发现潜在的bug并提供代码优化建议。你可以从命令行或者Android Studio中运行Lint。 Application 源文件（Application source files） 源文件包含组成你的Android项目的文件，包含Java和XML文件、图标和ProGuard配置文件。 Lint.xml文件 配置文件，用于配置你想忽略的问题，或者更高问题的严重级别。 Lint工具 你可以通过命令行或者Android Studio运行在你的Android项目上的静态代码扫描工具。Lint工具检测影响你的Android应用的质量和性能的代码结构性问题。强烈建议在发布你的应用之前修复Lint检测到的任何问题 Lint检测结果 你可以在Android Studio的Event Log中来查看Lint的结果（或者在命令行中）。 Lint工具作为Android SDK工具的一部分（>=16）。 在Android Studio中运行Lint 在Android Studio中，当你构建你的app时，Lint自动运行。 在Android Studio中你可以在android设置中添加lintOptions属性。如下： android { lintOptions { // 设置为true会关闭lint分析进度 quiet true // 如果为true，则在发现错误时停止gradle构建 abortOnError false // 如果为true，则只报告错误 ignoreWarnings true } } 命令行运行Lint 运行lint检测项目： lint [flags] <project directory> 检测项目的某个错误，以下这个用于检测Android命名空间前缀： lint --check MissingPrefix myproject 查看lint帮助，可用： Lint输出示例 接下来展示lint检测一个Earthquake的项目输出的信息： $ lint Earthquake Scanning Earthquake: ............................................................................................................................... Scanning Earthquake (Phase 2): ....... AndroidManifest.xml:23: Warning: <uses-sdk> tag appears after <application> tag [ManifestOrder] <uses-sdk android:minSdkVersion="7" /> ^ AndroidManifest.xml:23: Warning: <uses-sdk> tag should specify a target API level (the highest verified version; when running on later versions, compatibility behaviors may be enabled) with android:targetSdkVersion="?" [UsesMinSdkAttributes] <uses-sdk android:minSdkVersion="7" /> ^ res/layout/preferences.xml: Warning: The resource R.layout.preferences appears to be unused [UnusedResources] res: Warning: Missing density variation folders in res: drawable-xhdpi [IconMissingDensityFolder] 0 errors, 4 warnings 配置lint 默认情况下，当你运行一个扫描的时候，会检测Lint支持的所有的issue。你可以禁止Lint检测某个issue或者设置issue的安全级别。 你可以在不同级别来配置Lint检测： 1、 全局，针对整个项目 2、 每个项目模块 3、 每个测试模块 等等。 在Android Studio中配置Lint 当你使用Android Studio时，内置的Lint工具可以检测你的代码。你可以通过两种方式来查看警告和错误： 1、 代码编辑器中，当Lint发现错误之后，会黄色高翔显示问题代码。 2、 选择Analyze > Inspect Code，打开Lint Inspection Results。 设置默认Lint检测： 1、 在Android Studio中，打开你的项目。 2、 选择File > Other Settings > Default Settings 3、 选择Editor > Inspections，打开Default Preferences对话框。 4、 在Profile中，选择Default或者Project Default。 5、 根据需要更改Lint设置。 6、 点击OK。 将Lint检测显示在Inspection Results窗口： 1、 在Android Studio中，打开项目，选择你要测试的部分 2、 选择Analyze > Inspect Code 3、 在Specify Inspection Scope对话框中，选择需要测试的部分 4、 点击OK。 结构将根据分类显示在Inspection Results窗口。 配置Lint文件 你可以在lint.xml文件中声明Lint检测参数。如果你手动创建这个文件，将它放在你的Android项目的根目录。如果你在Android Studio中配置你的Lint参数，lint.xml自动生成并添加到你的项目中。 Lint.xml 文件包含一个父标签，包含一个或多个标签。如下： <?xml version="1.0" encoding="UTF-8"?> <lint> <!-- list of issues to configure --> </lint> 通过设置标签，你可以禁用Lint检测某个issue或者更高某个issue的级别。 注意：查看lint支持的issue列表，可以运行lint –list命令 Lint.xml文件示例 下面是一个lint.xml文件示例： <?xml version="1.0" encoding="UTF-8"?> <lint> <!-- Disable the given check in this project --> <issue id="IconMissingDensityFolder" severity="ignore" /> <!-- Ignore the ObsoleteLayoutParam issue in the specified files --> <issue id="ObsoleteLayoutParam"> <ignore path="res/layout/activation.xml" /> <ignore path="res/layout-xlarge/activation.xml" /> </issue> <!-- Ignore the UselessLeaf issue in the specified file --> <issue id="UselessLeaf"> <ignore path="res/layout/main.xml" /> </issue> <!-- Change the severity of hardcoded strings to "error" --> <issue id="HardcodedText" severity="error" /> </lint> 在Java和XML源文件中配置lint检测 你可以在Java和XML文件中禁用Lint检测 在Java中配置lint检测 为了在你的Android项目中指定的类或方法中金庸Lint检测，在Java代码中添加@SupprewwLint注解。 接下来的示例显示在OnCreate方法中如何关闭Lint检测，Lint工具在其他方法中继续检测NewApi issue。 @SuppressLint("NewApi") @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); 下面的示例显示如何关闭ParserError issue： @SuppressLint("ParserError") public class FeedProvider extends ContentProvider {} 在Java文件中禁止所有Lint检测，如下： @SuppressLint("all") 在XML中配置Lint检测 在XML文件中，你可以使用tools：ignore属性来金庸Lint检测。为了使相关属性被Lint工具识别，必须添加如下命名空间到你的XML文namespace xmlns:tools=http://schemas.android.com/tools下： <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" tools:ignore="UnusedResources" > <TextView android:text="@string/auto_update_prompt" /> </LinearLayout> 禁用多个issue，如下： tools:ignore="NewApi,StringFormatInvalid" 禁用所有的issue 检测，如下： tools:ignore="all" 本文作者：宋志辉 个人微博：点击进入
Android Studio包含了每个开发阶段的各种工具，但是最重要就是编写代码。 高效编码 接下来的是能够帮助你高效编程的方法。 使用Lint快速修复 Android Studio提供一个叫Lint的代码扫描工具，用来帮助你辨别和纠正错误，而无须执行app或者编写测试用例。 在你每次构建应用时，Android Studio运行Lint来检测你的源文件发现潜在的bug。在纠错，安全，性能，可用性，国际化等方面提供优化建议。 查阅文档和资源 你可以把光标放到方法或成员或类名称上按下F1来查阅文档。 快速创建一个新的文件 当你创建一个新的文件，点击Project窗口中的目标目录，按下Alt+Insert，Android Studio将会显示一个小的窗口显示一些建议的文件类型。 编辑资源文件 Android Studio包含了以下特性和工具来帮助你创建和管理资源文件。 创建支持所有屏幕像素的图片 Android Studio中包含一个叫Vector Asset Studio的工具来帮助你创建支持每个屏幕尺寸的图片。你可以上传你自己的SVG文件来编辑或者选择从谷歌提供的material design 图标中选择。通过点击File > New > Vector Asset，开始。 预览图片和颜色 当你在代码中引用图片或图标的时候，会在左边显示一个图片或者图标的预览。 为了预览全尺寸的图片，单击左边的预览。或者将光标移动到代码处，按下F1. 创建新的布局 Android Studio提供了一个高级的布局编辑器，允许你拖拽控件到布局中，并在编辑XML文件时预览。 点击你想添加布局的模块，然后执行File > New > XML > Layout XML File 翻译UI字符 Translations Editor工具给你一个需要翻译的资源的单独的视图，使更改或翻译变得更加容易。甚至可以找到漏掉的翻译。 本文作者：宋志辉 个人微博：点击进入
一个Android Library结构上与Android app模块相同。它可以包含构建一个app需要的所有东西，包括圆满，资源文件和AndroidManifest.xml。然而，并非编译成运行在设备上的APK，一个Android Library编译成其他Android app模块可以用作以来的AAR文件。 一个Library模块在以下情形中是有用的: 1、 当你构建多个使用相同组件，比如activity、service或者UI布局，的APP。 2、 当你构建的APP存在多个APK文件。比如免费版和付费版APK。 在这些案例中，简单的移动你想复用的文件到Library模块中，添加Library作为APP模块的依赖。 创建一个Library模块 为了创建一个新的Library模块到你的项目中，遵循如下步骤： 1、 单击File > New > New Module 2、 在Create New Module窗口出现时，点击Android Library。然后点击Next。 这里同样有一个创建Java Library的可选项，可以构建一个传统的JAR文件。JAR文件在很多项目中都是可用的。特别是你想与其他平台分享代码，它不允许包含Android资源文件或者AndroidMainfest.xml，，这个在Android项目中是非常有用的，所以我们专注创建Android Library。 3、 为你的Library设置一个名称并且选择一个最小的SDK，然后点击Finish。 一旦Gradle项目同步完成。Library模块显示在Project左边的面板中。如果你没有看到新的模块文件夹，确保适应的是Android视图。 将App模块转化为Library模块 如果你有一个已经存在的app模块所有的代码你都想复用，你可以通过以下几部将其转化成Library模块。 1、 打开build.gradle文件，你可以看到如下语句： apply plugin: ‘com.android.application’ 2、 更改成如下： apply plugin: ‘com.android.library’ 3、 点击Sync Project with Gradle Files 就这么简单，整个模块无需改动。但是现在就可以作为Library并且生成AAR文件而不是APK。 将你的Library添加为依赖 为了在其他app模块中使用你的Android Library代码，操作如下： 1、 有两种方式添加library到你的项目中。 添加编译后的AAR（或者JAR）文件： 1） 单击 File > New Module。 2） 单击 Import .JAR/.AAR Package 然后点击Next。 3） 输入AAR或者JAR文件的位置，然后点击Finish。 导入你的Library模块到你的项目： 1） 单击 File > New > Import Module 2） 输入Library 模块的位置点击Finish。 Library模块被复制到你的项目中所以你可以编辑Library代码。 2、 确保Library 列在setting.gradel文件的顶部。 include ‘:app’, ‘:my-library-module’ 3、 打开app模块的build.gradle文件添加一个新的依赖到dependencies中： dependencies { compile project(“:my-library-module”) } 4、 单击Sync Project with Gradle Files。 现在，你的Android Library中的任何代码和资源都是可以被你的app模块访问，Library的AAR文件将会在你的APK打包的时候加入进去。 注意以下问题 1、 资源合并可能导致冲突 2、 Library模块可以包含JAR 包。 3、 Library模块不能使用 raw资源 4、 App模块的最小SDK版本必须等于或高于Library中的版本。 5、 每个Library模块创建它自己的R类。 本文作者：宋志辉 个人微博：点击进入
模块为你的应用的源码、资源文件和app level设置（比如AndroidManifest.xml）提供了一个容器。每个模块可以独立的构建、测试和调试。 通过使用模块，Android Studio可以更容易的将新的设备添加到你的项目中。在Android Studio中可以通过一些简单的步骤来创建针对指定平台的模块，比如Android Wear或者Android TV。Android Studio自动创建模块目录，比如代码和资源目录和针对这个设备的build.gradle文件。 创建一个新的模块 为新的设备添加一个新的模块到你的项目中，如下： 1、 点击File > New > New Module。 2、 在出现的New Module窗口中，Android Studio提供了以下设备模块:: 1） Phone & Tablet Module 2） Android Wear Module 3） Android TV Module 4） Glass Module 选择你需要创建的模块类型，点击Next。 3、 在Configure your new module窗口中，输入如下细节： 1） Application Name：这个名称作为新模块运行图标的标题。 2） Module Name：这个用于作为文件夹的名称，放置源码和资源文件。 3） Package Name：在模块中这是代码的Java命名空间。被添加到AndroidManifest.xml的package属性中。 4） Minimum required SDK：用于设置你的app模块支持的最小的Android平台版本。 然后点击Next。 4、 接下来的页面根据你选择的模块不同显示选中的代码模板。选择一个activity模板，点击Next。如果你不需要一个activity，点击 Add No Activity然后点击Finish。 5、 如果你选择一个Activity模板，接下来的也没根据你的activity模板包含几个输入，比如累名称，布局名称。完成后点击Finish。 Android Studio创建了新的模块需要的所有的必须的文件，并且同步新模块的gradle文件，为一个新的设备添加模块同样需要添加需要的依赖到构建文件中。 一旦Gradle项目同步完成，新的模块就会出现在项目左边的面板中。如果没有看到新的模块文件夹，确保是使用Android视图。 下一步 一旦你添加一个新的模块，你就可以更改模块代码和资源、构建配置并且构建模块。你同样可以向其他应用一样运行、测试模块。 本文作者：宋志辉 个人微博：点击进入
Android Studio中的项目包含一个或多个模块。本节帮助你创建一个新的项目。 创建一个新的项目 如果你之前没有打开项目，Android Studio显示欢迎页面，通过点击Start a New Android Studio project.来创建一个新的项目。 如果你之前已经打开了项目，Android Studio显示开发环境。通过File > New > New Project来创建一个新的项目。 下一个窗口让你设置应用的名称，包名和项目的位置。 输入项目的各项值，点击Next。 选择平台和API Level 下一个窗口允许你选择你的应用支持的平台，比如电话，平板，电视，手表和谷歌眼镜。选中的平台将成为项目中的app模块。对于每个平台来说，你可以选择app的Level。 Android Platform Distribution 窗口显示了当前发布的移动设备运行的Android版本的分布，点击API level来查看这个版本的Android的特性。这可以帮你选择能够满足你你的app需要的所有的特性的最小版本的API Level。 然后，在Target Android Devices窗口，一旦你选择平台和API 版本，点击Next。 添加一个Activity 下一个屏幕让你选择一个Activity 类型来添加到你的应用中。 选择一个activity，点击Next。 注意：如果选择Add No Activity，点击Finish创建项目。 配置你的Activity 下一个窗口来配置你添加到app的activity。 输入activity名称，布局名称，activity标题。然后点击Finish 开发你的应用 Android Studio创建你的项目的默认结构并且打开开发环境。如果你的app支持多个平台，Android Studio会创建一个包含完整代码的模块文件夹。 本文作者：宋志辉 个人微博：点击进入
项目概览 Android Studio中的项目包含了开发一个app的工作环境所需要的一切。从代码，到资源，到测试到构建配置。当你创建一个新的项目的时候，Android Studio为所有的文件创建了必要结构，使它们在IDE左边的Project中可见（单击View >Tool Windows >Project）。 模块（Modules） 模块是构建设置（build settings）和源文件的集合，可以将你的项目分成几个独立可用的单元。你的项目可以有一个或多个模块，一个模块必须将其他模块作为依赖。每个模块可以单独构建，测试和调试。 你可以通过点击 File>New >New Module来创建模块文件。 Android Studio提供一些不同类型的模块。 Android app 模块 为你的应用源码、资源文件、设置文件和Android Manifest文件提供了一个容器。当你创建一个新的项目是，默认的模块名称为“app”。 在Create New Module窗口，Android Studio提供了以下app模块： 1） Phone & Tablet Module 2） Android Wear Module 3） Android TV Module 4） Glass Module 它们都提供了相应的代码模板和必要的文件。 Library 模块 提供了一个可芙蓉代码的容器，你可以将模块用作其他模块的依赖或者导入其他项目。Library模块在结构上跟Android app 模块是一样的。但是在构建上，它会成成一个包而不是APK文件，所以不能独立安装到设备中。 在Create New Module窗口，Android Studio提供了以下两种Library模块: 1） Android Library：这种类型的Library可以包含任何Android 项目中支持的文件类型。包括源码，资源和manifest文件。构建结果是生成一个AAR文件，你可以将AAR文件作为依赖添加到Android app模块中。 2） Java Library：这种类型的Library仅仅包含Java源文件。构建结果是生成一个Jar文件，你可以将jar文件作为依赖添加到Android app模块中或者其他Java项目中。 当你创建一个Library模块并且想作为依赖添加到当前的Android app模块中，你可以通过如下方式声明： dependencies { compile project(‘:my-library-module’) } 项目文件 默认情况下，Android Studio在Android 视图下显示你的项目文件，这样视图的项目机构并没有直接映射文件实际存在的位置。而是根据模块和文件类型在你关键的源文件中方便的进行导航，隐藏不常用的文件或文件夹。Android视图显示与保存在磁盘中的项目结构的区别如下： 1） 将所有的build.gradle都归置到Gradle Script组中。 2） 将所有的Manifest文件归置到manifests中。 3） 显示相关的资源文件到一个组中，而不是不同的文件夹。比如不同分辨率的图标。 在Android APP模块中，文件按照以下方式分组： Manifests 包含AndroidManifest.xml文件。 Java 包含根据包名进行分类的Java源文件，包含单元测试代码。 Res 包含所有的非代码资源，比如XML布局，UI字符和图片文件，分成几个子文件夹。 Android 项目视图 为了在Android视图中查看项目真实的结构（包括隐藏的文件），在项目窗口中选择Project试图。 当你选择项目视图后，你可以看到更多的文件和目录。最重要的如下： 模块名/ Build/ 包含构建输出 Libs/ 包含私有库 Src/ 包含所有的代码和资源文件，子文件夹如下： androidTest/ 包含运行在设备上的Instrumentation测试 Main/ AndroidManifest.xml/ 用于描述应用和各个组件 Java/ 包含Java源代码 Jni/ 包含使用Java Native Interface（JNI）的本地代码 Gen/ 包含由Android Studio生成的Java文件，比如R.java和有AIDL文件生成的接口文件。 Res/ 包含应用的资源，比如drawable文件，布局文件和UI字符。 Assets/ 包含需要打包进apk文件中的文件。 Test/ 包含运行在JVM的本地测试 Build.gradle(module) 定义了模块的运行配置 Build.gradel(project) 这个定义了可以应用于所有模块的构建配置。 项目结构设置 为了更改你的Android Studio项目的多种设置，通过点击File>Project Structure来打开Project Structure。它包含如下几个部分： 1） SDK Location：设置项目使用的JDK、Android SDK和Android NDK的位置。 2） Project：设置Gradle插件版本以及中央库 3） Developer Services：包含谷歌或第三方的Android Studio额外组件的设置。 4） Modules：允许你编辑构建设置，包含目标和最小SDK，app简明，library依赖。 开发者服务 Project Structure的Developter Services包含几个可以应用于你的app中的服务。包含如下： 1） AdMob：允许你开启Google的AdMob组件，用于广告。 2） Analytics：允许你开启Google Analytics。 3） Authenication：允许你开启Google Sign-In 4） Cloud：允许你开启Firebase 5） Notifications：允许你使用Google Cloud Messaging 模块 Modules设置允许你更改每个项目模块的设置。每个模块的设置页分成如下部分： 1） Properties：声明SDK的版本以及模块的构建工具版本。 2） Signing：签名 3） Flavors： 4） Build Types：创建或更改构建配置。 5） Dependencies：列出所有依赖。 本文作者：宋志辉 个人微博：点击进入
如果你的应用中使用了Content Provider来与其他应用进行数据交互，你需要对Content Provider进行测试来确保正常工作。 创建Content Provider整合测试 在Android中，app将Content Provider视为数据API。一个Content Provider可能会有public 常量。 Content Provider允许你访问真实的用户数据，所以必须在一个隔离的测试环境中来测试你的Content Provider。这就意味着你的测试不会更改真实的用户数据。 在隔离状态下测试Content Provider，需要使用ProviderTestCase2类。这个类允许你使用Android虚拟对象类比如IsolatedContext和MockContentResolver来在不影响真实用户数据的情况下访问文件和数据库信息。 你的整合测试类需要写为Junit4测试类风格。 为了创建Content Provider整合测试类，你需要执行如下几步: 1、 创建ProviderTestCase2的测试子类。 2、 添加 @RunWith(AndroidJUnit4.class) 注解到测试类开始的地方。 3、 声明AndroidJUnitRunner类 4、 设置Context 代码如下： @Override protected void setUp() throws Exception { setContext(InstrumentationRegistry.getTargetContext()); super.setUp(); } ProviderTestCase2如何工作 你通过ProviderTestCase2的子类来对Content Provider进行测试。这个基类扩展自AndroidTestCase，所以它提供了Junit 测试框架和Android特有的测试应用的方法。最重要的特性就是这个类的初始化创建了一个隔离的测试环境。 初始化在ProviderTestCase2的构造函数中完成，并且在子类的构造函数中调用。ProviderTestCase2构造函数创建一个IsolatedContext对象允许你访问文件和数据库操作，但是与Android系统隔离。 构造函数创建一个MockContentResolver来作为测试的resolver。 最后，构造函数在测试状态下创建一个Content Provider的实例。这是一个正常的Content Provider对象。但是所有的环境信息都是来时IsolatedContext中。所以你的测试工作严格的限制在一个隔离的测试环境中。 测试什么 1、 测试resolver方法 2、 测试你的Content Provider暴露的常量；测试你的Content Provider提供的URI；测试URI的有效性。 3、 测试Content Provider标准的交互。 4、 测试你的商业逻辑。 本文作者：宋志辉 个人微博：点击进入
如果你在应用中使用了Service，你应该来测试这个Service来确保它正常工作。你可以创建仪表测试来验证Service的行为是否正确；比如，service保存和返回有效的数值并正常的处理数据。 Android Testing Support Library在隔离状态下测试你的Service对象的API。ServiceTestRule类会在你的单元测试类运行之前就启动service，在测试完成之后关闭服务。通过这个规则，你可以保证service会在你的测试方法运行之前建立。 ServiceTestRule类不支持IntentService对象的测试。 配置测试环境 查看第一篇 创建Service的整合测试 你的整合测试需要按照Junit 4测试类的规则来编写。 为了创建一个service的整合测试，在类开始的地方添加 @RunWith(AndroidJUnit4.class) 注解。你同样需要声明AndroidJUnitRunner类。 接下来通过@Rule注解创建一个ServiceTestRule实例。 @Rule public final ServiceTestRule mServiceRule = new ServiceTestRule(); 接下来的示例显示创建一个service的整合测试类。 @Test public void testWithBoundService() throws TimeoutException { // 创建Service Intent Intent serviceIntent = new Intent(InstrumentationRegistry.getTargetContext(), LocalService.class); // Service通过Intent传递数据 serviceIntent.putExtra(LocalService.SEED_KEY, 42L); // 绑定service IBinder binder = mServiceRule.bindService(serviceIntent); LocalService service = ((LocalService.LocalBinder) binder).getService(); // 验证Service是否正常工作 assertThat(service.getRandomInt(), is(any(Integer.class))); } 本文作者：宋志辉 个人微博：点击进入
为你的APP进行UI测试是为了确保不出现意料之外的结果，提升用户的体验。如果你需要验证你的APP UI的正确性，你需要养成创建UI测试的习惯。 Espresso测试框架是由Android Testing Support Library提供，包含了编写UI测试的API用于模拟用户在指定的APP界面上进行交互。Espresso测试可以运行在Android 2.2（API level 8）以上的设备。当主线程空闲时，Espresso可以侦测到，所以它可以在合适的时候运行你的测试指令，提升测试的可信度。 Espresso基于仪表测试。 配置Espresso 先看第一篇。 在build.gradle文件中添加依赖。 dependencies { androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.1' } 关闭测试机器的动画。 创建一个Espresso 测试类 为了创建一个Espresso测试，按照以下的方式创建一个Java类： 1、 通过调用onView（）方法或者onData（）在Activity中找到需要测试的UI组件。 2、 通过调用ViewInteraction.perform()或DataInteraction.perform()在UI组件上模拟特定的用户动作。 3、 需要的话重复如上动作。 4、 用ViewAssertions来检测UI。 代码如下： nView(withId(R.id.my_view)) .perform(click()) .check(matches(isDisplayed())); 使用带ActivityTestRule的Espresso 下面将接受如何创建Junit 4风格的Espresso 测试，通过使用ActivityTestRule来减少不必要的代码。 package com.example.android.testing.espresso.BasicSample; import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import android.support.test.rule.ActivityTestRule; import android.support.test.runner.AndroidJUnit4; ... @RunWith(AndroidJUnit4.class) @LargeTest public class ChangeTextBehaviorTest { private String mStringToBetyped; @Rule public ActivityTestRule<MainActivity> mActivityRule = new ActivityTestRule<>( MainActivity.class); @Before public void initValidString() { // 声明一个String mStringToBetyped = "Espresso"; } @Test public void changeText_sameActivity() { // 输入文字，点击按钮 onView(withId(R.id.editTextUserInput)) .perform(typeText(mStringToBetyped), closeSoftKeyboard()); onView(withId(R.id.changeTextBt)).perform(click()); // 检测文字改变 onView(withId(R.id.textToBeChanged)) .check(matches(withText(mStringToBetyped))); } } 使用带ActivityInstrumentationTestCase2的Espresso 代码如下： import android.support.test.InstrumentationRegistry; public class MyEspressoTest extends ActivityInstrumentationTestCase2<MyActivity> { private MyActivity mActivity; public MyEspressoTest() { super(MyActivity.class); } @Before public void setUp() throws Exception { super.setUp(); injectInstrumentation(InstrumentationRegistry.getInstrumentation()); mActivity = getActivity(); } } 访问UI组件 在测试下Espresso与你的app进行交互之前，你首先需要声明UI 组件或者view。 代码如下： public void testChangeText_sameActivity() { // 输入文字，点击按钮 onView(withId(R.id.editTextUserInput)) .perform(typeText(STRING_TO_BE_TYPED), closeSoftKeyboard()); onView(withId(R.id.changeTextButton)).perform(click()); } 声明一个ViewMatcher 可以通过如下方法声明一个view matcher: 1、 调用ViewMatchers类中的方法。如下： onView(withText("登陆")); onView(withId(R.id.button_signin)); 使用id的时候需要注意，Android中资源id并不是唯一的，使用不当，Espresso可能会抛出AmbiguousViewMatcherException一场。 2、 使用Hamcrest Matchers类。你可以使用allof()方法来组合多个matchers。比如containsString()和instanceof() onView(allOf(withId(R.id.button_signin), withText(“登陆”))); onView(allOf(withId(R.id.button_signin), not(withText(“登出”)))); 在AdapterView中定位View 代码如下： onData(allOf(is(instanceOf(Map.class)), hasEntry(equalTo(LongListActivity.ROW_TEXT), is(str)))); 模拟动作 ViewActions.click():单击view ViewActions.typeText()：单机view并输入一个特定的string ViewActions.scrollTo():滚动操作 ViewActions.pressKey();按键单机 ViewActions.clearText():清除text 验证结果 通过调用ViewInteraction.check()或者DataInteraction.check()方法来检测。 代码如下： public void testChangeText_sameActivity() { // 检测text更改 onView(withId(R.id.textToBeChanged)) .check(matches(withText(STRING_TO_BE_TYPED))); } “` 本文作者：宋志辉 个人微博：点击进入
不同于运行于JVM的本地单元测试，仪表测试运行于你的物理设备或虚拟机中。当你需要访问设备的信息(比如Context)或者使用真正的Android framework组件时（比如SharePreferences）时，你需要创建仪表测试。使用仪表测试同样可以帮助你减少mock代码。如果你需要，同样可以使用虚拟框架。 搭建测试环境 第一篇已经阐述 创建仪表测试类 你的仪表测试类风格类似Junit 4 测试类。 创建一个仪表测试类，需要在类定义前面添加 @RunWith(AndroidJUnit4.class) 注解。你也同样需要声明Android Testing Support Library中的AndroidJUnitRunner类为默认的test runner。第一篇已经阐述。 代码示例： import android.os.Parcel; import android.support.test.runner.AndroidJUnit4; import android.util.Pair; import org.junit.Test; import org.junit.runner.RunWith; import java.util.List; import static org.hamcrest.Matchers.is; import static org.junit.Assert.assertThat; @RunWith(AndroidJUnit4.class) @SmallTest public class LogHistoryAndroidUnitTest { public static final String TEST_STRING = "This is a string"; public static final long TEST_LONG = 12345678L; private LogHistory mLogHistory; @Before public void createLogHistory() { mLogHistory = new LogHistory(); } @Test public void logHistory_ParcelableWriteRead() { // 设置 Parcelable 对象用于发送和接收 mLogHistory.addEntry(TEST_STRING, TEST_LONG); // 写入数据 Parcel parcel = Parcel.obtain(); mLogHistory.writeToParcel(parcel, mLogHistory.describeContents()); // 重置 parcel.setDataPosition(0); //读取数据 LogHistory createdFromParcel = LogHistory.CREATOR.createFromParcel(parcel); List<Pair<String, Long>> createdFromParcelData = createdFromParcel.getData(); // 断言验证结果是否正确 assertThat(createdFromParcelData.size(), is(1)); assertThat(createdFromParcelData.get(0).first, is(TEST_STRING)); assertThat(createdFromParcelData.get(0).second, is(TEST_LONG)); } } 创建test suite 为了组织执行你的仪表测试，你可以将想要执行的测试类集中到一个test suite中，同时运行这些测试。Test suite可以被嵌套。 为了创建测试类的test suite，在你的test suite中添加 @RunWith(Suite.class) 和 @Suite.SuitClasses() 注解，在 @Suite.SuiteClasses()，列出测试类或者test suite（嵌套）。 示例如下： import com.example.android.testing.mysample.CalculatorAddParameterizedTest; import com.example.android.testing.mysample.CalculatorInstrumentationTest; import org.junit.runner.RunWith; import org.junit.runners.Suite; // 运行所有的单元测试 @RunWith(Suite.class) @Suite.SuiteClasses({CalculatorInstrumentationTest.class, CalculatorAddParameterizedTest.class}) public class UnitTestSuite {} 本文作者：宋志辉 个人微博：点击进入
如果你的单元测试在Android中没有依赖或者只有简单的以来，你可以在你的本地开发环境中运行你的测试。这种测试比较高效因为它能让你避免将整个app安装到物理设备或虚拟机中执行单元测试。最后，执行单元测试的时间大量减少。你可以通过模拟框架，比如Mockito来模拟依赖关系。 配置你的测试环境 前文已经叙述。 创建一个本地单元类 你的本地测试单元类风格类似Junit 4测试类。Junit是Java最流行应用最广泛的单元测试类。最新的版本，Junit 4，允许你用比之前版本更简洁和灵活的方式编写测试。跟之前的版本不同，在Junit 4中，你不需要扩展junit.framework.TestCase类了。你也不需要在每个测试方法前加前缀test或者使用在junit.framework 或 junit.extensions中的包。 创建一个基本的Junit 4 测试类，你可以创建一个包含一个或多个测试方法的Java类。每个测试方法都用@Test 标注。如下： import org.junit.Test; import java.util.regex.Pattern; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; public class EmailValidatorTest { @Test public void emailValidator_CorrectEmailSimple_ReturnsTrue() { assertThat(EmailValidator.isValidEmail("name@email.com"), is(true)); } } 为了测试你的APP组件返回期望的记过，使用Assert方法来执行检查。 模拟Android 依赖 默认情况下，Gradle的安卓插件依靠一个经过修改的android.jar的库，不包含任何真正的代码，调用的任何的Android的类都被视为异常。 你可以使用一个模拟框架来排除你代码中额外的依赖，让你的组件通过期望的方式与依赖交互。 添加一个虚拟对象到你的本地单元测试，跟随如下几步： 1、 将Mockito依赖添加到build.gradle文件中 2、 在你的测试类前添加@RunWith(MockitoJUnitRunner.class)注解。 3、 创建一个mock对象，用@Mock注解 import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.CoreMatchers.*; import static org.mockito.Mockito.*; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; import android.content.SharedPreferences; @RunWith(MockitoJUnitRunner.class) public class UnitTestSample { private static final String FAKE_STRING = "HELLO WORLD"; @Mock Context mMockContext; @Test public void readStringFromContext_LocalizedString() { when(mMockContext.getString(R.string.hello_word)) .thenReturn(FAKE_STRING); ClassUnderTest myObjectUnderTest = new ClassUnderTest(mMockContext); String result = myObjectUnderTest.getHelloWorldString(); assertThat(result, is(FAKE_STRING)); } } 本文作者：宋志辉 个人微博：点击进入
编写和运行测试时Android APP开发周期中的重要的一环。好的测试可以让你非常容易的在开发过程中发现bug，提升你对自己代码的自信。使用Android Studio，你可以在物理设备或者虚拟机中运行本地单元测试或者仪表测试（instrumented tests）（仪表测试我自己发明的词汇），这样你就可以分析结果，在开发环境中更改你的代码。 本地单元测试是指无需访问Android Framework或者一台Android 设备，直接在你的开发机器中运行的测试。 仪表测试直接运行在你的设备或者虚拟机中。这些测试可以访问设备的信息，比如在测试状态下获取应用的Context。仪表测试可用于单元测试、UI测试或APP组件整合测试（Activity、Service、Content Provider）。 配置本地单元测试 在你的Android Studio项目中，你必须将本地单元测试的源码保存在一个特定的目录（src/test/java）。这可以将你的所有的测试类集中放置到一起。 在你编写代码时，你可以相应的添加相应的本地单元测试类，一般就是在原有类的名称的基础上添加Test。比如： Src/main/java/Dog.java 相应的测试类 src/test/java/DogTest.java 为了让你的项目使用Junit 4 framework提供的标准的API，你需要配置测试依赖（jar 包）。如果你需要与Android依赖进行交互，需要添加Mockito库来声明你的本地单元测试。 在你的build.gradle（官方说是最顶层的那个，我放进去报错，放在模块中也可以用）中，你需要声明如下依赖： dependencies { // 必须的-- JUnit 4 framework testCompile 'junit:junit:4.12' // 可选的 -- Mockito framework testCompile 'org.mockito:mockito-core:1.10.19' } 配置仪表测试 在你的Android Studio项目中，你必须将仪表测试的源码保存在一个特定的目录（src/androidTest/java）。 为了让你的项目使用Testing Support Library，你需要配置Android测试依赖。 在你的build.gradle中，你需要声明如下依赖： dependencies { androidTestCompile 'com.android.support:support-annotations:23.0.1' androidTestCompile 'com.android.support.test:runner:0.4.1' androidTestCompile 'com.android.support.test:rules:0.4.1' // 可选的 -- Hamcrest 库 androidTestCompile 'org.hamcrest:hamcrest-library:1.3' // 可选的 – Espresso（UI测试） androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.1' // 可选的 – Automator（UI测试） androidTestCompile 'com.android.support.test.uiautomator:uiautomator-v18:2.1.1' } 为了使用Junit 4 测试类，确保在build.gradle文件中生命了默认的AndroidJUnitRunner。 android { defaultConfig { testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" } } 测试配置 Android Studio有两种测试配置：Android仪表测试和单元测试。在之前，你只能同一时间内运行一种测试。现在，可以同时运行。 构建和运行测试 Android Studio在开发环境中提供了用于构建、运行和分析你的测试的所有的工具。 需要注意的是，当你运行仪表测试时，Android Studio会关掉Instant Run。 运行本地单元测试 为了运行你的本地单元测试，你需要： 1、 在Project窗口，右键单击，同步你的项目。 2、 在Project窗口，找到相应的测试类，右键单击，选择Run。 Gradle的安卓插件会编译放在（src/test/java）下的源码，生成一个测试app，在本地执行。Android Studio会将结果显示在Run窗口 运行仪表测试 为了运行你的仪表测试，你需要在Project窗口中，找到你的仪表测试的类或方法，右键单击运行。 Gradle的安卓插件会编译放在（src/androidTest/java）下的源码，生成一个测试app和生产apk，并将两个apk安装到已经连接的设备或虚拟机中。并在Run窗口中输出结果。 本文作者：宋志辉 个人微博：点击进入
作者：宋志辉 微博：weibo.com/askzhihui/ 安装所需工具 一、新立得 新立得（Synaptic）是Debian和Ubuntu Linux操作系统的包管理工具apt的图形化前端。 它结合了图形界面的简单操作和 apt-get 命令行工具的强大功能。您可以使用新立得安装、删除、配置、升级软件包，对软件包列表进行浏览、排序、搜索以及管理软件仓库或者升级整个系统。您可以进行一些系列操作形成操作队列，并一起执行它们。新立得会提示您可能的依赖关系（您所选择的软件包所需的额外软件包）以及您所选择的软件包与系统中已经安装了的软件包的冲突。 安装方法： 1、打开Ubuntu软件中心，如图。 2、在右上角搜索框中输入新立得，我已经安装好啦，搜索到后点击安装： 二、lantern 由于众所周知得原因，这个我就不多说了。这是一款跨平台得工具。可以帮助你顺利访问Android官网。 在Ubuntu软件中心右上角搜索框中输入lantern，如图： 配置开发环境 一、新立得安装jdk和android-studio 1、打开新立得，输入root密码，进入主界面： 2、安装jdk。 在 快速过滤 中输入jdk，选中 oracle-java8-installer ，点击 应用。 等待安装成功。 3、安装android-studio。 在 快速过滤 中输入 android-studio ，选中 android-studio，点击 应用。 等待安装成功。 二、下载SDK等 1、打开lantern。 lantern成功运行得标志是打开一个弹出一个如下的网页： 现在你就可以访问android官网了（你懂的！！！）。 2、运行android-studio。 现在你可以喝点咖啡，上个微博，等待一下。就OK了。
今天写的文章莫名奇妙的没了，所以再重新写一篇。 首先，为了方便起见，我已经将系统更换成里Ubuntu，因为官方推荐使用这个Linux发行版。先来一张系统的截图： Ubuntu的版本是16.04（推荐用这个版本）。接下来是我们可能用到的软件。 git ：使用repo工具的时候会用到git，git并没有在Ubuntu中预装，所以需要事先安装git，使用命令： sudo apt-get install git 安装完成之后，需要对git进行配置，设置git的电子邮件和用户名。 git config --global user.email "你的电子邮件地址" git config --global user.name "你的名字" - curl ：官方一点的说法就是开源的文件传输工具。类似迅雷，或者wget（这个没听说过？）。其实这个工具可以用wget来代替。。。。Ubuntu在默认的情况下是不安装curl的，所以我们需要自己动手安装： sudo apt-get install curl -y OK，现在工具都准备齐了，让我们开始吧。 首先，我们需要下载repo工具，国内其他教程都是从google官网下，所以很多人都卡在这里了，这里我们不用担心（看注释）。在进行步骤之前，我们先打开终端，长这个样子： 执行如下命令： //新建一个bin目录 mkdir ~/bin //将bin目录写入环境变量（这样你在任何目录下都可以访问） PATH=~/bin:$PATH //轮到curl工具了，我们使用curl工具下载repo，并将其放置到bin目录 curl https://storage-googleapis.lug.ustc.edu.cn/git-repo-downloads/repo > ~/bin/repo //更改repo权限（不要问为啥，跟着做） chmod a+x ~/bin/repo 执行完以上命令之后，是不是有点成就感了？平日里就堵这里吧？我们继续： 接下来新建一个目录，用于放置android源码（我先执行一下pwd命令，大家看看我的当前的目录），并进入该目录，如下： mkdir android cd android 做到这一步，恭喜你，接近成功了。 接下来我们初始化仓库（这是啥？不懂别问，继续。）： repo init -u git://mirrors.ustc.edu.cn/aosp/platform/manifest （接下来这一步就是从服务器取代码了，如果你只想下载特定的android版本，可以使用如下命令： repo init -u git://mirrors.ustc.edu.cn/aosp/platform/manifest -b Android版本 Android 版本可以参考这个网址 ） 但我们下载全部代码，运行命令： repo sync 如图： 以后如果需要更新代码的话，可以再次运行这个命令。 终于再次写完了，不要再给我删掉了。
在新版ubuntu中装eclipse，很多人会遇到eclipse打开之后没有菜单栏， 其实就是缺一个环境变量UBUNTU_MENUPROXY. 在/etc/profile 里面新建这个变量并且把值写成0 export UBUNTU_MENUPROXY=0 之后重启就OK了
Google有多庞大？要回答这个问题，我们可以看收入，看股价，看客户数量，看影响力。但是这都还不够充分。说到规模，那么Google绝对是一个巨大的计算机软件帝国。为了印证着一点，我们还可以看看Google的代码规模。 周一，Google员工 Rachel Potvin 在一个硅谷举办的工程会议上提到了代码量这个问题（戳这里看视频，请科学上网）。根据她的估计，你平时用到的Google互联网服务的软件（包括搜索服务、邮箱、地图）的总代码量，大约有20亿行之多。相比之下，微软公司的Windows操作系统，作为世界上最复杂的个人电脑操作系统，从1980年代至今不断研发和演化，其代码量规模也不过是5千万行而已。 （截图来自湾区日报） 所以说，把Google的代码全部重新构建一次，其规模相当于把Windows系统构建40次之多。其实和Windows系统作比较是合乎情理的（译注：作者的意思是：可能会有人质疑，Windows只是一个操作系统软件，但是Google搜索，Gmail，Google地图是好几个软件，用一个软件的代码量与好几个软件的代码总量做比较，貌似不合乎情理，作者在后面会解释这个问题）。 和Windows的基础代码很像，Google的20亿行代码是用来驱动整个Google服务的，他们是一个整体！这20亿行代码支撑着Google搜索、Google地图、Google文档、Google plus、Google日历、Gmail、Youtube，以及其他各种Google互联网服务。并且，这20亿行代码是存放在一个单一的代码仓库里的，供Google的25000个工程师共同使用。Google把自己的代码看成一个“巨大的操作系统”，“尽管我没法证明，”，Potvin表示，“但是我猜这应该是世界上最大的单一代码仓库了。” Google的情况其实是个特例。但这个例子向我们展示了，在互联网时代我们的软件有多么的复杂，以及我们如何通过改革工具来适应这种复杂度。Google的超大代码仓库只对内部员工开放。不过，我们也有类似的工具——Github，这是一个开源代码仓库平台，它向全世界所有的工程师开放，任何人都能最大程度地共享其中的海量代码。时代变了，现在的工程师能利用超大规模的代码库进行协同工作。这也是现代互联网服务能够维持快速进化的不二之法。 “让25000个开发人员共享代码库，就像Google这种大公司做的这样，意味着开发人员丰富各异，技能多种多样。”，GitHub 的系统总监 Sam Lambert 如是说，“不过，对于小公司来讲，通过Github和开放源代码，你也可以具有（与Google）同样的优势。因为有句古话说得好：‘水涨船高’”。 “关于编译20亿行代码，其挑战的一面在于：一次性构建和运行20亿行代码，这可不是闹着玩的。”“这肯定是一项技术挑战——一次伟大的壮举。”“20亿这个数字无疑是令人震惊的。” Github的天才之处在于，它能让程序员分享和协作的代价降低。但是Github（不像Google）并不把所有东西都存储成单一软件项目。它的方式是存储上百万个小项目。Google先行一步，把无数的小项目化零为整。考虑到这涉及那么多的工程师，那么多的项目，化零为整听上去有点疯狂。但是根据Potvin的说法：Google做到了。 听 Piper 的 简单来说，Google自己做了一个“版本控制系统”，用来对其所有的代码进行判审。这个系统名字叫做Piper，它运行在整个Google的已经搭建好的庞大的在线基础设施上，并管理着所有在线服务。根据Potvin的说法，这个系统分布在10个不同的Google数据中心上。 这件事情的意义绝不仅仅是说Google的工程师能够访问20亿行代码这么简单，这件事情的意义在于：每一个Google的工程师都有充分的自由对仓库中的无数项目进行使用和组合。“你新建一个项目”，Potvin向《连线》杂志解释到，“然后就有无比富裕的代码库资源供你使用。基本上你需要的东西都有现成的。”更美妙的是，工程师对代码进行了修改以后，马上就能实施部署，然后反映到所有Google的服务上。只需要对一处进行更新，你就对所有的东西都完成了更新。 当然这个系统还是有限制的。Potvin说，有一些高度敏感的代码——比如像Google的网页排名搜索算法（PageRank Search Algorithm）这种——是放在单独的代码仓库里的，只有部分被授权的员工才能看到。因为这些算法并不在互联网上运行，因此他们和其他代码是不同的，Google还把其他两个设备相关的操作系统源代码，Android和Chrome，进行了单独的版本控制管理。不过对于绝大多数代码，Google把他们存成了一个整体，工程师可以使用它进行构建模块，提出创新以及实现解决方案。 机器人因素 Lamber指出，构建和运行一个这样的系统不仅仅需要知道基本知识，还要意识到这个系统庞大的计算能力。Piper涵盖85T数据（8500G），Google的25000名工程师每天会完成45000次提交操作。这种强度可不是开玩笑。Linux开源操作系统一共有40000个文件，1500万行代码，而Google工程师每周就会修改25000个文件，1500万行代码。 同时，Piper还需要兼顾降低程序人员的负担的任务，让程序员可以埋头修改自己的程序，而又不至于踩了别人的脚。程序员要能够把不适用的或有问题的代码移除代码库。这个任务非常困难，所以不能完全靠人工来处理这项工作。现在Google已经把把之前所用的Perforce版本控制系统切换到了Piper上，Piper使用了自动机器人来处理大多数的用户提交。 当然这不是让机器人来写代码，而是让机器人自动生成当大量的数据和配置文件，来协助用户运行软件。“为了让你的代码维持健壮，你需要做很多具体的工作”，Potvin说，“然后我们的办法是让机器人帮助你去分担这些工作，而不是只让人来做。” 人人都能用的 Piper 那么其他厂商能不能从Piper这种系统中收益呢？当然可以，并且他们正在这样做。Facebook应用的总代码量也已经达到了2亿行之多，而且Facebook也是将整个代码看成一个整体工程的。其他的企业也在这么做，只是规模上稍微小了一些。对于那些与Google或者Facebook规模差不多的公司来讲，都可以采用这样的形式。不过现在Google和Facebook正在探索新的方法，从而让每个人都能从中获益。 两大IT巨头目前都在研究，如何让超大规模的开源版本控制系统可供所有人使用。这项研究是基于已经存在的Mercurial系统开展的。“我们正在尝试，是否能够把Mercurial系统扩展到Google代码仓库的规模。”，Potvin指出。目前Google正在和编程大师Bryan O’Sullivan以及其他Facebook的程序员们通力合作，争取在这方面取得突破。 这看上去也许有点儿极端。毕竟目前大多数公司对代码的操作都达不到Google或者Facebook的那个级别。但是在不久的将来，他们就会变成那样。
Android Studio 打 Jar 包一直是一个麻烦的事，按照网上现有的教程，打包一个混淆的 jar 需要完成下列步骤： 1.将 plugin 修改为 library 后 build 出 aar，再提取 aar 里面的 classes.jar 2.使用 jarjar 等工具剔除多余的 class 3.对第二步得到的 jar 进行混淆 无论哪一步，所做的工作量都不少。于我个人而言，相当麻烦，于是花了些时间研究了下 Gradle 打 Jar 包。 代码 废话不多说，先上代码（注：只在 Gradle Android Plugin 1.2.3 测试过） build.gradle import com.android.build.gradle.AppPlugin import proguard.gradle.ProGuardTask apply plugin: ‘com.android.application’ android { compileSdkVersion 22 buildToolsVersion “22.0.1” defaultConfig { applicationId “org.chaos.demo.jar” minSdkVersion 22 targetSdkVersion 22 versionCode 1 versionName “1.0” } buildTypes { release { minifyEnabled true proguardFiles getDefaultProguardFile(‘proguard-android.txt’), ‘proguard-rules.pro’ } } } dependencies { compile fileTree(dir: ‘libs’, include: [‘*.jar’]) } //dependsOn 可根据实际需要增加或更改 task buildJar(dependsOn: [‘compileReleaseJava’], type: Jar) { appendix = “demo” baseName = “androidJar” version = “1.0.0” classifier = “release” //后缀名 extension = “jar” //最终的 Jar 包名，如果没设置，默认为 [baseName]-[appendix]-[version]-[classifier].[extension] archiveName = “AndroidJarDemo.jar” //需打包的资源所在的路径集 def srcClassDir = [project.buildDir.absolutePath + “/intermediates/classes/release”]; //初始化资源路径集 from srcClassDir //去除路径集下部分的资源 // exclude “org/chaos/demo/jar/MainActivity.class” // exclude “org/chaos/demo/jar/MainActivity$*.class” exclude “org/chaos/demo/jar/BuildConfig.class” exclude “org/chaos/demo/jar/BuildConfig$*.class” exclude “**/R.class” exclude “*/R$.class” //只导入资源路径集下的部分资源 include “org/chaos/demo/jar/*/.class” //注: exclude include 支持可变长参数 } task proguardJar(dependsOn: [‘buildJar’], type: ProGuardTask) { //Android 默认的 proguard 文件 configuration android.getDefaultProguardFile(‘proguard-android.txt’) //会根据该文件对 Jar 进行混淆，注意：需要在 manifest 注册的组件也要加入该文件中 configuration ‘proguard-rules.pro’ String inJar = buildJar.archivePath.getAbsolutePath() //输入 jar injars inJar //输出 jar outjars inJar.substring(0, inJar.lastIndexOf(‘/’)) + “/proguard-${buildJar.archiveName}” //设置不删除未引用的资源(类，方法等) dontshrink AppPlugin appPlugin = getPlugins().findPlugin(AppPlugin) if (appPlugin != null) { List runtimeJarList if (appPlugin.getMetaClass().getMetaMethod(“getRuntimeJarList”)) { runtimeJarList = appPlugin.getRuntimeJarList() } else if (android.getMetaClass().getMetaMethod(“getBootClasspath”)) { runtimeJarList = android.getBootClasspath() } else { runtimeJarList = appPlugin.getBootClasspath() } for (String runtimeJar : runtimeJarList) { //给 proguard 添加 runtime libraryjars(runtimeJar) } } } 为什么已在 manifest 注册的组件需要在 .pro 文件声明对应的混淆规则? 可能各位注意到 proguardJar task 的第二行注释，在 apk 的打包过程中，aapt 会在解析 manifest 后生成一个用于不混淆 manifest 中已注册的组件的规则文件。Gradle Android Plugin 中配置上述 aapt 生成的规则文件的代码如下： BasePlugin.groovy protected File createProguardTasks(@NonNull BaseVariantData variantData, @Nullable BaseVariantData testedVariantData) { …… // also the config file output by aapt proguardTask.configuration(variantData.processResourcesTask.proguardOutputFile) …… } 碍于个人能力原因，获取不到 processResourcesTask 的实例，所以目前只能先添加对应的组件到规则文件中，还望知道怎么获取的朋友能够分享下，谢谢。 使用方法 不需要混淆则运行命令 gradle buildJar 或 ./gradlew buildjar 需要混淆则运行 gradle proguardJar 或 ./gradlew proguardJar 最后 buildJar 这部分相对比较简单，很多内容网上都有教程。关键在于混淆，由于团队每个人都有自己的安装习惯，JDK、Android SDK 路径不一定一致，并不能直接写死 runtime 的路径，最后直接看 Android Plugin 源码才写出了 proguardJar task。
hprof-conv工具可以将Android SDK工具生成的HPROF文件生成一个标准的格式，这样你就可以使用工具进行查看： hprof-conv [-z] <infile> <outfile>
Hierarchy Viewer允许你调试和优化用户界面。它提供了一个层可视的方式来显示。 启动Hierarchy Viewer，如下： 在Android Studio中，选择Tools > Android Device Monitor。 进入SDK tools文件夹，在命令行输入 monitor
etc1tool是一个命令行工具，可以将PNG图像压缩为etc1标准，并且可以进行解压缩。 用法： etc1tool infile [--help | --encode | --encodeNoHeader | --decode] [--showDifference diff-file] [-o outfile] 选项 描述 infile 要压缩的文件 –help 帮助 –encode 根据png文件创建ETC1文件 –encodeNoHeader 根据png文件创建ETC1数据文件 –decode 根据ETC1文件创建png文件 –showDifference diff-file 原始图像和解码图像比对到diff-file文件中 –o outfile 定义输出文件名
Android SDK包含了一个运行在计算机上的移动设备虚拟机。这个虚拟机可以允许你在没有物理设备的情况下开发和测试Android应用。 键盘命令 虚拟设备按键 对应键盘按键 Home HOME 菜单 F2 Back ESC 拨号 F3 挂断 F4 搜索 F5 电源按钮 F7 声音+ Ctrl+F5 声音- Ctrl+F6 相机 Ctrl+F3 切换横竖屏幕 Ctrl+F11 网络开关 F8 全屏模式 Alt+Enter
问题描述 在Win10中，安装virtualBox后，新建虚拟电脑时，所有的操作系统都没有64位。 解决 进入控制面板->卸载程序->启用或关闭windows功能->取消hyper-v前面的勾。
9-patch是一个所见即所得的编辑器，允许你创建可以自动更改大小适应屏幕的bitmap图像。被选中的部分可以水平或垂直的进行缩放。 下面是使用9-patch工具创建一个9-patch图像的实例，首先，你需要一个png文件。 找到sdk/tools目录，运行draw9patch来启动9-patch工具。 拖动png文件到9-patch工具中（或者File > Open 9-patch… 打开相应文件）。 左边是你的绘制区域，在这里你可以绘制或更改黑色线条的大小，以控制拉伸区域等。 可以通过右键单击来擦出之前的线条。 当完成之后，选择File > Save 9-patch… ，保存为.9.png的文件。
dmtracedump是一个根据log文件生成图形化调用堆栈的工具（除了Traceview之外）。 dmtracedump的用法： dmtracedump [-ho] [-s sortable] [-d trace-base-name] [-g outfile] <trace-base-name> 工具接下来从.data 和.key载入log数据。下面表格列出了dmtracedump的参数： 参数 描述 -d trace-base-name 判断不同 -g 生成输出 -h 生成html输出 -o 丢弃trace文件 -t
Android Device Monitor是一个提供了图形化界面的可以对Android应用进行调试和分析的独立的工具。Monitor工具不需要IDE环境，比如Android Studio。包括以下工具： DDMS Tracer for OpenGL ES Hierarchy Viewer Systrace Traceview Pixel Perfect magnification viewer 用法 可以通过如下方式启动Device Monitor： 在Android Studio中，选择Tools > Android Device Monitor或者点击Android Device Monitor图标 在命令行中，定位到SDK目录的tools文件夹下，运行如下命令： monitor 启动一个Android虚拟机或者通过一个USB线连接Android设备，可以通过在Devices窗口中选择设备来连接Device Monitor。 注意：如果你使用ADT，你可能需要在运行Device Monitor之前关闭调试工具。
发表了文章
2013-04-20
发表了文章
2013-04-21
发表了文章
2013-04-25
发表了文章
2013-05-12
发表了文章
2013-05-12
发表了文章
2013-05-12
发表了文章
2013-05-12
发表了文章
2013-05-12
发表了文章
2013-05-12
发表了文章
2013-05-12
发表了文章
2013-05-16
发表了文章
2013-05-16
发表了文章
2013-05-17
发表了文章
2013-05-19
发表了文章
2013-05-19
发表了文章
2013-05-26
发表了文章
2013-05-26
发表了文章
2013-05-26
发表了文章
2013-05-27
发表了文章
2013-05-28
