精通安卓应用开发-全-

精通安卓应用开发（全）

原文：zh.annas-archive.org/md5/23E2C896EDA56175BA900FB6F2E21CF8

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

本书是学习高级 Android 应用开发的实用指南。本书帮助掌握 Android 的核心概念，并在实际项目中快速应用知识。在整本书中，创建了一个应用，并在每一章中进化，以便读者可以轻松地跟随并吸收概念。

本书共分为十二章。前三章主要关注应用的设计，解释了设计的基本概念以及在 Android 中使用的编程模式。接下来的章节旨在改进应用，访问服务器端以下载应用中要显示的信息。应用功能完成后，将使用 Material Design 组件和其他第三方库进行改进。

在结束之前，为应用添加了额外服务，如位置服务、分析、崩溃报告和盈利化。最后，导出应用，解释不同的构建类型和证书，并将其上传到 Play 商店，准备进行分发。

本书内容涵盖

第一章，入门，解释了 Android 6 Marshmallow 的基础知识以及 Material Design 的重要概念。我们将设置开始开发所需的工具，并可选地安装一个比 Android 默认模拟器更快的超快模拟器，这将帮助我们在阅读本书的过程中测试我们的应用。

第二章，设计我们的应用，介绍了创建应用的第一步——设计导航——以及不同的导航模式。我们将应用标签页模式与滑动屏幕，解释并使用 Fragments，这是 Android 应用开发的一个关键组件。

第三章，从云端创建和访问内容，涵盖了在我们应用中显示来自互联网信息所需的一切。这些信息可以在外部服务器或 API 上。我们将使用 Parse 创建自己的服务器，并使用 Volley 和 OKHttp 进行高级网络请求来访问它，处理信息并使用 Gson 将其转换为可用的对象。

第四章，并发与软件设计模式，讨论了 Android 中的并发问题及处理它的不同机制，如 AsyncTask、服务、Loader 等。本章的第二部分讲述了在 Android 中最常见的编程模式。

第五章，列表和网格，讨论了列表和网格，从 ListViews 开始。它解释了这一组件如何在 RecyclerView 中演变，并以示例展示了如何创建带有不同类型元素的列表。

第六章，CardView 和材料设计，主要从用户界面角度出发，提升应用的设计感，并引入材料设计，讲解并实现如 CardView、Toolbar 和 CoordinatorLayout 等功能。

第七章，图像处理和内存管理，主要讨论如何在我们的应用中显示从互联网上下载的图片，使用不同的机制，例如 Volley 或 Picasso。它还涵盖了不同类型的图像，如矢量可绘制图像和 Nine patch。最后，它讨论了内存管理以及如何预防、检测和定位内存泄漏。

第八章，数据库和加载器，本质上是解释 Android 中数据库的工作原理，内容提供者是什么，以及如何使用 CursorLoaders 让数据库直接与视图通信。

第九章，推送通知和分析，讨论如何使用 Google Cloud Messaging 和 Parse 实现推送通知。章节的第二部分讨论了分析，这对于理解用户如何与我们的应用互动、捕获错误报告以及保持应用无 bug 至关重要。

第十章，位置服务，通过在应用中实现一个示例来介绍 MapView，从开发者控制台的初始设置到应用中最终展示位置标记的地图视图。

第十一章，安卓上的调试和测试，主要讨论测试。它涵盖了单元测试、集成测试和用户界面测试。还讨论了使用市场上不同的工具和最佳实践，通过自动化测试开发可维护的应用。

第十二章，营利化、构建过程和发布，展示了如何使应用盈利，并解释了广告盈利化的关键概念。它展示了如何导出具有不同构建类型的应用，并最终如何在 Google Play 商店上传和推广此应用。

阅读本书所需条件

您的系统需要安装以下软件以执行本书中提到的代码：

• Android Studio 1.0 或更高版本

• Java 1.7 或更高版本

• Android 4.0 或更高版本

本书的目标读者

如果您是一位有 Gradle 和项目开发经验的 Java 开发者，并希望成为专家，那么这本书适合您。对 Gradle 的基本了解是必需的。

约定

在本书中，您会发现多种文本样式，用于区分不同类型的信息。以下是一些样式示例及其含义的解释。

文本中的代码字、数据库表名、文件夹名、文件名、文件扩展名、路径名和虚拟 URL 会以如下形式显示："我们可以通过使用include指令包含其他上下文。"

代码块如下设置：

<uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> 

当我们希望引起你注意代码块中的特定部分时，相关的行或项目会以粗体设置：

<uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> 

新术语和重要词汇会用粗体显示。你在屏幕上看到的词，例如菜单或对话框中的，会在文本中以这样的形式出现："点击下一步按钮，你会进入下一个屏幕。"

注意

警告或重要注意事项会像这样出现在一个框里。

提示

提示和技巧会像这样出现。

读者反馈

我们始终欢迎读者的反馈。请告诉我们你对这本书的看法——你喜欢或不喜欢的地方。读者的反馈对我们很重要，因为它能帮助我们开发出你真正能从中获益的图书。

要发送给我们一般反馈，只需通过电子邮件<feedback@packtpub.com>联系我们，并在邮件的主题中提及书籍的标题。

如果你有一个擅长的主题，并且有兴趣撰写或参与编写一本书，请查看我们的作者指南：www.packtpub.com/authors。

客户支持

既然你现在拥有了 Packt 的一本书，我们有一些事情可以帮助你最大限度地利用你的购买。

下载示例代码

你可以从你的账户www.packtpub.com下载你所购买的 Packt Publishing 图书的示例代码文件。如果你在其他地方购买了这本书，可以访问www.packtpub.com/support注册，我们会直接将文件通过电子邮件发送给你。

下载本书的彩色图像

我们还为你提供了一个 PDF 文件，其中包含本书中使用的屏幕截图/图表的彩色图像。彩色图像将帮助你更好地理解输出的变化。你可以从www.packtpub.com/sites/default/files/downloads/4221OS_ColorImages.pdf下载这个文件。

错误更正

尽管我们已经尽力确保内容的准确性，但错误仍然会发生。如果你在我们的书中发现了一个错误——可能是文本或代码中的错误——如果你能报告给我们，我们将不胜感激。这样做，你可以避免其他读者的困扰，并帮助我们改进本书的后续版本。如果你发现任何错误更正，请通过访问www.packtpub.com/submit-errata，选择你的书籍，点击错误更正提交表单链接，并输入你的错误更正详情。一旦你的错误更正被验证，你的提交将被接受，错误更正将被上传到我们的网站或添加到该标题错误更正部分下的现有错误更正列表中。

要查看先前提交的勘误信息，请访问www.packtpub.com/books/content/support，并在搜索字段中输入书名。所需信息将显示在勘误部分下。

盗版

互联网上对版权材料的盗版行为是所有媒体持续面临的问题。在 Packt，我们非常重视保护我们的版权和许可。如果您在互联网上以任何形式遇到我们作品的非法副本，请立即提供其位置地址或网站名称，以便我们可以寻求补救措施。

如果您发现疑似盗版材料，请通过<copyright@packtpub.com>联系我们，并提供相关链接。

我们感谢您帮助保护我们的作者以及我们向您提供有价值内容的能力。

问题咨询

如果您对这本书的任何方面有疑问，可以通过<questions@packtpub.com>联系我们，我们将尽力解决问题。

第一章：开始

我们将以 Material Design 和 Android 6 Marshmallow 的概述开始本书。谷歌的新 Material Design 概念在应用的外观和感觉上带来了一场革命。

在本书的进行过程中，我们将构建一个名为 MasteringAndroidApp 的应用。在本章中，我们将解释这个应用的内容。在这个应用中，我们将实践每一章中讲解的所有概念和理论。在本书结束时，我们应该能拥有一个功能丰富的应用，可以轻松修改以创建你自己的版本，并上传到 Google Play 商店。

我们将确保拥有所有必要的工具，下载最新版本的 Android，并介绍Genymotion，这是本书强烈推荐的最快的 Android 模拟器。

• Material Design

• Android 6 Marshmallow 的关键点

• 应用概述

• 准备工具

  • Android Studio

  • SDK 管理器

• Genymotion

介绍 Material Design

如前所述，Material Design 在应用的外观和体验上带来了一场革命。你可能之前已经听说过这个概念，但确切来说它是什么呢？

Material Design 是由谷歌创建的一种新的视觉语言，它适用于所有基于材质、有意义的过渡、动画和响应式交互的平台、网站和移动设备。

材质是可以在表面看到的一个元素的隐喻，它由可以具有不同高度和宽度的层组成，但它们的厚度始终是一个单位，就像纸张一样。我们可以将材质叠放在彼此之上，这为视图引入了深度元素，一个 Z 坐标。同样，我们可以在另一张纸上放置一张纸，投下阴影，定义视觉优先级。

内容呈现在材质上，但不会增加其厚度。内容可以以任何形状和颜色显示；可以是纯背景色、文本、视频，以及其他许多事物。内容被限制在材质的边界内。

材质可以扩展，内容也可以随之扩展，但内容永远不能超过材质的扩展。我们不能让两个材质处于同一 Z 位置。其中一个总是要在另一个下面或上面。如果我们与材质互动，我们总是在最顶层互动。例如，触摸事件将在顶层执行，不会穿透到底层。你可以改变材质的大小和形状，两个材质可以合并为一个，但它们不能弯曲或折叠。

这是一个使用 Material Design 风格的应用示例；我们可以看到带有阴影的卡片、不同的内容以及带有导航抽屉的应用栏。所有这些组件都将在本书中进行讲解，我们将致力于构建一个使用相同风格的应用。

材料设计同时也带来了重要的 UI 元素，比如RecyclerView。这是一个视图，将替代早期 Android 中的ListView，用来创建任意类型的可滚动元素列表。我们将在第五章，列表和网格中处理这些组件，从ListView的基本版本开始，演进了解RecyclerView是如何诞生的，并以一个示例结束。

CardView是另一个引入的主要 UI 元素。我们可以在前面的图片中看到一个；这是一个带有背景和阴影的组件，可以自定义以适应我们想要的所有内容。我们将在第六章，CardView 和材料设计中处理它，同时也会介绍下一个组件——设计支持库。

设计支持库是一个包含动画、FAB（浮动动作按钮）和导航抽屉的必备库。你可能已经在其他应用中见过从左侧滑出的滑动菜单。设计支持库为旧版 Android 提供了这些组件的支持，使我们能够在旧版本中使用材料设计特性。

所有以上内容都是从 UI 和编程的角度来看的特性，但材料设计同时也为我们的手机引入了不同的功能，比如具有不同优先级级别的新通知管理系统。例如，我们可以指定哪些通知是重要的，并设定一个时间段，在这个时间段内我们不想被打扰。

另一个我们不能忽视的是这个版本在电池消耗上的改进，与之前的 Android 版本相比，它最多可以节省 90 分钟的电池寿命，这得益于一个新的 Android 运行时 ART。用非技术性的方式来解释，它是在应用安装时将应用翻译成一种可以更快被 Android 理解的语言。之前的运行时Dalvik是在执行我们应用时进行这种翻译，而不是只在安装时一次翻译。这帮助应用消耗更少的电池并运行得更快。

介绍 Android 6 Marshmallow

这个版本的主要变化之一与应用的权限有关。在 Android M 之前，我们习惯在下载应用前接受应用的权限；应用商店会向我们展示一个应用拥有的权限列表，我们需要接受它们才能下载和安装应用。

运行时权限

这在引入运行时权限后发生了变化。这里的理念是在你需要时才接受权限。例如，WhatsApp 在你进行通话或留下语音消息之前可能不需要访问你的麦克风。

在开发应用程序时，我们需要考虑到这一点；这对开发者来说是一种改变，现在他们需要控制如果用户不接受权限，应该做什么。以前，在安装时，我们只需做全有或全无的选择；而现在，在运行时，我们必须考虑用户的决策。

提示

下载示例代码

您可以从您在www.packtpub.com的账户下载您购买的所有 Packt Publishing 书籍的示例代码文件。如果您在别处购买了这本书，可以访问www.packtpub.com/support注册，我们会直接将文件通过电子邮件发送给您。

省电优化

自从 Lollipop 版本以来，我们的手机电池寿命有了另外一项改进；这次，谷歌引入了两种新的状态：省电模式和应用待机。

省电模式提高了空闲设备的睡眠效率。如果我们关闭屏幕并且没有使用手机，就会进入空闲状态。以前，应用程序可以在后台进行网络操作并继续工作；现在，引入了省电模式后，系统会定期允许我们的应用程序在后台工作，并执行其他挂起操作的一段时间。在开发时，这也需要考虑；例如，在这种模式下，我们的应用程序无法访问网络。

应用待机是一种针对长时间未使用且后台没有运行任何进程的应用程序引入的空闲模式。如果一个应用程序没有显示任何通知，并且用户没有明确要求它免除优化，那么它将进入待机模式。这种空闲模式防止应用程序访问网络和执行挂起的任务。当连接电源线时，所有处于待机状态的应用程序都会被释放，空闲限制也会被移除。

文本选择

在之前的版本中，当用户选择文本时，操作栏上会出现一组操作，如复制、剪切和粘贴。在这个版本中，我们可以在浮动的工具栏中显示这些操作以及更多内容，该工具栏将显示在选定内容的上方：

指纹认证

在这个版本的 Android 中，我们可以验证指纹的使用。身份验证可以在设备级别进行，以解锁手机，不仅仅是为了解锁一个特定的应用程序；因此，我们可以基于用户最近解锁设备的情况，在应用程序中验证用户。

我们有一个新的可用对象，FingerprintManager，它将负责身份验证，并允许我们显示一个请求指纹的对话框。我们需要一个带有指纹传感器的设备才能使用这个功能。

直接分享

直接分享是一个新增加的功能，用于简化内容分享过程。以前，如果我们处在图库中，想要将图片分享给 WhatsApp 中的一个联系人，我们必须点击分享，在应用列表中找到 WhatsApp，然后在 WhatsApp 中找到联系人来分享内容。这个过程将被简化，直接显示一个你可以直接分享信息给的联系人群列表：

这些是与 Android 6 Marshmallow 一起发布的主要新特性；完整列表可以在developer.android.com/preview/index.html查看。

创建 MasteringAndroidApp

既然我们已经了解了最新 Android 版本的主要特性，接下来可以介绍我们在本书中将要开发的应用程序。这个应用程序将包括这些特性中的大部分，但我们也会花时间研究在之前 Android 版本中广泛使用的组件。

要掌握 Android，我们应该准备好理解遗留代码；例如，我们可能需要在一个仍然使用ListView而不是新出的RecyclerView的应用上工作。我们不会总是用最新的组件从零开始创建应用，特别是如果我们是专业的 Android 开发者。同时，查看之前的组件将帮助我们理解这些组件的自然演变，从而更好地了解它们现在的样子。

我们将从零开始创建这个应用，从最初的设计开始，看看在 Android 中最常用的设计和导航模式，比如顶部标签，左侧的滑动菜单等。

我们将要开发的这个应用，MasteringAndroidApp，是一个与服务器端交互的应用。这个应用将展示存储在云中的信息，我们将创建云组件，使我们的应用能够与其通信。我们为这个应用选择的主题是职位公告板，我们将在服务器端创建职位信息，应用用户可以阅读这些信息并接收通知。

你可以轻松地自定义主题；这将是一个你可以更改信息并使用相同结构创建自己应用的例子。实际上，如果你有自己的想法会更好，因为我们将讨论如何在 Play 商店发布应用以及如何实现盈利；我们将添加广告，当用户点击广告时会产生收入。所以，如果你使用自己的想法应用所学内容，等到你完成这本书时，你将拥有一个准备发布的应用。

我们将开发这个应用，并解释在 Android 中最常用的编程模式，以及并发技术和连接到 REST API 或服务器的方法。

我们不仅关注后端，也关注 UI；通过高效地展示信息，使用列表和网格，从互联网上下载图片，以及使用最新的材料设计特性来自定义字体和视图。

我们将学习如何调试我们的应用程序，管理日志，并在学习如何识别和防止内存泄漏时考虑内存使用。

我们的应用程序将基于一个数据库的离线模式，我们将把云中的内容存储在这里。因此，如果手机失去连接，我们仍然可以显示上次在线时可用信息。

为了完成我们的应用程序，我们将添加额外的功能，如推送通知、崩溃报告和数据分析。

最后，我们将了解 Android 构建系统的工作原理，以不同版本导出我们的应用程序，并对代码进行混淆以保护它，防止被反编译。

我们压缩了大量的信息，这将帮助您在本书结束时掌握 Android；但是，在开始我们的应用程序之前，让我们先准备好工具。

准备工具

在本书中我们需要用到的工具是最新版本的 Android Studio 和更新到 Android M 或更高版本的 Android SDK。还建议您使用Genymotion，这是一个用于测试应用程序的模拟器。

注意

首先，我们需要下载并安装 Android Studio，这是在 Android 上进行开发的官方工具。可以从developer.android.com/sdk/index.html下载。

在网站的顶部，您可以根据您的操作系统版本找到一个下载链接。

安装完成后，我们需要下载一个 Android M SDK，它将为特定 Android 版本的应用程序开发提供所有必要的类和资源。这是通过 SDK 管理器完成的，它是 Android Studio 内包含的一个工具。

我们可以点击工具 | Android | SDK 管理器，或者在 Android Studio 最上方的栏中找到快捷方式。

打开 SDK 管理器后，我们将看到一个可用 SDK 平台和 SDK 工具的列表。我们需要确保已安装最新可用的版本。

这样，我们就有了我们开发应用程序所需的一切。为了测试它，理想情况下应该有 Genymotion，这是一个 Android 模拟器，它将帮助我们测试在不同设备上的应用程序。

我们使用这个模拟器而不是 Android 默认模拟器的主要原因是速度。在 Genymotion 上部署应用程序甚至比使用物理设备还要快。除此之外，我们还受益于其他功能，例如可调整大小的窗口、从我们的计算机复制和粘贴，以及使用默认模拟器时耗时的一些小细节。可以从www.genymotion.com下载。

我们需要做的就是安装它，一旦打开，我们就可以添加具有现有设备包含相同功能的模拟器。

总结

在本章中，我们回顾了最新版本的 Android 中的重要变化，重点介绍了 Android Marshmallow 和 Material Design。

我们说明了将在本书的学习过程中开发的应用程序中将执行的操作以及创建它所需的工具。

在下一章中，我们将研究 Android 中现有的设计模式并开始设计我们的应用程序。

第二章：设计我们的应用

在本章中，我们将为应用想出一个点子，并将这个点子转化为真实的应用，创建要在屏幕上显示的基本结构，并选择一个合适的导航模式在它们之间移动。

在查看最常用的导航模式之后，我们将继续实现由片段和ViewPager组成的标签模式。

在此期间，我们将回顾关于片段的知识，以便能够解释高级概念。我们还将讨论FragmentManager和片段后退栈的重要性。

最后，我们将在屏幕过渡中添加一些美观的动画。因此，本章我们将涵盖以下主题：

• 选择应用导航模式

• 精通片段

• 实现标签和 ViewPager

• 屏幕之间的动画过渡

选择应用导航模式

假设有一天你醒来时感到很有灵感；你有一个应用点子，你认为它可能比 WhatsApp 还要受欢迎。不要浪费时间，你会想要将这个应用点子变为现实！这就是为什么你需要学习如何设计应用并选择最合适的导航模式。不是要让你失去信心，但你会发现你的 99%的点子已经在 Google Play 商店里了。事实上，有数十万个应用可供选择，而且这个数字还在不断增加！所以，你可以选择改进已有的应用，或者继续头脑风暴，直到你有一个原创的点子。

为了将应用变为现实，第一步是在脑海中可视化应用；为此，我们需要确定基本组件。我们需要在屏幕上简化想法，并且需要在屏幕之间移动。

请记住，你正在为 Android 用户创建这个应用。这些用户习惯于使用如 Gmail、Facebook 和 Spotify 等应用中的滑动面板这样的导航模式。

我们将看看三种不同的常用导航模式，这些模式保证用户在我们的应用中不会迷失方向，并能立即理解应用结构。

基本结构

为了绘制我们的屏幕（请注意，我这里不是指活动或片段；所谓屏幕是指用户在我们的应用执行期间任何时候实际可以看到的内容），我们需要确定我们想法的关键点。我们需要用软件开发术语来建立用例。

让我们从确定本书学习过程中要构建的应用的形状开始：MasteringAndroidApp。一开始很难在脑海中想象出所有细节，所以我们将从确定我们肯定需要的组件开始，稍后再填补可能存在的空白。

我们从上一章知道，我们有一个演示屏幕，它会在需要时从互联网下载数据的同时显示应用的徽标几秒钟。

在这个应用程序中，我们还将有一个包含来自互联网的信息列表的屏幕，用户可以点击单个项目获取更详细的信息。

作为主要选项，我们将展示一个带有MapView显示我的位置和联系数据的联系人屏幕。

最后，我们需要一个偏好设置或设置屏幕，在这里我们可以打开或关闭通知，以及禁用广告或购买额外内容。

现在，我们已经准备好创建一个草图。请看以下图片：

首先，我们有应用程序的入口点，即启动屏幕。这里的导航很直接；我们可以直接导航到下一个屏幕，并且没有按钮或任何其他可能的流程。

在下一级，我们有一个项目列表的屏幕（即带有联系信息的屏幕）、一个地图视图和一个设置屏幕。这三个屏幕在我们的应用程序中处于同一级别，因此它们具有同等的重要性。

最后，我们有一个第三层导航，即列表项的详细视图。

我们打开这个屏幕的唯一方式是点击列表中的一个元素；因此，这个屏幕的入口点是列表屏幕。

既然我们已经建立了一个基本的结构和流程，接下来我们将研究各种广泛使用的导航模式，以决定哪一种最适合我们的应用程序。

注意

有关应用程序结构和有关材料设计类似信息的更多信息，请参考以下链接：

developer.android.com/design/patterns/app-structure.html

www.google.com/design/spec/patterns/app-structure.html#

仪表板模式

仪表板模式是 Android 中最早使用的模式之一。它由一组在主屏幕上以图标矩阵形式显示的元素组成。在以下图片中，我们可以看到左侧是 Facebook 应用程序的早期版本，右侧是 Motor Trend 对该模式的定制：

这种视图非常适合那些旨在清晰显示非常有限的选项的应用程序；每行不超过两个元素，行数适合屏幕显示。

这些图标清晰地展示了主要功能的符号，所有选项都在同一级别。这对于拥有大量目标受众的应用程序来说是一个理想的模式；它简单明了，一目了然，任何人都可以进行导航。

尽管这个设计看起来很古老，考虑到它曾在 Android 的第一个版本中被广泛使用，现在使用得较少，但它的使用取决于您的需求，因此不要因此而放弃。前面图片中显示的 Motor Trends 应用程序对这个模式有一个非常原始的实现。

如果元素不适合屏幕显示，我们需要滚动才能发现它们，那么我们需要重新考虑这个模式。当我们元素太少时也同样适用；这些情况下有更好的选择。在我们的具体示例中，我们有三个主要元素，因此我们将不使用此模式。

滑动面板

这种模式因如 Gmail 和 Facebook 等应用而广为人知。它在用户界面的顶层展示一个布局；当我们执行滑动手势或点击左上或右上按钮时，屏幕会从左或右滑出，这个按钮通常是一个显示三条水平线的图标，也被称为汉堡图标。

如果我们的应用在同一层级有大量选项，这个模式是完美的，并且它可以与其他模式结合使用，比如选项卡模式。

此面板的实现可以通过DrawerLayout类完成，它由两个子视图组成：包含内容和导航抽屉的FrameLayout，导航抽屉可以是ListView或包含选项的任何其他自定义布局。

为此，执行以下代码：

<android.support.v4.widget.DrawerLayout    
   android:id="@+id/drawer_layout"   
   android:layout_width="match_parent"   
   android:layout_height="match_parent" >   

   <FrameLayout   
    android:id="@+id/frame_container"   
    android:layout_width="match_parent"   
    android:layout_height="match_parent" />   

   <ListView   
    android:id="@+id/drawer_list"   
    android:layout_width="240dp" 
    android:background="#fff"  
    android:layout_height="match_parent"   
    android:layout_gravity="start" />   

  </android.support.v4.widget.DrawerLayout>

一旦我们在侧面板中选择了一个元素，屏幕中间就会出现一个子元素；这个子元素可以帮助你导航到子子元素，但绝不能导航到主菜单的元素。子元素和子子元素的导航可以通过后退按钮或操作栏中的向上导航来管理。

我们可以通过点击一个条目来关闭面板，并通过设置一个抽屉监听器ActionBarDrawerToggle来知道面板是关闭还是打开，它包含onDrawerClosed(View drawerView)和onDrawerOpened(View drawerView)方法。

确保你使用的是android.support.v7.app中的ActionBarDrawerToggle，v4 中的已弃用。

这种模式的另一个大优点是它允许通过菜单上的主项目进行分组导航，可以展开成子项目。正如以下示例所示，项目 4 在下拉菜单中有三个选项：

抽屉布局的一个示例

这对我们的应用程序来说并不合适，因为我们没有足够的选项来充分利用这个模式。此外，由于这个模式可以与选项卡模式结合，从教育角度来看，用这个模式开发我们的示例更有意义。

选项卡

选项卡模式是一种你可能之前见过并使用过的模式。

它显示了一个具有同一层级组件的固定菜单。注意，当我们有选项卡时，菜单总是可见的，这在滑动和仪表板模式中不会发生。这看起来与网页界面非常相似，并且考虑到用户可能已经熟悉这个模式，它非常用户友好。

以下模式有两个变体：固定和滑动选项卡。如果我们只有少量可以适应屏幕的菜单项，第一个变体将是最合适的，因为它一次向用户展示所有项目。

当所有项目不适合屏幕或适合但知道将来会添加更多项目而无法容纳时，通常会使用滑动标签页。

这两个变体的实现略有不同，因此我们需要在决定变体时考虑未来的变化。在这里，我们可以看到一个滑动变体的实现：

提示

记住，为了平台一致性，我们必须将标签放在屏幕顶部；否则，人们会认为你是 iOS 开发者！

以下是一些供你遵循的材料设计指南中的功能和格式规范：

• 将标签作为单行呈现。如果需要，将标签文字换行到第二行，然后截断。

• 不要在标签页内包含一组标签化内容。

• 高亮显示与可见内容对应的标签页。

• 按层次结构将标签页分组。将一组标签与其内容连接起来。

• 保持标签与其内容相邻。这有助于减少两者之间的歧义，保持关系。

在以下图片中，我们可以看到一个带有子菜单的滚动/滑动标签页的例子：

注意

设计标签时图形规格以及有关标签规范更多信息可以在www.google.com/design/spec/components/tabs.html#找到。

既然我们已经了解了应用导航的基础知识，我们可以探索实现这些模式所需的组件。正如你所知，主要组件是活动和片段。我们将实现一个带有三个片段的滑动标签页的例子。

片段

在本节中，我们将简要回顾片段的关键概念，以解释高级功能和组件，如片段管理器和片段回退栈。

在我们的例子中，我们将创建一个名为MainActivity的活动和四个片段：ListFragment、ContactFragment、SettingsFragment和DetailsFragment。为此，你可以创建一个fragments包，双击该包装进入新建 | 片段 | 空白片段。看看以下对话框：

现在，你可以不使用片段工厂方法和接口回调来创建它们。我们将在本章后面介绍这些内容。

目前我们的项目在项目视图中应该看起来像这样：

理解片段的重要性

片段代表活动中的行为或用户界面的一部分。你可以在单个活动中组合多个片段来构建多窗格 UI，并在多个活动中重用片段。你可以将片段视为活动的模块化部分，它有自己的生命周期并接收自己的输入事件，你可以在活动运行时添加或移除（有点像可以在不同活动中重用的子活动）。

片段的生命周期与活动的生命周期略有不同。我们注意到的第一个区别是使用了OnAttach()和OnDetach()方法，它们将片段与活动连接起来。

在onCreate()中使用，我们可以在OnCreateView()中创建视图；在这之后，我们可以在片段中调用getView()，它不会是 null。

onActivityCreated()方法告诉片段其活动在其自身的Activity.onCreate()中已完成。

有两种方法可以显示一个片段：

第一种方式是在我们的布局 XML 中拥有片段。这将创建我们的片段，当包含它的视图被填充时。执行以下代码：

<LinearLayout 
    android:orientation="horizontal"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <fragment android:name="com.example.android.MyFragment"
              android:id="@+id/headlines_fragment"
android:layout_width="match_parent"
              android:layout_height="match_parent" />
</LinearLayout>

第二种方式是程序化创建我们的片段，并告诉片段管理器在容器中显示它。为此，你可以使用以下代码：

<LinearLayout 
    android:orientation="horizontal"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">

    <Framelayout android:id="@+id/fragment_container"
android:layout_width="match_parent"
             android:layout_height="match_parent" />

</LinearLayout>

之后，使用以下代码行填充一个FrameLayout容器，片段将被插入到其中：

Myfragment fragment = MyFragment.newInstance();
getSupportFragmentManager().beginTransaction()
                    .add(R.id.fragment_container, fragment).commit();

为了结束关键概念，解释为什么 Android 示例使用MyFragment.newInstance(params)工厂方法创建片段而不是使用默认的new MyFragment(params)构造函数是很重要的。请看以下代码：

public class MyFragment extends Fragment {

 // Static factory method that returns a new fragment
 // receiving a   parameter and initializing the fragment's arguments

    public static MyFragment newInstance(int param) {
        MyFragment fragment = new MyFragment();
        Bundle args = new Bundle();
        args.putInt("param", param);
        fragment.setArguments(args);
        return fragment;
    }
}

这种模式背后的原因是，Android 只使用默认构造函数重新创建片段；因此，如果我们有一个带参数的构造函数，它将被忽略，参数将丢失。

提示

请注意，我们将参数作为 bundle 中的参数传递，这样如果片段需要被重新创建（由于设备方向改变，我们使用后退导航），片段就可以检索参数。

片段管理器

片段管理器是一个接口，用于与活动内的片段交互。这意味着任何操作，如添加、替换、移除或查找片段，都必须通过它来完成。

要获取片段管理器，我们的Activity需要继承自FragmentActivity，这将允许我们调用getFragmentManager()或getSupportFragmentManager()，优先选择后者因为它使用了Android.support.v4中包含的向后兼容的片段管理器。

如果我们想使用嵌套片段，可以用getChildFragmentManager()来管理它们。当布局包括<fragment>时，你不能将布局填充到片段中。只有当动态地将嵌套片段添加到片段中时，才支持嵌套片段。

现在，我们将讨论在使用片段时迟早会遇到的一些场景。设想我们有一个带有两个片段 A 和 B 的活动。

一个典型的情况是，我们处于一个片段中，并希望执行活动中的方法。在这种情况下，我们有两个选择；一个是 在MyActivity中实现一个public方法，例如doSomething()，这样我们可以将getActivity强转为我们的活动，并调用((MyActivity)getActivity).doSomething();方法。

第二种方法是让我们的活动实现碎片中定义的接口，并在onAttach(Activity)方法中将活动的实例设置为该接口的监听器。我们将在第四章 并发与软件设计模式中解释这种软件模式。反过来，如果要让活动与碎片通信（如果我们没有在活动的变量中实例化碎片 A），我们可以找到管理器中的碎片。我们将在下一节中查看如何使用容器 ID 或标签查找碎片：

FragmentManager fm = getSupportFragmentManger();
FragmentA fragmentA = fm.findFragmentById(R.id.fragment_container);
fragmentA.doSomething(params);

最后一种情况是在碎片 A 中与 B 对话；为此，我们只需从活动中获取管理器并查找碎片。运行以下代码：

FragmentManager fm = getActivity().getSupportFragmentManger();
FragmentA fragmentA = fm.findFragmentById(R.id.fragment_container);
fragmentA.doSomething(params);

碎片堆栈

我们一直在谈论在碎片管理器中查找碎片，这要归功于碎片管理器的碎片堆栈，我们可以在事务期间添加或移除碎片。

当我们想要动态显示一个碎片时，我们可以决定是否要将碎片添加到堆栈中。将碎片放在堆栈上允许我们导航回上一个碎片。

这对于我们的示例非常重要；如果用户在第一个标签页上，点击列表中的项目，我们希望他能看到详情屏幕，DetailsFragment。现在，如果用户在DetailsFragment上，点击返回按钮，我们不希望他离开应用；我们希望应用能导航回碎片堆栈。这就是为什么我们在添加DetailsFragment时，必须包含addToBackStack(String tag)选项。标签可以为 null，也可以是一个String类型，这将允许我们通过标签找到这个新碎片。它将类似于以下内容：

FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.replace(R.id.simple_fragment, newFragment);
ft.addToBackStack(null);
ft.commit();

进一步说明，如果我们想在三个碎片之间导航，从 A 到 B 再到 C，然后返回，拥有一个堆栈将允许我们从C 到 B 再到 A。然而，如果我们不将碎片添加到返回堆栈，或者如果我们在同一个容器中添加或替换它们，从 A 到 B 再到 C，这将只留下 C 碎片，并且无法进行返回导航。

现在，要在DetailsFragment中实现返回导航，我们必须让活动知道，当我点击返回时，我想首先在碎片中导航回退，然后才退出应用，这是默认的行为。如果堆栈中有一个以上的碎片，可以通过覆盖onKeyDown并处理碎片导航来实现。运行以下命令：

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK && getSupportFragmentManager.getBackStackEntryCount > 1) {
getSupportFragment.popBackStack();
return true;
}
return super.onKeyDown(keyCode, event);
}

视图翻页器

继续我们的示例，在MainActivity上有两种在碎片之间导航的方法：通过点击标签或通过在碎片间滑动。为了实现这一点，我们将使用ViewPager，包括其中的滑动标签，这是一个非常优雅的解决方案，代码量最少，并包括滑动与标签之间的同步。

ViewPager可用于滑动任何类型的视图。我们可以用ViewPager创建一个图片画廊；在一些应用首次运行时，常见到使用滑动屏幕来展示如何使用应用的教程，这是通过ViewPager实现的。要将ViewPager添加到MainActivity，我们可以简单复制并粘贴以下代码：

<?xml version="1.0" encoding="utf-8"?>
<android.support.v4.view.ViewPager

android:id="@+id/pager"
android:layout_width="match_parent"
android:layout_height="match_parent" />

在ViewPager部分最后，我们将了解如何使用不同的第三方库来改善标签页的体验，以及如果我们想要自定义解决方案，如何手动创建这些标签页。

适配器

ViewPager与适配器一起工作；适配器是负责创建我们滑动的每个页面的元素。在滑动片段的特殊情况下，我们可以使用Adapter类的扩展，称为FragmentPagerAdapter和FragmentStatePagerAdapter：

• FragmentStatePagerAdapter保存页面的状态，在屏幕上不显示时销毁它，并在需要时重新创建，类似于ListView对其行所做的处理。

• FragmentPagerAdapter将所有页面保存在内存中；因此，在滑动时没有与保存和恢复状态相关的计算成本。我们可以拥有的页面数量取决于内存。

根据元素的数量，我们可以选择其中一种。如果我们正在创建一个阅读新闻的应用，用户可以在带有图片和不同内容的新闻文章之间滑动，我们不会尝试将所有内容都保存在内存中。

我们有三个固定标签，因此我们将选择FragmentPagerAdapter。我们将创建一个包适配器，并创建一个扩展FragmentPagerAdapter的MyPagerAdapter类。在扩展它时，我们需要覆盖getCount()和getItem(int i)方法，这些方法返回项目的数量和给定位置的项目。

创建构造函数并完成方法后，我们的类将类似于以下代码：

public class MyPagerAdapter extends FragmentPagerAdapter {

    public MyPagerAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int i) {
        switch (i) {
            case 0 :
                return new ListFragment();
            case 1 :
                return new ContactFragment();
            case 2 :
                return new SettingsFragment();
            default:
                return null;
        }
    }

    @Override
    public int getCount() {
        return 3;
    }
}

最后，我们需要在MainActivity中将适配器设置到页面。执行以下代码：

public class MainActivity extends FragmentActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MyPagerAdapter adapter = new MyPagerAdapter(getSupportFragmentManager());
        ViewPager viewPager = (ViewPager) findViewById(R.id.pager);
        viewPager.setAdapter(adapter);

    }

}

滑动标签

在我们的示例中，此时我们已经能够在片段之间滑动。现在，我们将使用PagerTabStrip或PagerTitleStrip添加标签。

有一种非常优雅的实现方式，即在ViewPager的 XML 标签中包含PageTabStrip。执行以下代码：

<?xml version="1.0" encoding="utf-8"?>
<android.support.v4.view.ViewPager

android:id="@+id/pager"
android:layout_width="match_parent"
android:layout_height="wrap_content">

    <android.support.v4.view.PagerTabStrip
        android:id="@+id/pager_title_strip"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="top"
        android:background="#33b5e5"
        android:textColor="#fff"
        android:textSize="20dp"
        android:paddingTop="10dp"
        android:paddingBottom="10dp" />

</android.support.v4.view.ViewPager>

在这里，PagerTabStrip会找到页面的标题，并为每个页面显示一个标签。我们需要在MyPagerAdapter中添加getPageTitle方法，这将返回每个页面的字符串。在我们的案例中，这将是部分名称：列表、联系人及设置。为此，你可以使用以下代码：

@Override
public CharSequence getPageTitle(int position) {
  switch (position) {
    case 0 :
    return "LIST";
    case 1 :
    return "CONTACT";
    case 2 :
    return "SETTINGS";
    default:
    return null;
  }
}

运行应用，瞧！我们轻松实现了一个流畅的标签页和滑动导航支持，支持 Android 1.6（API 4）：

自定义标签

Android 中的标签有一段很长的历史；最初，标签是通过TabActivity实现的，但在 API 13 中被废弃，并演变成了FragmentTabHost。

因此，我按照 Android 文档，开心地使用TabHost开发了一个应用，并意识到这必须改变。起初，我抱着侥幸心理，希望废弃不会影响我的应用，直到一些用户抱怨崩溃问题。然后，不可避免地，我必须移除废弃的TabHost并寻找新方法。

起初，FragmentTabHost似乎是拥有固定标签的好方法，但它不允许标签上带有图标。在遇到这个问题，并在 Stack Overflow 上发现其他人也有同样的问题时（一个我们可以提问和找到关于 Android 和其他主题答案的网站），我决定寻找其他方法。

在 API 11 中，出现了ActionBar.Tab的概念，这是一个允许我们向操作栏添加标签的类。最终，我找到了一种在应用中添加标签的方法，这让用户很开心！但这种喜悦并未持续太久；ActionBar.Tab又被废弃了！

这件事会让任何开发者的耐心耗尽；这让我创建了在LinearLayout中以按钮形式呈现的标签。在按钮上设置点击监听器，点击标签时，我会将ViewPager滑动到正确的页面，反之亦然，当检测到ViewPager页面滑动时，我会选择正确的标签。努力是值得的，因为它让我在设计标签时有完全的自由度，更重要的是，它给了我满足感，除非有一天LinearLayout或Button被废弃，否则它总是能工作！

你总可以将自己的实现作为最后的选择。如今，如果你不喜欢滑动标签的设计，还有第三方库的其他选择，比如ViewPagerIndicator和PagerSlidingTabStrip。

注意

若要了解更多信息，你可以查看以下链接：

ViewPagerIndicator 的 GitHub 仓库

PagerSlidingTabStrip 的 GitHub 仓库

过渡效果

比如创建我们自己的屏幕过渡动画等小细节，这些都能让我们的应用更加精致，看起来更加专业。

我们的示例非常适合讨论过渡，因为我们有两种类型的屏幕过渡：

• 第一个转换是活动之间的转换，从SplashActivity到MainActivity

• 第二个转换（尚未实现）是片段之间的转换，其中ListFragment被DetailsFragment替换。

对于活动之间的过渡，我们需要在启动新活动之前调用overridePendingTransition。该方法接收两个动画作为参数，这些动画可以是我们创建的 XML 文件中的，也可以是 Android 中已经创建的动画。运行以下命令：

overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);

在我们的示例中，我们不允许可返回导航到SplashActivity；然而，如果我们处于活动之间的过渡，并希望在点击返回时拥有相同的过渡效果，我们就必须重写返回键并在此处设置我们的过渡效果。为此，你可以运行以下命令：

@Override public void onBackPressed() {
   super.onBackPressed();        overridePendingTransition(android.R.anim.fade_in,  android.R.anim.fade_out); 
}

在片段的情况下，我们需要在FragmentTransaction对象中指定过渡。使用对象动画师，我们可以在两个文件中定义这一点：enter.xml和exit.xml。执行以下代码：

FragmentTransaction transaction = getFragmentManager().beginTransaction();
transaction.setCustomAnimations(R.animator.enter, R.animator.exit);
transaction.replace(R.id.container, new DetailsFragment());
transaction.commit();

enter.xml

<?xml version="1.0" encoding="utf-8"?>
<set>
     <objectAnimator

         android:duration="1000"
         android:propertyName="y"
         android:valueFrom="2000"
         android:valueTo="0"
         android:valueType="floatType" />
</set>

exit.xml 
<?xml version="1.0" encoding="utf-8"?>
<set>
    <objectAnimator

        android:duration="1000"
        android:propertyName="y"
        android:valueFrom="0"
        android:valueTo="-2000"
        android:valueType="floatType" />
</set>

对于 Android Lollipop 及其之后的版本，你可以直接为 Fragment 设置过渡。使用以下代码片段：

Fragment f = new MyFragment();
f.setEnterTransition(new Slide(Gravity.RIGHT));
f.setExitTransition(new Slide(Gravity.LEFT));

总结

在本章结束时，你应该了解基本的导航模式，并能将你心中应用程序的想法转化为 Android 应用程序的实际结构。Fragments 是 Android 开发中的关键概念，我们在本章中已经花费足够的时间通过复习 Fragment Manager 和片段回退栈来掌握它们，并学习如何面对诸如它们之间的通信等常见问题。我们考虑了一个带有PagerTabStrip的ViewPager的工作示例，它将页面标题作为标签显示，你现在知道如果需要如何自定义它。我们有一个应用程序的框架；这个项目可以在这一阶段保存，并用作你未来开发的模板。我们已经准备好继续发展我们的应用程序。

在下一章中，我们将学习如何创建和访问将填充我们片段和ViewPager的内容，以使我们的应用程序生动起来。

第三章：从云端创建和访问内容

在本章中，我们将学习如何使用我们的应用程序从网络上获取内容；这些内容可能是一个 XML 或 JSON 文件中的项目列表（我们希望展示的内容），从互联网上获取。例如，如果我们正在构建一个显示当前天气状况的应用程序，我们需要联系外部 API 以获取所需的所有信息。

我们将在 Parse 中创建自己的云数据库，这项服务允许我们非常快速地完成这一操作，而无需创建和维护自己的服务器。除此之外，我们还将用要在MasteringAndroidApp中展示的信息填充数据库。

我们还将介绍与 Google Volley 网络请求相关的最佳实践，使用超快的 HTTP 库 OkHttp，以及使用 Gson 高效地解析请求的对象。我们将在本章中介绍以下主题：

• 创建你自己的云数据库

• 从 Parse 中消费内容

• Google Volley 和 OkHttp

• 使用 Gson 解析对象

创建你自己的云数据库

在项目的这个阶段，我们必须开始构建我们自己的版本的MasteringAndroidApp。你可以自由地开发自己的思路，并使用数据库存储自己的数据。以本例为指南，你不必严格按照我写的代码逐行复制。实际上，如果你在本书的最后开发出自己的示例，你将得到一个你可以使用的东西。例如，你可以创建一个供个人使用的应用程序，如任务提醒、旅行日记、个人照片画廊，或任何适合在云端存储的东西。

你也可以尝试将这个应用货币化；在这种情况下，你应该尝试为用户开发一些有趣的东西。例如，它可以是新闻源阅读器或食谱阅读器；它可以是任何可以提交内容到云端并通知用户新内容可用的应用。

在此过程中，我们将解释Application类的重要性，该类用于在我们的项目中设置 Parse。

Parse

如果你每秒的请求少于 30 次，Parse 是免费的。我猜想，如果你的应用有足够的用户每秒请求信息 30 次，即每分钟 1,800 次，你肯定能负担得起升级到付费账户，甚至构建自己的服务器！这项服务是一种非常简单且可靠的方法，可以为你的应用提供服务器端支持。此外，它还提供推送通知服务和分析，这也是它的一个优点。

我们将开始创建一个新账户；之后，我们需要在 Parse 中为我们的应用程序命名。在这里，我将使用MasteringAndroid。命名应用程序后，你将进入账户的主页。我们需要导航至数据服务 | 移动端 | Android | 原生 Java。

下图展示了作为云的数据服务：

将 Parse SDK 添加到我们的项目中

要从我们的应用程序访问数据服务，我们需要安装 Parse SDK（系统开发工具包）。为此，Parse 指引我们查看一个快速入门指南，其中包含所有代码，包括我们应用程序的 API 密钥，这些代码已准备好复制并粘贴到我们的项目中。

基本上，我们需要完成两个步骤：

1. 第一步是下载一个 .jar 库文件，我们需要将其复制到项目中的 libs 文件夹内。复制后，我们需要告诉我们的构建系统在应用程序中包含这个库。为此，我们需要在 Application 文件夹内找到 build.gradle 文件（注意，我们的项目中有两个 build.gradle 文件），并添加以下几行：

   dependencies {
     compile 'com.parse.bolts:bolts-android:1.+'
     compile fileTree(dir: 'libs', include: 'Parse-*.jar')
   }
   

2. 在下图中，你可以看到两个名为 build.gradle 的文件；被选中的是正确的文件：

3. 第二步是在我们的项目中初始化 Parse SDK；为此，我们可以直接导航到www.parse.com/apps/quickstart?app_id=masteringandroidapp。在链接中替换你自己的应用 ID，或者通过点击主页找到链接，如下面的截图所示：

4. 点击 快速入门指南 后，转到 数据 | 移动 | Android | 原生 | 现有项目。

5. 如果尚未添加，系统会提示你在 AndroidManifest.xml 文件中添加 INTERNET 和 ACCESS_NETWORK_STATE 权限。

Android 的 Application 类

接下来我们要注意的一点是，我们需要将初始化 Parse 的代码添加到我们的 Application 类中；然而，我们的 Application 类在项目中默认并未创建。我们需要创建并了解 Application 类是什么以及它是如何工作的。

要创建一个 Application 类，我们将在包上右键点击并创建一个新的 Java 类，名为 MAApplication，继承 Application。一旦继承了 Application，我们就可以重写 onCreate 方法。然后，我们将在类内部右键点击 | 生成。 | 重写方法 | onCreate。

这将重写 onCreate 方法，我们将准备好在那里实现我们自己的功能。onCreate 方法每次创建我们的 Application 时都会被调用；因此，它是初始化我们的库和第三方 SDK 的正确位置。现在，你可以按照快速入门指南中看到的 Parse 初始化行进行复制和粘贴。

提示

请注意，这是唯一的，对于你自己的账户，你应该有自己的密钥。

Parse.initialize(this, "yourKeyHere", "yourKeyHere");

最后，我们需要告诉我们的应用程序有一个新的 Application 类，并且我们想要使用这个类；如果我们不这样做，我们的 Application 类将不会被识别，onCreate 也不会被调用。

在我们的清单文件中，我们需要在 <application> 标签内设置属性名称以匹配我们自己的应用程序。执行以下代码：

<application
    android:name="MApplication "
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_newname"
>

应用程序类封装了我们应用中的所有内容；活动包含在应用程序中，随后，片段包含在活动中。如果我们需要在应用中访问所有活动/片段的全局变量，这将是一个合适的地方。在下一章中，我们将了解如何创建这个全局变量。以下图表是应用程序的图形结构：

创建数据库

如我们所知，在本书中我们将创建一个示例应用，该应用将提供与 Android 相关的职位信息；因此，我们需要创建一个数据库来存储这些职位信息。

在开发过程中可以更改数据库（当应用发布并拥有用户时，这将变得更加困难）。但是，现在我们将从大局出发，创建整个系统，而不是拥有一个包含所有字段完成的最终版数据库。

要创建一个表，请点击如下截图所示的Core部分：

首先，通过点击+ 添加类按钮创建一个表，并将其命名为JobOffer，包含以下属性，可以通过点击Col+按钮添加：

• objectId: 这是默认创建的：String

• title: 这是职位名称：String

• description: 这是工作描述：String

• salary: 这表示薪水或日薪：String

• company: 这表示提供工作的公司：String

• type: 这表示员工的类型，可以是永久、合同或自由职业者：String

• imageLink: 这是公司的图片：String。

• Location: 这表示工作的地点：String

• createdAt，updatedAt: 这是工作的日期；这些列是使用默认日期创建的

要向表中添加数据，请在左侧选择表并点击+ 行。我们只需要完成我们创建的列；默认创建的列，如 ID 或日期，将自动完成。到目前为止，我们的表应如下所示：

随意添加更多详细信息，例如联系人、电子邮件和手机号码。你也可以添加更多表；例如，一个新的JobType表，包含工作类型和字段类型，而不是String，应为Relation<JobType>。

我们已经拥有我们示例所需的内容；接下来要做的是使用我们的应用程序消费这些数据。

在 Parse 中存储和消费内容

Parse 是一个非常强大的工具，它不仅允许我们轻松地消费内容，还可以从我们的设备将内容存储在云数据库中，使用传统方法进行这项任务是相当繁琐的。

例如，如果我们想从设备上传图片到自定义服务器，我们就需要创建一个POST请求，并发送一个带有正确编码的表单，同时将图片作为FileBody对象附加在MultiPartEntity中，并导入 Apache HTTP 库：

HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = new HttpPost("URL TO SERVER");

MultipartEntity mpEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE);
File file = new File(filePath);
mpEntity.addPart("imgField", new FileBody(file, "application/octet"));

httppost.setEntity(mpEntity);
HttpResponse response = httpclient.execute(httppost);

现在，让我们看看 Parse 的替代方案：

ParseFile imgFile = new ParseFile ("img.png", ImgByteArray);

ParseObject myParseObject = new ParseObject ("ParseClass");    
 myParseObject.put("imageField", imgFile);
 myParseObject.saveInBackground();

让我们不要忘记在 Parse 上处理错误。你可以简单地这样写，非常优雅：

imageObj.saveInBackground(new SaveCallback() {
  @Override
  public void done(ParseException e) {
    if (e == null) {
      //Successful
    } else {
      //Error
    }
  }
});

存储内容

为了说明 Parse 的简便性，我们将从我们的应用程序将职位信息上传到我们的 Parse 云。

为了实现这一点，我们可以在联系人片段中创建一个按钮，在应用程序的最终版本中将其设置为不可见，因为我们不希望用户自己上传职位信息。

通过这个按钮，我们将创建一个类似于地图的ParseObject。我们将添加我们想要完成的字段，之后我们将调用saveInBackground()方法，这是上传对象的方法。执行以下代码：

view.findViewById(R.id.addJobOffer).setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View view) {

    ParseObject jobOffer = new ParseObject("JobOffer");

    jobOffer.put("title", "Android Contract");
    jobOffer.put("description", "6 months rolling    contract. /n The client" +
    "is a worldwide known digital agency");
    jobOffer.put("type", "Contract");
    jobOffer.put("salary", "450 GBP/day");
    jobOffer.put("company", "Recruiters LTD");
    jobOffer.put("imageLink", "http://.....recruitersLTD_logo.png");
    jobOffer.put("location","Reading, UK");

    jobOffer.saveInBackground();
  }
});

如果在您自己的MasteringAndroidApp版本中，您希望用户上传内容，您可以显示一个带有EditText的对话框，让用户编写职位信息，按下上传按钮，然后您将发送带有用户编写字段的jobOffer对象。

运行应用程序，导航到联系人，并点击按钮。如果数据正确上传，在浏览器中打开 Parse 云数据库时，你应该能看到刚刚上传的职位信息额外的一行。

提示

记得在AndroidManifest.xml中添加权限，android.permission.ACCESS_NETWORK_STATE和android.permission.INTERNET。

消费内容

Parse 云中的对象默认有一个对象标识符，即objectId字段。让我们通过 ID 开始检索对象，之后，我们可以检索带有和没有过滤器的所有对象列表。运行以下代码：

ParseQuery<ParseObject> query = ParseQuery.getQuery("JobOffer");
query.getInBackground("yourObjectID", new GetCallback<ParseObject>() {
  public void done(ParseObject object, ParseException e) {
    if (e == null) {
      // object will be our job offer
    } else {
      // something went wrong
    }
  }
});

当网络请求完成时，ParseQuery对象会在网络上异步执行查询。回调中包含的方法done (the ParseObject object, ParseException e)将被执行。

检验结果的一个好方法是打印日志；在异常为null的情况下，意味着一切正常。

if (e == null) {
  Log.d("PARSE_TEST",object.getString("Title"));
} else {
  // something went wrong
}

我们可以从ParseObject中提取每个字段，并在我们的应用程序中创建一个JobOffer类，其构造函数的参数与对象的字段相匹配。使用以下代码片段：

JobOffer myJobOffer = new JobOffer(object.getString("title), object.getString("description"), … );

然而，有一种更好的方法可以实现这一点。我们可以创建一个扩展了ParseObject的JobOffer类，这样所有的字段都会自动转换成我们类中的变量。这样，我们就可以非常方便地使用自己的类，而不是ParseObject：

public void done(JobOffer jobOffer, ParseException e) 

不要忘记在类顶部添加@ParseClassName("Name")注解，以让 Parse 知道我们要实例化云中的哪个对象，并在MAApplication中初始化解析之前注册子类：

public class MAApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();

        // Enable Local Datastore.
        Parse.enableLocalDatastore(this);

        ParseObject.registerSubclass(JobOffer.class);

        Parse.initialize(this, "KEY", "KEY");
    }

}

@ParseClassName("JobOffer")
public class JobOffer extends ParseObject {

    public JobOffer() {
        // A default constructor is required.
    }

    public String getTitle() {
        return getString("title");
    }

    public void setTitle(String title) {
        put("title", title);
    }

    public String getDescription() {
        return getString("description");
    }

    public void setDescription(String description) {
        put("description", description);
    }

    public String getType() {
        return getString("type");
    }

    public void setType(String type) {
        put("type", type);
    }
    //Continue with all the fields..

}

现在我们已经创建了自己的自定义类，获取所有职位列表就更加容易了。如果我们愿意，可以用一个参数来过滤它。例如，我可以用以下查询检索所有永久职位：

ParseQuery< JobOffer > query = ParseQuery.getQuery("JobOffer");
query.whereEqualTo("type", "Permanent");
query.findInBackground(new FindCallback<JobOffer>() {
    public void done(List<JobOffer> jobsList, ParseException e) {
        if (e == null) {
            Log.d("score", "Retrieved " + jobsList.size() + " jobs");
        } else {
            Log.d("score", "Error: " + e.getMessage());
        }
    }
});

显示内容

一旦检索到对象列表，就可以创建ListView和一个接收对象作为参数的Adapter。为了结束对 Parse 的使用，我们将使用另一个功能，它允许我们直接从查询结果创建适配器；这样，我们就不必自己创建一个Adapter类了。

在这两种情况下，我们需要创建ListView和列表行的视图。现在，只需显示标题和描述的第一行即可。我们将在第七章《图像处理和内存管理》中自定义此视图并添加一个图片。按照以下方式创建一个row_job_offer.xml布局：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="10dp">

    <TextView
        android:id="@+id/rowJobOfferTitle"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Title"
        android:textColor="#555"
        android:textSize="18sp"
        />

    <TextView
        android:id="@+id/rowJobOfferDesc"
        android:layout_marginTop="5dp"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Description"
        android:textColor="#999"
        android:textSize="16sp"
        android:maxLines="1"
        android:ellipsize="marquee"
        />

</LinearLayout>

现在我们准备创建ParseQueryAdapter并自定义getItemView()方法。这个适配器的一个巨大优势是我们不需要通过查询下载数据，因为它是自动完成的；基本上，我们可以从云中创建一个适配器来显示项目列表。从未如此简单！

要覆盖类中的方法——在这种情况下，我们想要覆盖getItemView——我们可以创建一个子类，一个扩展ParseQueryAdapter的MyQueryAdapter类，并在该子类中覆盖方法。这是一个很好的解决方案，特别是如果我们想在应用程序中多次实例化对象。

然而，有一种方法可以在不扩展类的情况下覆盖方法；我们可以在对象实例化后添加{ }。例如，参考以下代码：

Object object = new Object() {

 //Override methods here

 }

使用这种方法，我可以创建一个新的ParseQueryAdapter并自定义getItemView，如下面的代码所示：

ParseQueryAdapter<JobOffer> parseQueryAdapter = new ParseQueryAdapter<JobOffer>(getActivity(),"JobOffer") {

  @Override
  public View getItemView(JobOffer jobOffer, View v, ViewGroup parent) {

    if (v == null) {
      v = View.inflate(getContext(), R.layout.row_job_offer, null);
    }

    super.getItemView(jobOffer, v, parent);

    TextView titleTextView = (TextView) v.findViewById(R.id.rowJobOfferTitle);
    titleTextView.setText(jobOffer.getTitle());
    TextView descTextView = (TextView) v.findViewById(R.id.rowJobOfferDesc);
    descTextView.setText(jobOffer.getDescription());

    return v;
  }

};

我们现在将在ListFragment的布局中创建ListView，在OnCreateView中找到这个视图，将适配器设置到列表中，这样就完成了。不再需要代码来检索项目并显示它们。如果您的列表为空，请确保在MyPagerAdapter中导入com.packtpub.masteringandroidapp.fragments.ListFragment;而不是android.support.v4.app.ListFragment；它们是不同的对象，使用后者将导致显示一个空的内置ListFragment。

谷歌 Volley 和 OkHttp

要掌握 Android，我们不能依赖像 Parse 这样的解决方案。作为开发者，我们必须准备面对不同的服务器端解决方案。我们不能总是使用ParseObjects，因为我们需要能够进行 HTTP Post请求并消费 JSON 或 XML 格式的数据。然而，这并不意味着我们必须手动完成所有这些工作；我们可以使用谷歌的官方库来帮助我们解析数据和网络请求。

为此，我们将研究Google Volley，这是一个强大的库，用于管理我们的网络请求。我们还将讨论OkHttp，这是一个超快的 HTTP 客户端，并将两者结合以获得网络请求的惊人解决方案。

Google Volley

根据官方定义和功能列表来自developer.android.com/training/volley/index.html的说明，"Volley 是一个 HTTP 库，它使得 Android 应用的网络通信变得更加简单，最重要的是，更快”。

Volley 提供以下好处：

• 网络请求的自动调度

• 多个并发网络连接

• 透明的磁盘和内存响应缓存，具有标准的 HTTP 缓存一致性

• 支持请求优先级

• 请求 API 的取消；这意味着您可以取消单个请求，或设置要取消的请求块或作用域

• 易于定制；例如，用于重试和退避

• 强大的排序功能，这使得可以轻松地用从网络异步获取的数据正确填充 UI

• 调试和跟踪工具

在 Volley 诞生之前，在 Android 中管理网络请求是一项艰巨的任务。几乎每个应用程序都会执行网络请求。诸如定制重试（如果连接失败，我们需要再次尝试）以及管理并发网络连接等功能通常需要开发者手动实现。如今，我们习惯于这类库，但如果我们回想几年前的情景，Volley 是解决这一问题的绝佳方案。

在了解如何创建请求之前，我们需要理解 Volley 请求队列对象RequestQueue的概念。Volley 执行的每个请求都必须添加到此队列中，以便执行。这个想法是让我们的应用程序中有一个单一的请求队列，所有的网络请求都可以添加到其中，并且可以从应用程序的任何部分访问。我们将在第四章，并发与软件设计模式中看到如何拥有一个可以全局访问的对象实例。请看以下请求：

// Instantiate the RequestQueue.
RequestQueue queue = Volley.newRequestQueue(this);

如果设备的 Android 版本晚于 Gingerbread，此请求队列将只使用以下HttpURLConnection或AndroidHttpClient方法；在 Gingerbread 之前的版本中，HttpURLConnection是不可靠的。

// If the device is running a version >= Gingerbread...
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
    // ...use HttpURLConnection for stack.
} else {
    // ...use AndroidHttpClient for stack.
}

当实例化请求队列时，我们只需向其中添加一个请求。例如，一个网络请求www.google.com，它会记录响应：

String url ="https://www.google.com";

// Request a string response from the provided URL.
StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
            new Response.Listener<String>() {
    @Override
    public void onResponse(String response) {
        // Display the first 500 characters of the response string.
        Log.d("Volley","Response is: "+ response.substring(0,500));
    }
}, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        Log.d("Volley","That didn't work!");
    }
});

// Add the request to the RequestQueue.
queue.add(stringRequest);

请求将被执行，并且在应用程序主线程（也称为 UI 线程）中调用onResponse(…)或onErrorResponse(…)方法。我们将在第四章，并发与软件设计模式中更详细地解释 Android 中的线程。

OkHttp

OkHttp 是来自 Square 公司的 Android 和 Java 的 HTTP 和 SPDY 客户端。它不是 Volley 的替代品，因为它不包括请求队列。实际上，我们可以像下一节将看到的那样，使用 OkHttp 作为 Volley 的底层。

根据官方定义，"HTTP 是现代应用程序联网的方式。它是我们交换数据和媒体的方法。高效地使用 HTTP 可以使你的东西加载更快，节省带宽"。

如果我们不需要处理队列中的请求，优先处理请求或计划请求，我们可以直接在应用程序中使用 OkHttp；我们不一定需要 Volley。

例如，以下方法打印给定 URL 响应的内容：

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {

  Request request = new Request.Builder()
      .url(url)
      .build();

  Response response = client.newCall(request).execute();
  return response.body().string();

}

除了比使用AsyncTask或HttpUrlConnection进行请求更简单之外，让我们决定使用 OkHttp 的是 SPDY（快速）协议，它处理、标记化、简化和压缩 HTTP 请求。

极速网络

如果我们想保持 Volley 的特性，以便拥有灵活可管理的请求队列，并使用 SPDY 协议实现更快连接，我们可以将 Volley 和 OkHttp 结合起来使用。

这真的很简单；在实例化请求队列时，我们可以指定我们想要的HttpStack方法：

RequestQueue queue = Volley.newRequestQueue(this, new OkHttpStack());

在这里，OkHttpStack是一个我们自己通过扩展HurlStack创建的类，它将使用OkUrlFactory。这个OkUrlFactory将打开一个 URL 连接；这将在内部完成，无需重写createConnection方法：

/**
 * An HttpStack subclass
 * using OkHttp as transport layer.
 */
public class OkHttpStack extends HurlStack {

    private final OkUrlFactory mFactory;

    public OkHttpStack() {
        this(new OkHttpClient());
    }

    public OkHttpStack(OkHttpClient client) {
        if (client == null) {
            throw new NullPointerException("Null client.");
        }
        mFactory = new OkUrlFactory(client);
    }
}

JSON 和 Gson

作为一名 Android 开发者，迟早你将不得不处理 JSON 格式的网络请求。在某些情况下，你也可能会遇到 XML，这使得将其转换为对象更加繁琐。了解如何通过发送 JSON 格式的参数执行网络请求以及如何消费 JSON 格式的数据是非常重要的。

JSON 和 GSON 是两个不同的概念；我们需要了解它们之间的区别。JSON，即 JavaScript 对象表示法，是一种开放标准格式，它使用人类可读的文本来传输由属性-值对组成的数据对象。它主要用于在服务器和 Web 应用程序之间传输数据，作为 XML 的替代方案。下面是一个 JSON 文件的例子；如你所见，我们可以有不同的属性类型，我们还可以有嵌套的 JSON 结构：

{
  "firstName": "Antonio",
  "lastName": "Smith",
  "isDeveloper": true,
  "age": 25,
  "phoneNumbers": [
    {
      "type": "home",
      "number": "212 555-1234"
    },
    {
      "type": "office",
      "number": "646 555-4567"
    }
  ],
  "children": [],
  "spouse": null
}

下面是两个使用 JSON 格式发送带参数的网络请求的例子。这些例子涵盖了本章前面讨论过的 Volley 和 OkHttp：

//With Volley

public void post(String param1, String param2, String url) {

  Map<String, String> params = new HashMap<String, String>();
  params.put("param1",param1);
  params.put("param2",param2);

  JsonObjectRequest stringRequest = new  JsonObjectRequest(Request.Method.POST, url, new JSONObject(params),  new Response.Listener<JSONObject>() {

    @Override
    public void onResponse(JSONObject responseJSON) {

    }, new Response.ErrorListener() {

      @Override
      public void onErrorResponse(VolleyError error) {
      }
    });

    // Add the request to the RequestQueue.
    requestQueue.add(stringRequest);
  }

  //With OkHttp

  public static final MediaType JSON
  = MediaType.parse("application/json; charset=utf-8");

  String post(String url, String json) throws IOException {
    RequestBody body = RequestBody.create(JSON, json);
    Request request = new Request.Builder()
    .url(url)
    .post(body)
    .build();
    Response response = client.newCall(request).execute();
    return response.body().string();

  }

  //To create a JSONObject from a string

  JSONObject responseJSON = new JSONObject(String json);

Gson（Google Gson）是一个开源的 Java 库，用于将 Java 对象序列化和反序列化为（或从）JSON。

如果我们从自定义服务器以 JSON 格式为我们的应用程序下载工作邀请，格式将如下所示：

{
  "title": "Senior Android developer",
  "description": "A developer is needed for…",
  "salary": "25.000 € per year",
  .
  .
  .
}

同样，我们不想手动创建一个新对象并从 JSON 中获取所有参数来设置；我们想要做的是从 JSON 创建一个JobOffer对象。这称为反序列化。

要使用这个功能，我们需要在build.gradle中导入 GSON 库作为依赖：

dependencies {
compile 'com.google.code.gson:gson:2.2.4'
}

Gson 提供了fromJSON和toJSON方法来进行序列化和反序列化操作。fromJson方法接收要转换的 JSON 代码以及我们希望转换成的对象类作为输入。使用以下代码：

Gson gson = new Gson();
JobOffer offer = gson.fromJson(JSONString, JobOffer.class);

如果我们有一个列表而不是单个对象，这在请求数据时是典型场景，我们需要额外的步骤来获取类型：

Gson gson = new Gson();
Type listType = new TypeToken<List<JobOffer>>(){}.getType();
List<JobOffer> listOffers = gson.fromJson(JSONString, listType);

最后，如果我们希望类中的字段在反序列化时与 JSON 代码中的字段名称不同，可以使用如下注解：

import com.google.gson.annotations.SerializedName;

public class JobOffer extends ParseObject {

    @SerializedName("title")
    private String title;

    @SerializedName("description")
    private String desc;

    @SerializedName("salary")
    private String salary;

总结

在本章结束时，你应该能够自己在 Parse 中创建数据库并从应用程序中消费内容。你也应该拥有使用 Volley 和 OkHttp 进行网络请求的所有必要知识，特别是在执行网络请求和以 JSON 格式交换数据时。

在下一章中，我们将更详细地解释本章中使用的 HTTP 库的一些模式。例如，我们将了解回调是什么以及它遵循的模式，以及在 Android 中其他常用的软件模式。

第四章：并发与软件设计模式

作为开发者，你不仅要编写能工作的代码，而且要尽可能使用现有的解决方案，以便将来能更好地维护你的代码。如果其他开发者需要在你项目中工作，他们会很快理解你的做法。我们能够实现这一点，要归功于软件设计模式。

为了正确理解这些模式，我们需要了解 Android 中并发是如何工作的基本概述。我们将阐明 UI 线程是什么，并讨论在线程中延迟事件的不同机制。

我们将介绍 Android 中最常用的模式，这将帮助我们进一步理解 Android 功能和开发技术，并成为更好的开发者。

• 并发

  • 处理器和线程

  • AsyncTask

  • Service

  • IntentService

  • Loader

• Android 中的模式

  • 单例模式

  • 适配器和持有者模式

  • 观察者模式

Android 中的并发

如果你是一个 Android 用户，你可能对 ANR 消息有所了解。这可能不会让你立刻明白，所以请看以下图片：

当 UI 或主线程中的代码运行时间超过 5 秒，阻塞用户交互时，就会发生应用无响应（ANR）。

在 Android 中，一个应用程序运行一个单一的线程，称为用户界面线程。我们将解释线程是什么，即使是没有编程背景的读者也能理解。我们可以将线程视为由 CPU 执行的指令或消息列。这些指令来自不同的地方；它们来自我们的应用程序以及操作系统。这个线程用于处理用户的响应、生命周期方法和系统回调。

CPU 逐个顺序处理消息；如果它很忙，消息将在队列中等待执行。因此，如果我们在应用程序中执行长时间的操作并向 CPU 发送许多消息，我们将不会让 UI 消息得到执行，这将导致用户感觉到手机无响应。

这个问题的解决方案似乎很明显：如果一个线程不够用，我们可以使用多个。例如，如果我们发起一个网络请求，这个请求将在另一个线程中完成，并且当它结束时，会与主线程通信以显示所请求的数据。

只有主线程或 UI 线程可以访问 UI；因此，如果我们再另一个线程中进行任何后台计算，我们必须告诉主线程显示这些计算的结果，因为我们不能直接从那里做。

处理器和线程

我们之前描述的消息在一个称为MessageQueue的队列中运行，这个队列对于每个线程是唯一的。处理器可以发送消息到这个队列。当我们创建一个处理器时，它与创建它的线程的MessageQueue相关联。

处理器用于两种情况：

• 向同一线程发送延迟消息

• 向另一个线程发送消息

这就是为什么在我们的SplashActivity中，我们将使用以下代码：

new Handler().postDelayed(new Runnable() {
  @Override
  public void run() {

    Intent intent = new Intent(SplashActivity.this, MainActivity.class)

    startActivity(intent);
  }
},3000);

提示

当你创建一个新的Handler()方法时，确保导入Android.OS处理器。

在这里，我们使用了postDelayed(Runnable, time)方法来发送一个延迟的消息。在这种情况下，消息是一个可运行对象，代表可以执行的命令。

当runOnUIThread()活动内部有一个方法允许我们向 UI 线程发送可运行对象时，你就不需要创建一个处理器来与它通信。当我们有活动的上下文并且想在 UI 上运行某些内容时，这非常有用，例如从在后台执行的任务中向 UI 发布更新。

如果我们查看 Android 中该方法的源代码，可以看到它只是简单地使用处理器在 UI 线程中发布可运行对象：

public final void runOnUiThread(Runnable action) {
  if (Thread.currentThread() != mUiThread) {
    mHandler.post(action);
  } else {
    action.run();
  }
}

通常，当我们想要在后台执行一个长时间的任务并希望管理并行线程的执行时，会手动创建线程。线程有一个run()方法，其中包含要执行的指令，并且必须在创建后启动以执行run()：

Thread thread = new Thread(){

  @Override
  public void run() {
    super.run();
  }
};

thread.start();

创建线程和处理器以执行后台任务的缺点是它的手动处理，如果我们有多个任务，很容易导致应用程序的可读性变得极差。Android 还有其他机制来执行任务，如AsyncTask。

介绍 AsyncTasks

这可能是你在初学阶段就已经了解的内容，但我们将从并发性的角度来审视它。Asynctask是基于线程和处理器的一个类，旨在提供一种在后台执行任务并更新 UI 的简便方法。

要使用AsyncTask，需要对其进行子类化，它有四个可以被重写的方法：onPreExecute、doInBackground、onProgressUpdate和onPostExecute。

OnPreExecute方法是在后台执行任何工作之前被调用的；这意味着它仍然在 UI 线程中，用于在开始任务前初始化变量和进度。

doInBackground方法在后台线程中执行。在这里，你可以调用onProgressUpdate，它向 UI 线程发布一个更新，例如，通过增加ProgressBar的值来显示任务的进度。

最后一个方法onPostExecute是在后台任务完成且在 UI 线程中运行时被调用的。

以一个例子来说明：一个AsyncTask在后台需要x秒完成，并且每秒更新一次进度。进度条对象作为参数在构造函数中传递，秒数作为参数在execute方法中传递，并在doInBackground中获取。请注意，在以下代码中，<Integer,Integer,Void>类型分别指的是输入参数、进度更新和后执行的类型：

public class MyAsyncTask extends AsyncTask<Integer,Integer,Void> {

  ProgressBar pB;

  MyAsyncTask(ProgressBar pB) {
    this.pB = pB;
  }

  @Override
  protected void onPreExecute() {
    super.onPreExecute();
    pB.setProgress(0);
  }

  @Override
  protected void onProgressUpdate(Integer... values) {
    super.onProgressUpdate(values);
    pB.setProgress(values[0]);
  }

  @Override
  protected Void doInBackground(Integer... integers) {
    for (int i = 0; i < 10; i++){
      try {
        Thread.sleep(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      onProgressUpdate(new Integer[]{i});
    }
    return null;
  }

  @Override
  protected void onPostExecute(Void o) {
    super.onPostExecute(o);
    Log.d("AsyncTask","Completed");
  }

}

创建了AsyncTask类后，以下是执行它的方法：

new MyAsyncTask( progressBar ).execute(new Integer[]{10});

如果我们同时执行多个 AsyncTask，从 Android 3.0 版本开始，默认情况下它们将会按顺序依次运行。如果我们希望它们并行运行，我们需要创建一个执行器，并通过 THREAD_POOL_EXECUTOR 参数调用 executeOnExecutor()。

至于限制，我们应该提到 AsyncTask 必须始终从主线程执行，并且不能在同一个对象中两次调用 execute()；因此，它们不能循环执行。

理解服务

当下载文件或执行任何需要任务完成时通知 UI 的短操作时，AsyncTask 是理想的。然而，在 Android 中，有时需要执行非常长时间的任务，这些任务可能不需要 UI 交互。例如，你可以有一个应用，它与服务器打开一个套接字（直接通道），用于收听广播应用中的音频流。

即使应用不在屏幕上显示，服务也会运行；它默认在后台运行，但使用主线程。因此，如果我们想要执行长时间的任务，我们需要在服务内创建一个线程。它必须在清单中声明，如果我们将其声明为公开，也可以从另一个应用中使用。

与 AsyncTask 相比，服务可以从任何线程触发；它们通过 onStartService() 方法触发，并通过 onStopService() 停止。

可选地，服务可以绑定到一个组件；一旦绑定组件，就会调用 onBind()。当绑定发生时，我们有一个接口供组件与服务交互。

一种服务类型 —— IntentService

IntentService 是 services 的一个子类，可以从一个意图触发。它创建一个线程并包含回调，以了解任务何时完成。

IntentService 的背后的想法是，如果你不需要并行运行任务，实现一个按顺序接收意图并完成任务后通知的服务更容易。

当我们调用 onStart 时，服务会持续运行；然而，IntentService 被创建后，只会在接收到意图并完成任务时，在短时间内运行。

以一个实际例子来说，我们可以考虑一个应用在屏幕不在显示时，在后台执行短任务的需求。比如一个新闻阅读应用，将新闻存储在您的设备上，以便您在没有网络的情况下也能离线阅读。这可能是来自一个每天发布文章的报纸的应用，允许用户在没有网络连接的情况下，如在飞机上或火车通勤时阅读文章。

这个想法是，当文章发布时，应用在后台运行时用户会收到推送通知。这个通知将触发一个下载文章的意图，这样用户下次打开应用时，无需任何额外操作，文章就已经在那里了。

下载文章是一个小而重复的任务，需要在应用在后台、在线程中运行时完成，无需并行处理，这正是IntentService的理想场景。

介绍加载器

为了结束并发部分，我们将快速概览Loader类。加载器的目的是更容易在活动中异步加载数据，因此在片段中也是如此。从 Android 3.0 开始，每个活动都有LoaderManager来管理在其中使用的加载器。在基于片段导航的应用程序中，即使在你切换片段时，也可以在活动级别执行后台操作。

加载器从数据源加载数据；当这个数据源发生变化时，它会自动刷新信息，这就是为什么加载器与数据库一起使用是完美的。例如，一旦我们将加载器连接到数据库，这个数据库就可以被修改，而加载器将捕获这些更改。这将允许我们立即刷新 UI，让用户看到这些变化。

在第八章《数据库 *和加载器》中，我们将实现CursorLoader来查询我们在MasteringAndroidApp中创建的数据库。

模式的重要性

当软件开发者需要开发具有特定功能特性的功能或组件时，通常可以用不同的方法完成；可以用不同的代码或不同的结构来完成。很可能同样的问题已经被其他开发者解决了无数次，以至于解决方案从具体实现中抽象出来，变成了一个模式。与其重新发明轮子，不如了解并实现这些模式。

在 Android 开发中，我们每天都在使用模式，即使我们没有意识到。大多数时候，我们使用的是 Android 内置的模式实现。例如，当我们想要执行按钮点击并设置OnClickListener时——换句话说，等待onClick()方法被调用——我们使用的是观察者模式的实现。如果我们创建一个弹出窗口AlertDialog，我们使用的是AlertDialog.Builder，它使用了构建器模式。这样的例子有很多，但我们希望的是能够将这些解决方案应用到我们自己的问题中。

有不同类型的模式分为四类，以下是在开发 Android 应用时我们可能会遇到的一些例子：

• 创建型

  • 单例模式

  • 构建器模式

  • 工厂方法模式

• 行为型

  • 观察者模式

  • 策略模式

  • 迭代器模式

• 结构型

  • 适配器模式

  • 门面模式

  • 装饰器模式

• 并发

  • 锁

  • 调度器

  • 读写锁

为了完成MasteringAndroidApp，我们需要实现前三组中的模式。关于第四组（并发），我们需要了解 Android 中的并发概念，但我们不会自己实现一个并发模式。

小贴士

模式通常由 UML 图表示。

根据维基百科（en.wikipedia.org/wiki/Class_diagram），“在软件工程中，统一建模语言（UML）中的类图是一种静态结构图，通过显示系统的类，它们的属性，操作（或方法）以及对象之间的关系来描述系统的结构”。

单例模式

软件设计模式中的单例模式（Singleton）限制了对象的创建，只允许有一个实例。其思想是全局访问这个单一对象。

该模式的实现是，如果之前没有创建对象，则创建对象，如果已创建，则返回现有实例。以下是 UML 图：

在某些情况下，我们希望一个对象能够全局访问，并且希望它在我们的应用中是唯一的。例如，在使用 Volley 时，我们希望保持一个唯一的请求队列，以使所有请求都在同一个队列中，并且我们希望它能够全局访问，因为我们需要从任何片段或活动中添加请求。

这是一个单例实现的基本示例：

public class MySingleton {

    private static MySingleton sInstance;

    public static MySingleton getInstance(){
        if (sInstance == null) {
            sInstance = new MySingleton();
        }
        return sInstance;
    }
}

为了理解实现，请记住在 Java 中，静态变量与类相关联，而不是与对象相关。同样，静态方法可以在不创建类实例的情况下调用。

拥有一个静态方法意味着它可以在我们应用的任何地方被调用。我们可以调用MySingleton.getInstance()，它总是返回同一个实例。第一次调用时，它会创建并返回它；之后的调用，它会返回已创建的实例。

使用单例和测试框架有一个缺点；我们将在第十一章，安卓上的调试与测试中讨论这个问题。

应用类中的单例

我们可以将单例实现适配到 Android。考虑到在Application类中的onCreate方法在我们打开应用时只被调用一次，且Application对象不会被销毁，我们可以在应用中实现getInstance()方法。

应用这些更改后，我们的应用类将类似于以下结构：

public class MAApplication extends Application {

  private static MAApplication sInstance;

  @Override
  public void onCreate() {
    super.onCreate();

    sInstance = this;

    // Enable Local Datastore.
    Parse.enableLocalDatastore(this);

    ParseObject.registerSubclass(JobOffer.class);

    Parse.initialize(this, "KEy", "KEY");
  }

  private static MAApplication getInstance(){
    return sInstance;
  }
}

现在，我可以在应用的任何地方调用MAAplication.getInstance()，并在应用类中创建可以通过单例MAAplication对象全局访问的成员变量。例如，在 Volley 的情况下，我可以在OnCreate()中创建RequestQueue，然后随时从MAAplication对象中获取它。执行以下代码：

private RequestQueue mRequestQueue;

@Override
public void onCreate() {
  super.onCreate();

  sIntasnce = this;

  mRequestQueue = Volley.newRequestQueue(this);
  .
  .
  .
}

public RequestQueue getRequestQueue(){
  return mRequestQueue;
}

采用这种方法，我们有一个单例，即我们的Application类；其余的全局可访问对象都是成员变量。另一个选项是创建一个新的单例类来存储 Volley 请求队列，并为每个需要全局访问的对象创建一个新的请求单例。

提示

不要在Application类中使用此方法来持久化数据。例如，如果我们通过点击主页按钮进入后台，经过一段时间后，Android 可能需要内存，并会杀死该应用。因此，下次打开应用时，即使看起来像是返回到上一个实例，实际上会创建一个新的实例。如果你在onCreate中重新初始化所有变量，并且后来不改变它们的状态，这样做是没问题的。为了避免这个问题，请避免使用 setter 方法。

观察者模式

这种模式在 Android 中被广泛使用。我们讨论的大多数网络库都实现了这种模式，如果你是 Android 开发者，你肯定已经多次使用过它——我们需要实现它，甚至是为了检测按钮的点击。

观察者模式基于一个对象，即观察者，它注册其他对象来通知它们状态变化；在这里，监听状态变化的对象是观察者。这种模式可以用来创建一个发布/订阅系统：

以下是一个注册多个观察者的模式的实现：

public class MyObserved {

  public interface ObserverInterface{
    public void notifyListener();
  }

  List<ObserverInterface> observersList;

  public MyObserved(){
    observersList = new ArrayList<ObserverInterface>();
  }

  public void addObserver(ObserverInterface observer){
    observersList.add(observer);
  }

  public void removeObserver(ObserverInterface observer){
    observersList.remove(observer);
  }

  public void notifyAllObservers(){
    for (ObserverInterface observer : observersList){
      observer.notify();
    }
  }
}

public class MyObserver
implements MyObserved.ObserverInterface {

  @Override
  public void notify(){
    //Do something
  }
}

你会注意到，观察者可以是任何实现接口——ObserverInterface的对象。这个接口在观察对象中定义。

如果我们将这个与在 Android 中处理按钮点击的方式进行比较，我们会执行myButton.setOnClickListener(observer)。在这里，我们添加了一个等待点击的观察者；这个观察者实现了OnClick()方法，这是我们案例中通知的方法。

在 Volley 中，当我们创建一个网络请求时，我们必须指定两个作为参数的监听器：Response.Listener和Response.ErrorListener。它们分别调用onResponse()和onErrorResponse()。这是观察者模式的一个清晰实现。

我们将在第六章 CardView 和材料设计中实现观察者模式的一个变体，即发布/订阅模式的一个示例。

介绍适配器模式

适配器是在创建ListView或ViewPager时在 Android 中使用的元素，但它也是一个著名的设计模式。我们将看看两者的定义及其关系。

一方面，适配器作为设计模式，是介于两个不兼容接口之间的桥梁。它允许两个不同的接口一起工作。这就像现实世界中的适配器，比如 SD 卡到 micro SD 卡的适配器，它允许两个不兼容的系统协同工作。如图所示，适配器被调用新的所需方法，但在内部，它调用来自被适配者的旧方法。

另一方面，来自android.widget.Adapter的适配器是一个对象，我们用它为列表的每一行或视图翻页的每一页创建视图。因此，它适配了一组数据和一组视图。

要实现一个适配器，我们必须扩展BaseAdapter并重写getView()和getCount()方法。通过这两个方法，适配器将知道它必须创建多少个视图以及如何创建这些视图。

我们将在下一章更深入地探讨这个主题，同时会涉及到ListViews的使用，并讨论ViewHolder模式，这是在 Android 中处理适配器和列表时经常使用的一种特定模式。

总结

在本章结束时，你应该能够理解 Android 中的并发性以及与之相关的所有不同机制。你应该知道有一个主线程用于更新 UI，我们可以创建后台线程来执行其他任务。你还必须了解应用程序在后台（换句话说，不在屏幕上）执行任务与在后台线程中执行任务的区别。你也应该知道软件设计模式的重要性，并能够实现其中的一些。

在下一章中，我们将看看如何使用列表视图，我们将实现一个适配器，并发现一种新模式ViewHolder，它将是理解在 Android Lollipop 中引入的ListView和RecyclerView之间区别的关键。

第五章：列表和网格

在本章中，我们将处理列表和网格。几乎在市场上的每个应用中都可以找到列表或元素矩阵。了解如何在 Android 上显示元素列表是你在基础层面要学习的东西；然而，还有很多可以扩展和了解的内容。

了解我们可以在这里使用哪些模式很重要，如何回收视图，以及如何在同一个列表中用不同的视图显示不同类型的元素。

有了这个想法，我们将能够理解为什么RecyclerView是ListView的继任者，并且我们将学习如何使用这个组件实现列表。因此，在本章中我们将介绍以下内容：

• 从列表开始

  • ListView

  • 自定义适配器

  • 视图回收

  • 使用 ViewHolder 模式

• 介绍 RecyclerView

  • 列表、网格或堆叠

  • 实现

• OnItemClick

从列表开始

如果你听说过RecyclerView，你可能会想知道为什么我们要学习ListView。RecyclerView小部件是新的，它随着 Android Lollipop 一起出现，在显示项目列表时是一场革命；它可以垂直和水平显示，作为列表或网格，以及具有其他改进的精美动画。

尽管在某些场景下RecyclerView可能更高效、更灵活，但它需要额外的编码来实现相同的结果，因此仍然有使用ListView的理由。例如，RecyclerView中没有用于条目选择的onItemClickListener()，而且我们在点击条目时也没有视觉反馈。如果我们不需要定制和动画，例如对于一个简单的数据选择弹窗，这可能是一个只需选择一个国家的对话框。在这种情况下，使用ListView而不是RecyclerView是完全没问题的。

另一个从ListView开始的原因是RecyclerView解决了大多数在使用ListViews时遇到的问题。因此，通过从ListView开始并解决这些问题，我们将完全理解RecyclerView是如何工作的以及为什么这样实现。因此，我们将分别解释用于全局理解组件的模式。

下面是一个基本的AlertDialog示例，其目的是为了选择一个条目；在这种情况下，使用ListView是很有意义的：

使用内置视图的 ListViews

当你第一次实现ListView时，可能会觉得微不足道且简单；然而，当你花更多时间在 Android 上时，你会意识到它可能变得多么复杂。如果你有一个带有每行图片的大型元素列表，你很容易就能找到性能和内存问题。如果你尝试实现复杂的 UI，例如让同一个列表显示不同的条目，创建具有不同视图的不同行，或者甚至尝试在显示部分标题时组合某些条目，可能会很头疼。

让我们从实现列表的最简方式开始，使用前面讨论过的简单列表中使用的 Android 内置项目布局。为了显示列表，我们将它包含在AlertDialog中，当我们点击设置片段中的按钮时，会显示这个对话框。我会将按钮的文本设置为Lists Example。

第一步是在settings_fragment.xml中创建按钮；创建后，我们可以为按钮设置点击监听器。现在，我们对软件模式有了更深入的了解，而不仅仅是以下这种方式设置点击监听器：

view.findViewById(R.id.settingsButtonListExample).setOnClickListener(new View.OnClickListener() {
  @Override
  public void onClick(View view) {
    //Show the dialog here
  }
});

我们将以更有条理的方式来做这件事，特别是因为我们知道在设置屏幕上，将会有很多按钮，我们希望在同一地方处理所有点击事件。我们不会在方法调用内部创建onClickListener，而是通过将onClickListener设置为this，使Fragment实现OnClikListener。这里的this关键字指的是整个片段，因此片段将在onClick方法中监听点击，一旦Fragment实现了View.OnClickListener，这个方法是必须实现的。

OnClick()方法接收一个视图，即被点击的视图。如果我们将该视图的 ID 与按钮的 ID 进行比较，我们就会知道是按钮还是设置了clickListener的其他视图被点击了。

在定义类时只需键入implements View.OnClickListener，你就会被要求实现必填的方法：

/**
* Settings Fragment
*/
public class SettingsFragment extends Fragment implements View.OnClickListener {

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
  Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_settings, container, false);

    view.findViewById(R.id.settingsButtonListExample).setOnClickListener(this);

    view.findViewById(R.id.ViewX).setOnClickListener(this);

    view.findViewById(R.id.imageY).setOnClickListener(this);

    return view;
  }

  @Override
  public void onClick(View view) {
    switch (view.getId()){
      case (R.id.settingsButtonListExample) :
      showDialog();
      break;
      case (R.id.viewX) :
      //Example
      break;
      case (R.id.imageY) :
      //Example
      break;

      //...
    }
  }

  public void showListDialog(){
    //Show Dialog here
  }
}

你会注意到，我们还把显示列表对话框的逻辑移到了外部方法中，这样在onClick();中的结构易于阅读。

继续使用对话框，我们可以显示一个带有setAdapter()属性的AlertDialog，它会自动将内部项与ListView绑定。或者，我们可以为对话框创建一个带有ListView的视图，然后将适配器设置给该ListView：

/**
*  Show a dialog with different options to choose from
*/
public void showListDialog(){

  AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());

  final ArrayAdapter<String> arrayAdapter = new ArrayAdapter<String>(
  getActivity(),
  android.R.layout.select_dialog_singlechoice);
  arrayAdapter.add("Option 0");
  arrayAdapter.add("Option 1");
  arrayAdapter.add("Option 2");

  builder.setTitle("Choose an option");

  builder.setAdapter(arrayAdapter,
  new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialogInterface, int i) {
      Toast.makeText(getActivity(),"Option choosen "+i, Toast.LENGTH_SHORT).show();
      dialogInterface.dismiss();
    }
  });

  builder.show();
}

这个对话框将显示一条消息，指示点击的选项。我们使用了android.R.layout.select_dialog_singlechoice作为我们行的视图。

这些是列表内置布局的几个不同示例，它们将取决于我们应用程序的主题。例如，在 4.4 KitKat 和 5.0 Lollipop 中，对话框看起来是不同的，在android.R.layout.simple_list_item_1中，它看起来会是这样：

android.R.layout.simple_list_item_2布局有两行，看起来会类似这样：

这是一个android.R.layout.simpleListItemChecked的例子，我们可以将选择模式更改为多选或单选：

这是android.R.layout.activityListItem，我们有一个图标和文本：

在创建布局时，我们可以访问这些内置的布局组件，以便进一步调整视图。这些组件的名称为android.resource.id.Text1、android.resource.id.Text2、android.resource.id.Icon等。

现在，我们知道了如何创建带有功能和视图的列表。是时候创建我们自己的适配器并手动实现功能和视图了。

创建自定义适配器

当你寻找工作时，除了查看职位信息，你还会向不同的软件公司或 IT 招聘公司提交你的简历，他们会为你找到一家公司。

在我们的联系人片段中，我们将创建一个按国家排序的列表，显示这些公司的联系人详细信息。将有两行不同的内容：一行用于国家头部，另一行用于公司详细信息。

我们可以在 Parse 数据库中创建另一个表，名为JobContact，包含以下字段：

我们将从服务器请求工作联系人，并构建一个项目列表，该列表将发送到适配器以构建列表。在列表中，我们将发送两个不同的元素：公司和国家。我们可以生成一个项目列表并将这两个作为对象添加。我们的两个类将类似于以下内容：

@ParseClassName("JobContact")
public class JobContact extends ParseObject {

  public JobContact() {
    // A default constructor is required.
  }

  public String getName() {
    return getString("name");
  }

  public String getDescription() {
    return getString("description");
  }

  public String getCountry() {
    return getString("country");
  }

  public String getEmail() {
    return getString("email");
  }

}

public class Country {

  String countryCode;

  public Country(String countryCode) {
    this.countryCode = countryCode;
  }

}

一旦我们从www.parse.com按国家排序下载了信息，我们就可以通过遍历解析列表并检测到不同国家时添加一个国家头部来构建我们的项目列表。执行以下代码：

public void retrieveJobContacts(){
  ParseQuery<JobContact> query = ParseQuery.getQuery("JobContact");
  query.orderByAscending("country");
  query.findInBackground(new FindCallback<JobContact>() {
    @Override
    public void done(List<JobContact> jobContactsList, ParseException e) {
      mListItems = new ArrayList<Object>();
      String currentCountry = "";
      for (JobContact jobContact: jobContactsList) {
        if (!currentCountry.equals(jobContact.getCountry())){
          currentCountry = jobContact.getCountry();
          mListItems.add(new Country(currentCountry));
        }
        mListItems.add(jobContact);
      }
    }
  });
}

现在我们有了包含头部的列表，我们可以基于这个列表创建Adapter，它将在构造函数中作为参数发送。自定义Adapter的最佳方式是创建一个扩展BaseAdapter的子类。一旦我们这样做，我们将被要求实现以下方法：

public class JobContactsAdapter extends BaseAdapter {
  @Override
  public int getCount() {
    return 0;
  }

  @Override
  public Object getItem(int i) {
    return null;
  }

  @Override
  public long getItemId(int i) {
    return 0;
  }

  @Override
  public View getView(int i, View view, ViewGroup viewGroup) {
    return null;
  }
}

这些方法需要根据我们想要显示的数据来实现；例如，getCount()需要返回列表的大小。我们需要实现一个接收两个参数的构造函数：列表和上下文。上下文将是在getView()方法中膨胀列表所必需的。下面是没有实现getView()的适配器的外观：

public class JobContactsAdapter extends BaseAdapter {

  private List<Object> mItemsList;
  private Context mContext;

  public JobContactsAdapter(List<Object> list, Context context){
    mItemsList = list;
    mContext = context;
  }

  @Override
  public int getCount() {
    return mItemsList.size();
  }

  @Override
  public Object getItem(int i) {
    return mItemsList.get(i);
  }

  @Override
  public long getItemId(int i) {
    //Not needed
    return 0;
  }

  @Override
  public View getView(int i, View view, ViewGroup viewGroup) {
    return null;
  }
}

在我们的案例中，我们可以创建两个不同的视图；因此，除了必须实现的方法外，我们还需要实现两个额外的方法：

@Override
public int getItemViewType(int position) {
  return mItemsList.get(position) instanceof Country ? 0 : 1;
}

@Override
public int getViewTypeCount() {
  return 2;
}

getItemViewType方法将返回0如果元素是国家，或者1如果元素是公司。借助这个方法，我们可以实现getView()。如果是国家，我们膨胀row_job_country.xml，其中包含ImageView和TextView；如果是公司，我们膨胀row_job_contact.xml，其中包含三个文本视图：

@Override
public View getView(int i, View view, ViewGroup viewGroup) {

  View rowView = null;
  switch (getItemViewType(i)){

    case (0) :
    rowView = View.inflate(mContext, R.layout.row_job_country,null);
    Country country = (Country) mItemsList.get(i);
    ((TextView) rowView.findViewById(R.id.rowJobCountryTitle)).setText(country.getName());
    ((ImageView) rowView.findViewById(R.id.rowJobCountryImage)).setImageResource(country.getImageRes(mContext));
    break;

    case (1) :
    rowView = View.inflate(mContext, R.layout.row_job_contact,null);
    JobContact company = (JobContact) mItemsList.get(i);
    ((TextView) rowView.findViewById(R.id.rowJobContactName)).setText(company.getName());
    ((TextView) rowView.findViewById(R.id.rowJobContactEmail)).setText(company.getEmail());
    ((TextView) rowView.findViewById(R.id.rowJobContactDesc)).setText(company.getDescription());
  }

  return rowView;
}

最后，我们可以在contact_fragment.xml中创建ListView，并将适配器设置到这个列表。但是，我们将采取捷径，使用android.support.v4.ListFragment；这是一个已经通过ListView膨胀了视图并包含setListAdapter()方法的片段，该方法将适配器设置到内置的ListView中。从这段代码扩展，我们的ContactFragment类将类似于以下代码：

public class ContactFragment extends android.support.v4.app.ListFragment {

  List<Object> mListItems;

  public ContactFragment() {
    // Required empty public constructor
  }

  @Override
  public void onViewCreated(View view, Bundle bundle) {
    super.onViewCreated(view,bundle);
    retrieveJobContacts();
  }

  public void retrieveJobContacts(){
    ParseQuery<JobContact> query = ParseQuery.getQuery("JobContact");
    query.orderByAscending("country");
    query.findInBackground(new FindCallback<JobContact>() {
      @Override
      public void done(List<JobContact> jobContactsList, ParseException e) {
        mListItems = new ArrayList<Object>();
        String currentCountry = "";
        for (JobContact jobContact: jobContactsList) {
          if (!currentCountry.equals(jobContact.getCountry())){
            currentCountry = jobContact.getCountry();
            mListItems.add(new Country(currentCountry));
          }
          mListItems.add(jobContact);
        }
        setListAdapter(new JobContactsAdapter(mListItems,getActivity()));
      }
    });
  }
}

在视图创建后调用retrieveJobContacts()方法，我们实现了以下结果：

我们显示的旗帜是drawable文件夹中的图片，其名称与国家代码相匹配，drawable/ "country_code" .png。我们可以通过将资源标识符设置为ImageView并在Country类内的以下方法中获取它们来显示它们：

public int getImageRes(Context ctx){
  return ctx.getResources().getIdentifier(countryCode, "drawable", ctx.getPackageName());
}

这是一个基本的ListView版本，包含两种不同类型的行。这个版本仍然远非完美；它的性能不佳，没有回收视图，并且每次创建行时都会查找小部件的 ID。我们将在下一节解释并解决这个问题。

视图回收

在使用ListView时，我们需要牢记行数是一个变量，即使我们尽可能快速地滚动，我们也希望列表能够流畅。幸运的是，Android 在这方面为我们提供了很大帮助。

当我们滚动ListView时，屏幕一侧不再可见的视图会被复用并在另一侧再次显示。这样，Android 节省了视图的膨胀；当它膨胀时，视图必须遍历 xml 节点，实例化每个组件。这种额外的计算可能是流畅列表和卡顿列表之间的区别。

getView()方法接收一个待回收的视图作为参数，如果没有视图可以回收，则接收 null。

为了利用这种视图回收机制，我们需要停止每次都创建新视图，而是复用作为参数传入的视图。我们仍然需要在回收的视图中更改行内文本视图和小部件的值，因为它具有与其先前位置的初始值相对应的内容。在我们的示例中，有一个额外的复杂性；我们不能将国家的视图回收用于公司视图，因此我们只能回收相同视图类型的视图。然而，再次强调，Android 通过内部使用我们实现的getItemViewType方法为我们进行这个检查：

@Override
public View getView(int i, View view, ViewGroup viewGroup) {

  switch (getItemViewType(i)){

    case (0) :
    if (view == null){
      view = View.inflate(mContext, R.layout.row_job_country,null);
    }
    Country country = (Country) mItemsList.get(i);
    ((TextView) view.findViewById(R.id.rowJobCountryTitle)).setText(country.getName());
    ((ImageView) view.findViewById(R.id.rowJobCountryImage)).setImageResource(country.getImageRes(mContext));
    break;

    case (1) :
    if (view == null){
      view = View.inflate(mContext, R.layout.row_job_contact,null);
    }
    JobContact company = (JobContact) mItemsList.get(i);
    ((TextView) view.findViewById(R.id.rowJobContactName)).setText(company.getName());
    ((TextView) view.findViewById(R.id.rowJobContactEmail)).setText(company.getEmail());
    ((TextView) view.findViewById(R.id.rowJobContactDesc)).setText(company.getDescription());
  }

  return view;
}

应用 ViewHolder 模式

请注意，在getView()方法中，每次我们想要将文本设置到TextView时，都会使用findViewById()方法在行视图中搜索这个TextView；即使行被回收，我们仍然需要再次找到TextView以设置新值。

我们可以创建一个名为ViewHolder的类，它通过保存行内小部件搜索的计算来引用小部件。这个ViewHolder类将只包含对小部件的引用，我们可以通过setTag()方法在行与其ViewHolder类之间保持引用。View对象允许我们设置一个对象作为标签并在稍后检索它；我们可以通过指定这个标签的键来添加任意数量的标签：setTag(key)或getTag(key)。如果没有指定键，我们可以保存和检索默认标签。

按照这种模式，在我们第一次创建视图时，我们将创建一个ViewHolder类并将其设置为视图的标签。如果视图已经创建并且我们正在回收利用它，我们只需简单地检索持有者。执行以下代码：

@Override
public View getView(int i, View view, ViewGroup viewGroup) {

  switch (getItemViewType(i)){

    case (0) :
    CountryViewHolder holderC;
    if (view == null){
      view = View.inflate(mContext, R.layout.row_job_country,null);
      holderC = new CountryViewHolder();
      holderC.name = (TextView) view.findViewById(R.id.rowJobCountryTitle);
      holderC.flag = (ImageView) view.findViewById(R.id.rowJobCountryImage);
      view.setTag(view);
    } else {
      holderC = (CountryViewHolder) view.getTag();
    }
    Country country = (Country) mItemsList.get(i);
    holderC.name.setText(country.getName());
    holderC.flag.setImageResource(country.getImageRes(mContext));
    break;
    case (1) :
    CompanyViewHolder holder;
    if (view == null){
      view = View.inflate(mContext, R.layout.row_job_contact,null);
      holder = new CompanyViewHolder();
      holder.name = (TextView) view.findViewById(R.id.rowJobContactName);
      holder.email = (TextView) view.findViewById(R.id.rowJobContactEmail);
      holder.desc = (TextView) view.findViewById(R.id.rowJobOfferDesc);
      view.setTag(holder);
    } else {
      holder = (CompanyViewHolder) view.getTag();
    }
    JobContact company = (JobContact) mItemsList.get(i);
    holder.name.setText(company.getName());
    holder.email.setText(company.getEmail());
    holder.desc.setText(company.getDescription());
  }

  return view;
}

private class CountryViewHolder{

  public TextView name;
  public ImageView flag;

}

private class CompanyViewHolder{

  public TextView name;
  public TextView email;
  public TextView desc;

}

为了简化这段代码，我们可以在每个持有者内部创建一个名为bindView()的方法；它将获取一个国家或公司对象并填充小部件：

CountryViewHolder holderC;
if (view == null){
  view = View.inflate(mContext, R.layout.row_job_country,null);
  holderC = new CountryViewHolder(view);
  view.setTag(view);
} else {
  holderC = (CountryViewHolder) view.getTag();
}
holderC.bindView((Country)mItemsList.get(i));
break;

private class CountryViewHolder{

  public TextView name;
  public ImageView flag;

  public CountryViewHolder(View view) {
    this.name = (TextView) view.findViewById(R.id.rowJobCountryTitle);
    this.flag = (ImageView) view.findViewById(R.id.rowJobCountryImage);
  }

  public void bindView(Country country){
    this.name.setText(country.getName());
    this.flag.setImageResource(country.getImageRes(mContext));
  }

}

我们现在将完成ListView性能改进列表。如果需要加载图像或长时间操作视图，我们需要在getView()中创建AsyncTask方法，以避免在滚动时进行繁重操作。例如，如果我们想在每一行显示从互联网下载的图像，我们会有一个LoadImageAsyncTask方法，我们将使用持有者和要下载图像的 URL 来执行它。当Asynctask方法完成后，它将拥有对持有者的引用，因此能够显示图像：

public View getView(int position, View convertView,
ViewGroup parent) {

  ...

  new LoadImageAsyncTask(list.get(position).getImageUrl, holder)
  .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, null);

  return convertView;
}

现在我们知道了所有不同的提高ListView性能的技术，我们准备引入RecyclerView。通过在实现中应用这些技术的大部分，我们将能够轻松识别它。

介绍 RecyclerView

RecyclerView在 Android 5.0 Lollipop 中引入，并被谷歌定义为比ListView更灵活和先进的版本。它基于一个类似于ListView的Adapter类，但强制使用ViewHolder类来提高性能和模块化，如我们前一部分所见。当我们把项目表示与组件分离，允许动画、项目装饰和布局管理器来完成工作时，灵活性就体现出来了。

RecyclerView通过RecyclerView.ItemAnimator处理添加和移除动画，我们可以通过子类化来自定义动画。如果你从数据源显示数据，或者数据发生变化，例如添加或移除项目，可以调用notifyItemInserted()或notifyItemRemoved()来触发动画。

为了添加分隔线、分组项目或突出显示某个项目，我们可以使用RecyclerView.ItemDecoration。

使用 ListView 的主要区别之一是使用布局管理器来定位项目。使用 ListView 时，我们知道我们的项目将始终垂直显示，如果我们想要网格，可以使用 GridView。布局管理器使我们的列表更加灵活，因为我们可以按需显示元素，甚至可以创建自己的布局管理器。

使用列表、网格或堆叠

默认情况下，我们有三个内置布局管理器：LinearLayoutManager、GridLayoutManager 和 StaggeredLayoutManager。

LinearLayoutManager 以列表形式对齐显示项目，我们可以指定方向——垂直或水平。

GridLayoutManager 以矩阵形式显示项目，我们可以指定列和行：

StaggereGriddLayoutManager 以交错方式显示项目；这些项目可以有不同的宽度和高度，我们可以使用 setGapStrategy() 控制它们的显示方式。

实现 RecyclerView

继续使用 MasteringAndroidApp，我们将再次实现工作机会列表，移除 ParseQueryAdapter 并使用 RecyclerView 替代。我们仍然会从 Parse 查询数据，但这次，我们将做的是将项目列表保存在一个变量中，并使用它来构建 RecyclerView.Adapter，这将由 RecyclerView 使用。

RecyclerView 包含在 v7 支持库中；将依赖项添加到项目中的最佳方式是打开项目结构，点击依赖项标签，并搜索 RecyclerView。将展示如下截图所示的结果列表：

这相当于在 build.gradle 依赖项中添加以下行：

dependencies {
  compile fileTree(dir: 'libs', include: ['*.jar'])
  compile 'com.android.support:appcompat-v7:21.0.3'
  compile 'com.parse.bolts:bolts-android:1.+'
  compile fileTree(dir: 'libs', include: 'Parse-*.jar')
  compile 'com.mcxiaoke.volley:library-aar:1.0.1'
  compile 'com.android.support:recyclerview-v7:21.0.3'
}

添加完代码行后，我们将点击同步 Gradle 与项目文件来更新依赖项，并准备在 XML 中使用 RecyclerView。

打开 fragment_list.xml 文件，将现有的 ListView 替换为 RecyclerView，如下所示：

<android.support.v7.widget.RecyclerView
  android:id="@+id/my_recycler_view"
  android:scrollbars="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent"/>

添加后如果没有错误，说明依赖项已正确添加。

下一步是创建适配器。这个适配器与我们为工作联系人创建的适配器略有不同；我们不会扩展 BaseAdapter，而是将扩展 RecyclerView.Adapter <RecyclerView.MyViewHolder>，在创建 JobOfferAdapter 适配器类后实现 ViewHolder 模式。但在扩展之前，我们必须创建一个内部类 MyViewHolder 继承 RecylcerView.ViewHolder。至此，我们有以下代码：

public class JobOffersAdapter  {

  public class MyViewHolder extends RecyclerView.ViewHolder{

    public TextView textViewName;
    public TextView textViewDescription;

    public  MyViewHolder(View v){
      super(v);
      textViewName = (TextView)v.findViewById(R.id.rowJobOfferTitle);
      textViewDescription = (TextView)v.findViewById(R.id.rowJobOfferDesc);
    }
  }
}

现在是扩展 JobOffersAdapter 类从 RecyclerView.Adapter<JobsOfferAdapter.MyViewHolder> 的时候了。系统将要求我们实现以下方法：

@Override
public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
  return null;
}

@Override
public void onBindViewHolder(MyViewHolder holder, int position) {

}

@Override
public int getItemCount() {
  return 0;
}

与 JobsContactsAdapter 中的方法相同，我们通过接收工作机会列表创建构造函数，并根据该列表实现适配器方法。

OnBindViewHolder 接收带有位置的持有者；我们需要做的就是获取列表中该位置的 job offer 并使用这些值更新持有者的文本视图。OnCreateViewHolder 将会填充视图；在这种情况下，我们只有一种类型，所以我们忽略 ViewType 参数。这里我们将展示一种替代的视图填充方法：使用作为参数传递的父级上下文。

最后，getItemCount 将返回工作机会的数量。完成上述所有任务后，我们新的适配器将使用以下代码创建：

public class JobOffersAdapter extends RecyclerView.Adapter<JobOffersAdapter.MyViewHolder>  {

  private  List<JobOffer> mOfferList;

  public JobOffersAdapter(List<JobOffer> offersList) {
    this.mOfferList = offersList;
  }

  @Override
  public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.row_job_offer, parent, false);
    return new MyViewHolder(v);
  }

  @Override
  public void onBindViewHolder(MyViewHolder holder, int position) {
    holder.textViewName.setText(mOfferList.get(position).getTitle());
    holder.textViewDescription.setText(mOfferList.get(position).getDescription());
  }

  @Override
  public int getItemCount() {
    return mOfferList.size();
  }

  public class MyViewHolder extends RecyclerView.ViewHolder{

    public TextView textViewName;
    public TextView textViewDescription;

    public  MyViewHolder(View v){
      super(v);
      textViewName = (TextView)v.findViewById(R.id.rowJobOfferTitle);
      textViewDescription = (TextView)v.findViewById(R.id.rowJobOfferDesc);
    }
  }
}

这就是我们需要适配器完成的所有工作；现在，我们需要初始化 RecyclerView 并设置布局管理器以及适配器。适配器必须使用从 Parse 获取的对象列表实例化，就像我们在之前的适配器中获取工作联系人一样。首先，在 OnCreateView 中，我们将初始化 RecyclerView：

public class ListFragment extends android.support.v4.app.Fragment {

  public List<JobOffer> mListItems;
  public RecyclerView mRecyclerView;

  public ListFragment() {
    // Required empty public constructor
  }

  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container,
  Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_list, container, false);

    mRecyclerView = (RecyclerView) view.findViewById(R.id.my_recycler_view);

    // use this setting to improve performance if you know that changes
    // in content do not change the layout size of the RecyclerView
    mRecyclerView.setHasFixedSize(true);

    // use a linear layout manager
    mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));

    //Retrieve the list of offers
    retrieveJobOffers();

    return view;
  }

最后，我们将调用 retrieveOffers()，这是一个 async 操作。只有当从 Parse 获取结果后，我们才能创建适配器并将其设置到列表中：

public void retrieveJobOffers(){

  ParseQuery<JobOffer> query = ParseQuery.getQuery("JobOffer");
  query.findInBackground(new FindCallback<JobOffer>() {

    @Override
    public void done(List<JobOffer> jobOffersList, ParseException e) {
      mListItems = jobOffersList;
      JobOffersAdapter adapter = new JobOffersAdapter(mListItems);
      mRecyclerView.setAdapter(adapter);
    }

  });
}

检验我们工作成果的最佳方式是查看控制台是否有错误。如果一切运行正常，你应该能够看到如下截图所示的优惠列表：

我们故意添加了一个重复的工作机会，以便删除它以查看 RecyclerView 中默认包含的移除动画。我们将在 长按监听器 中实现这个功能。点击监听器仅用于在详情视图中打开优惠。我们将在下一节中看到如何操作。

点击 RecyclerView 项

在 ListView 中，检测项目点击相当简单；我们可以直接执行 ListView.setOnItemClickLister 和 setOnItemLongClickListener 以处理长按点击。然而，这种实现方式在 RecyclerView 中并不那么快速，这种灵活性是有代价的。

这里有两种实现项目点击的方法：一种是通过创建一个实现 RecyclerView.OnItemTouchListener 的类，并调用 RecyclerView 的方法 addOnItemTouchListener，如下所示：

mrecyclerView.addOnItemTouchListener(new MyRecyclerItemClickListener(getActivity(), recyclerView, new MyRecyclerItemClickListener.OnItemClickListener() {

  @Override
  public void onItemClick(View view, int position){
    // ...
  }

  @Override
  public void onItemLongClick(View view, int position){
    // ...
  }
}));

public class MyRecyclerItemClickListener implements RecyclerView.OnItemTouchListener
{
  public static interface OnItemClickListener
  {
    public void onItemClick(View view, int position);
    public void onItemLongClick(View view, int position);
  }

  private OnItemClickListener mListener;
  private GestureDetector mGestureDetector;

  public MyRecyclerItemClickListener(Context context, final RecyclerView recyclerView, OnItemClickListener listener)
  {
    mListener = listener;

    mGestureDetector = new GestureDetector(context, new GestureDetector.SimpleOnGestureListener()
    {
      @Override
      public boolean onSingleTapUp(MotionEvent e)
      {
        return true;
      }

      @Override
      public void onLongPress(MotionEvent e)
      {
        View child = recyclerView.findChildViewUnder(e.getX(), e.getY());

        if(child != null && mListener != null)
        {
          mListener.onItemLongClick(child, recyclerView.getChildPosition(child));
        }
      }
    });
  }

  @Override
  public boolean onInterceptTouchEvent(RecyclerView view, MotionEvent e)
  {
    View child = view.findChildViewUnder(e.getX(), e.getY());

    if(child != null && mListener != null && mGestureDetector.onTouchEvent(e))
    {
      mListener.onItemClick(child, view.getChildPosition(child));
    }

    return false;
  }

  @Override
  public void onTouchEvent(RecyclerView view, MotionEvent motionEvent){
    //Empty
  }
}
@Override
public void onRequestDisallowInterceptTouchEvent(RecyclerView view){
  //Empty
}

这种方法的好处在于，我们可以在每个活动或片段中定义 onClick 内应该执行的操作。点击逻辑不在视图上，一旦我们构建了这个组件，就可以在不同的应用中重复使用它。

第二种方法是设置和管理ViewHolder内部的点击事件。如果我们想要在应用程序的不同部分或在另一个应用程序中复用这个ViewHolder，这里就会出现问题，因为点击逻辑位于视图内部，我们可能希望在不同的片段或活动中有不同的逻辑。然而，这种方法使得在同一行内检测不同组件的点击变得更加容易。例如，如果我们在行内有一个小图标用于删除，另一个用于分享优惠，这种方法更有意义。这样，我们可以在每一行设置对工作名称的点击，并在整行上设置长按监听器：

public class MyViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener, View.OnLongClickListener{

  public TextView textViewName;
  public TextView textViewDescription;

  public  MyViewHolder(View v){
    super(v);
    textViewName = (TextView)v.findViewById(R.id.rowJobOfferTitle);
    textViewDescription = (TextView)v.findViewById(R.id.rowJobOfferDesc);
    textViewName.setOnClickListener(this);
    v.setOnLongClickListener(this);
  }

  @Override
  public void onClick(View view) {
    switch (view.getId()){
      case R.id.rowJobOfferTitle :
      //Click
      break;
    }
  }

  @Override
  public boolean onLongClick(View view) {
    //Delete the element here
    return false;
  }
}

你应该能够判断在每种情况下应该使用哪种实现，并为其辩护。为了能够测试这一点，我们将在长按后删除一个元素（这里应该有一个确认对话框以避免误删，但我们将省略这部分内容）。元素将在本地被删除以显示移除动画。注意，我们没有从 Parse 中的源数据中删除这个元素；我们需要做的是从列表中删除元素并调用notifyItemRemoved来触发通知。我们可以通过getPosition()方法知道哪个条目被点击了。

@Override
public boolean onLongClick(View view) {
  mOfferList.remove(getPosition());
  notifyItemRemoved(getPosition());
  return true;
}

总结

在本章的最后，你将了解到如何实现一个适配器，如何在列表中处理不同类型的条目，以及我们如何以及为什么应用ViewHolder模式。你最早是在ListView类中学习这些内容，并手动实现了视图回收技术。因此，你将能够完全理解特性以及RecyclerView如何工作，以展示不同的条目显示方式和实现条目点击监听器。

在下一章，我们将探索在 Android 5.0 中与RecyclerView一起引入的一个新组件—CardView。我们将将其与RecyclerView结合使用，以获得灵活且专业外观的卡片列表。

第六章：CardView 和材料设计

在本章的第一部分，我们将从用户界面的角度显著改进我们的应用程序，使其看起来更专业，我们从一个新的小部件：CardView 开始。我们将学习如何使用设计时属性，这将提高我们的设计和开发速度，并且我们将使用第三方库轻松地在整个应用程序中包含自定义字体。

第二部分将重点关注设计支持库，将材料设计概念添加到我们的应用程序中，改进标签页，并在职位视图上添加视差效果。在此过程中，我们将阐明工具栏、操作栏和应用程序栏是什么，以及如何从应用程序栏实现向上导航。

• CardView 和 UI 小贴士：

  • CardView

  • 设计时布局属性

  • 自定义字体

• 设计支持库：

  • TabLayout

  • 工具栏、操作栏和应用程序栏

  • CoordinatorLayout

  • 向上导航

CardView 和 UI 设计小贴士

目前，我们的应用程序以行形式显示职位信息，包含两个文本视图；它展示了所需的信息，我们可以说应用程序目前是好的，并且达到了它的目的。然而，我们仍然可以让应用程序实用，并且同时拥有专业、美观的界面，使我们能够保持原创并与竞争对手不同。例如，为了展示职位信息，我们可以模拟一个带有广告海报的职位公告板。为此，我们可以使用 CardView 小部件，它将赋予其深度和纸质卡片的外观。我们将改变我们应用程序的字体。这样一个简单的改变可以带来很大的不同；当我们把默认字体改为自定义字体时，从用户的角度来看，这个应用程序就是一个定制的版本，开发者关注到了每一个细节。

介绍 CardView

CardView 随 Android 5.0 一起发布。它是一个具有圆角和阴影的视图，从而提供深度感，并模拟卡片。将此与回收视图结合使用，我们可以得到一个外观一致且符合许多应用程序的列表项。以下是一张带有 CardView 和自定义字体的列表示例：

在使用 CardView 时，请记住，圆角根据 Android 版本的不同实现方式也不同。在 Android 5.0 之前的版本中，为了防止裁剪子视图以及实现阴影效果，会增加内边距。在 Android 5.0 及以后的版本中，基于 CardView 的 elevation 属性显示阴影，任何与圆角相交的子视图都会被裁剪。

要开始使用 CardView，我们需要从项目结构窗口将其作为依赖项添加，或者在 build.gradle 文件内的依赖项中添加以下行：

dependencies {
  ...
  compile 'com.android.support:cardview-v7:21.0.+'
}

我们可以修改我们的 row_job_offer.xml 文件，将基础视图设置为带有内容的 CardView。这个 CardView 将具有一些高度和圆角。为了设置这些属性，我们需要通过在 XML 中添加以下架构来导入 CardView 自有的属性：

以下代码将创建新的布局：

<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.CardView

    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="170dp"
    android:layout_margin="10dp"
    card_view:cardElevation="4dp"
    card_view:cardCornerRadius="4dp"
    >
    <LinearLayout
        android:orientation="vertical"
        android:layout_width="wrap_content"
        android:padding="15dp"
        android:layout_height="wrap_content">
        <TextView
            android:id="@+id/rowJobOfferTitle"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Title"
            android:textColor="#555"
            android:textSize="18sp"
            android:layout_marginBottom="20dp"
            />
        <TextView
            android:id="@+id/rowJobOfferDesc"
            android:layout_marginTop="5dp"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Description"
            android:textColor="#999"
            android:textSize="16sp"
            />
    </LinearLayout>
</android.support.v7.widget.CardView>

我们找到了一块软木塞的纹理，将其设置为背景，并在每张卡片上添加了一个带有 ImageView 对象的图钉。以下是实现的效果：

应用程序看起来比之前好多了；现在它真成了一个职位公告板。仅仅通过改变外观，展示了相同的信息——同样是带有标题和职位描述的两个TextView——它就从演示应用演变成了可以在 Play 商店完美发布的应用。

我们可以通过更改字体来继续改进这一点，但在介绍设计时布局属性之前，这将使视图设计更加容易和快捷。

设计时的布局属性

在使用设计时属性时，我总是想起我在第一份工作中发生的一个有趣故事。我需要显示联系人列表，因此我在创建联系人视图时使用了虚拟数据，这样在创建视图时可以分配一些文本，以便在设计视图中看到大小、颜色和总体外观。

我创建的联系人名叫Paco el churrero，即弗兰克，炸油条的人。Paco 是弗朗西斯科的昵称，而如果你不知道，churro 是一种油炸面食。不管怎样，这些虚拟数据后来被更正为适当的联系人姓名，当显示联系人列表时，这些联系人是从服务器获取的。我记不清是我急于发布应用，忘记了这个操作，还是我简单地遗漏了它，但应用就这样上线了。我开始处理另一个组件，直到有一天服务器端出现问题，服务器开始发送空白联系人。应用无法用联系人姓名覆盖虚拟数据，结果 Paco el churrero 作为联系人显示了出来！幸运的是，在用户注意到之前，服务器得到了修复。

之后，我使用虚拟数据创建了视图，当我满意视图后，我删除了虚拟数据。但是，这种方法在需要更改 UI 时，我不得不再次添加虚拟数据。

随着 Android Studio 0.2.11 版本的发布，设计时的布局属性应运而生。这些属性允许我们在设计视图中显示文本或任何属性，这些属性在运行应用时不会出现；这些数据只在设计视图中可见。

要使用这些属性，我们需要在布局中添加工具的命名空间。命名空间总是在视图的根元素中定义；你可以找到这样的行，informalexample">。

<FrameLayout
xmlns:android="http://schemas.android.com/apk/res/android 

为了测试这个，我们将在职位信息和职位描述的TextView中添加一些虚拟文本：

<TextView
    android:id="@+id/rowJobOfferTitle"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    tools:text="Title of the job"
    android:textColor="#555"
    android:textSize="18sp"
    android:layout_marginBottom="20dp"
    />
<TextView
    android:id="@+id/rowJobOfferDesc"
    android:layout_marginTop="5dp"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    tools:text="Description of the job"
    android:textColor="#999"
    android:textSize="16sp"
    android:ellipsize="marquee"
    />

如果你遇到渲染设计视图的问题，可以更改 Android 版本或主题，如下面的图片所示。如果问题仍然存在，请确保你安装了最新版本的 Android Studio 和下载了最新的 Android API：

当视图渲染后，我们可以看到设计时属性中的职位提供标题和描述。

你可以使用任何属性，如文本颜色、背景颜色，甚至图片源，这对于创建包含从互联网下载图片的视图非常有用，但在创建视图时需要预览图片来查看视图的外观。

在 Android 中使用自定义字体

当在 Android 上使用自定义字体时，有一个令人惊叹的开源库——Chris Jenkins 的Calligraphy——它允许我们为整个应用程序设置默认字体。这意味着每个带有文本的组件，如 Button、TextView 和 EditText 默认都会显示这种字体，我们无需为应用程序中的每个单独项目分别设置字体。让我们更详细地了解这一点，并考虑一些支持 Calligraphy 的观点。

如果我们想要应用一个自定义字体，我们首先需要做的是将这个字体放在我们应用程序的assets文件夹中。如果我们没有这个文件夹，我们需要在main方法中创建它，与java和src同一级别。在assets中创建一个名为fonts的第二个文件夹，并将字体放在那里。在我们的示例中，我们将使用Roboto字体；可以从 Google 字体获取，地址为www.google.com/fonts#UsePlace:use/Collection:Roboto。下载字体后，应用程序结构应与以下截图类似：

字体放置到位后，我们需要从这个字体创建一个Typeface对象，并将其设置为myTextView：

Typeface type = Typeface.createFromAsset(getAssets(),"fonts/Roboto-Regular.ttf"); myTextView.setTypeface(type);

如果我们现在想将相同的字体应用到我们应用程序中的所有组件上，比如标签、标题和职位提供卡，我们不得不在应用程序的不同地方重复相同的代码。除此之外，我们还会遇到性能问题。从资源中创建字体需要访问文件；这是一个昂贵的操作。如果我们改变了适配器中职位标题和职位描述的字体，我们应用程序的视图在滚动时将不再流畅。这带来了一些额外的考虑；例如，我们不得不在一个静态类中一次加载字体，并在整个应用程序中使用它。Calligraphy 为我们处理了所有这些事情。

使用书法的另一个好处是它允许我们在 XML 中设置字体，这样我们就可以在同一个视图中拥有不同的字体，而且无需通过编程设置字体。我们只需在组件中添加fontPath属性，并可选地添加ignore属性以避免 Android Studio 未检测到fontPath的警告：

<TextView     android:text="@string/hello_world"     android:layout_width="wrap_content"     android:layout_height="wrap_content"     
fontPath="fonts/Roboto-Bold.ttf"
tools:ignore="MissingPrefix"/>

既然我们已经解释了书法的优点，我们可以在我们的应用程序中使用它。在build.gradle中的依赖项中添加以下行：

compile 'uk.co.chrisjenx:calligraphy:2.1.0'

要应用默认字体，请在MAApplication内的Oncreate()中添加以下代码：

CalligraphyConfig.initDefault(new CalligraphyConfig.Builder().setDefaultFontPath("fonts/Roboto-Regular.ttf").setFontAttrId(R.attr.fontPath).build());

以及我们想要显示默认字体的任何活动中添加以下内容：

@Override protected void attachBaseContext(Context newBase) {super.attachBaseContext(CalligraphyContextWrapper.wrap(newBase)); }

最后，我们可以找到我们喜欢的手写字体，并将其设置为卡片标题和描述，效果可能类似于以下输出：

设计支持库

设计支持库以官方方式引入了材料设计组件，并且兼容从 Android 2.1 开始的版本。材料设计是随着 Android Lollipop 推出的一种新的设计语言。在这个库发布之前，我们观看了使用这些组件的应用程序的视频和示例，但没有官方的方法来使用它。这为应用程序设定了一个基线；因此，要掌握 Android，我们需要掌握材料设计。你可以使用以下代码行进行编译：

compile 'com.android.support:design:22.2.0'

这个库包括视觉组件作为输入文本，带有浮动文本、浮动动作按钮、TabLayout…等等。然而，材料设计不仅仅是视觉组件；它还涉及到其元素之间的动作和过渡，因此引入了CoordinatorLayout。

介绍 TabLayout

TabLayout设计库允许我们有固定或可滚动的标签，包含文本、图标或自定义视图。正如你在本书的第一个实例中所记得的，自定义标签并不是那么容易做到的，要从滚动标签更改为固定标签，我们需要不同的实现方式。

现在，我们想要改变标签的颜色和设计使其固定；我们首先需要做的是进入activity_main.xml并添加TabLayout，移除之前的PagerTabStrip标签。我们的视图将如下所示：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    android:layout_height="fill_parent"
    android:layout_width="fill_parent"
    android:orientation="vertical"
    >
    <android.support.design.widget.TabLayout
        android:id="@+id/tab_layout"
        android:layout_width="match_parent"
        android:layout_height="50dp"/>
    <android.support.v4.view.ViewPager
        android:id="@+id/pager"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
    </android.support.v4.view.ViewPager>
</LinearLayout>

当我们有这个时，我们需要向Layout标签中添加标签。有两种方法可以做到这一点；一种是通过以下方式手动创建标签并添加它们：

tabLayout.addTab(tabLayout.newTab().setText("Tab 1"));

第二种方式，也就是我们将要实现的标签方式，是将视图页面设置为TabLayout。我们的MainActivity.java类应该如下所示：

public class MainActivity extends ActionBarActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    MyPagerAdapter adapter = new MyPagerAdapter(getSupportFragmentManager());
    ViewPager viewPager = (ViewPager) findViewById(R.id.pager);
    viewPager.setAdapter(adapter);

    TabLayout tabLayout = (TabLayout) findViewById(R.id.tab_layout);

    tabLayout.setupWithViewPager(viewPager);
  }

  @Override
  protected void attachBaseContext(Context newBase) {
    super.attachBaseContext(CalligraphyContextWrapper.wrap(newBase));
  }

}

如果我们不指定任何颜色，TabLayout会使用主题中的默认颜色，并且标签的位置是固定的。我们新的标签栏将如下所示：

工具栏、操作栏和应用程序栏

在为我们的应用程序添加动作和动画之前，我们需要明确工具栏、操作栏、应用程序栏和AppBarLayout的概念，因为这些可能会造成一些混淆。

操作栏和应用程序栏是同一个组件；“应用程序栏”只是操作栏在材料设计中获得的新名字。这是固定在我们活动顶部的不透明栏，通常显示应用程序的标题、导航选项，并显示不同的操作。图标的显示与否取决于主题：

自从 Android 3.0 以来，默认使用 Holo 主题或其任何后代，这些主题显示操作栏。

让我们继续下一个概念——工具栏(toolbar)。在 API 21，即 Android Lollipop 中引入，它是操作栏(action bar)的泛化，不必固定在活动顶部。我们可以使用setActionBar()方法指定工具栏是否作为活动的操作栏。这意味着工具栏将根据我们的需求表现为操作栏或非操作栏。

如果我们创建一个工具栏并将其设置为操作栏，我们必须使用带有.NoActionBar选项的主题，以避免在主题默认的操作栏和我们刚转换成操作栏的工具栏之间出现重复。

设计支持库中引入了一个名为AppBarLayout的新元素。它是一个LinearLayout，旨在包含工具栏以基于滚动事件显示动画。我们可以使用app:layout_scrollFlag属性在子项中指定滚动时的行为。AppBarLayout旨在被包含在CoordinatorLayout中，该组件也随设计支持库一起引入，我们将在下一节中进行描述。

使用 CoordinatorLayout 添加动态效果

CoordinatorLayout允许我们向应用程序添加动态效果，将触摸事件和手势与视图连接起来。例如，我们可以协调滚动动作与视图的折叠动画。这些手势或触摸事件由Coordinator.Behaviour类处理，而AppBarLayout已经拥有这个私有类。如果我们想要在自定义视图中使用这种动态效果，我们将不得不自己创建这种行为。

CoordinatorLayout可以实现在我们应用程序的顶层，因此我们可以将其与应用程序栏或活动或片段内的任何元素结合使用。它也可以作为一个容器，与子视图进行交互。

在我们的应用程序中，当点击卡片时，我们将显示一份工作机会的完整视图。这将在一个新活动中展示。该活动将包含一个显示工作机会标题和公司标志的工具栏。如果描述很长，我们需要向下滚动来阅读；此时，我们希望顶部不再相关的公司标志可以折叠。同样，当我们向上滚动时，希望它再次展开。为了控制工具栏的折叠，我们将需要CollapsingToolbarLayout。

描述将被包含在NestedScrollView中，这是来自 Android v4 支持库的滚动视图。使用NestedScrollView的原因是，这个类可以将滚动事件传递给工具栏，而ScrollView则不能。确保compile 'com.android.support:support-v4:22.2.0'是最新版本。

我们将在下一章中了解如何下载图片，所以现在我们可以只从drawable文件夹放置一个图片来实现CoordinatorLayout的功能。在下一章中，我们将为每个提供工作的公司加载相应的图片。

我们的优惠详情视图，activity_offer_detail.xml，将如下所示：

<android.support.design.widget.CoordinatorLayout 

    android:id="@+id/main_content"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <android.support.design.widget.AppBarLayout
        android:id="@+id/appbar"
        android:layout_height="256dp"
        android:layout_width="match_parent">
        <android.support.design.widget.CollapsingToolbarLayout
            android:id="@+id/collapsingtoolbar"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:layout_scrollFlags="scroll|exitUntilCollapsed">
            <ImageView
                android:id="@+id/logo"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:scaleType="centerInside"
                android:src="img/googlelogo"
                app:layout_collapseMode="parallax" />
            <android.support.v7.widget.Toolbar
                android:id="@+id/toolbar"
                android:layout_height="?attr/actionBarSize"
                android:layout_width="match_parent"
                app:layout_collapseMode="pin"/>
        </android.support.design.widget.CollapsingToolbarLayout>
    </android.support.design.widget.AppBarLayout>
    <android.support.v4.widget.NestedScrollView
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:paddingLeft="20dp"
        android:paddingRight="20dp"
        app:layout_behavior="@string/appbar_scrolling_view_behavior">
            <TextView
                android:id="@+id/rowJobOfferDesc"
                android:layout_width="fill_parent"
                android:layout_height="fill_parent"
                android:text="Long scrollabe text"   
                android:textColor="#999"
                android:textSize="18sp"
                />
    </android.support.v4.widget.NestedScrollView>
</android.support.design.widget.CoordinatorLayout>

如你所见，CollapsingToolbar布局对滚动标志做出反应，并告诉其子元素如何反应。工具栏将固定在顶部，始终保持可见，app:layout_collapseMode="pin"。然而，标志随着视差效果消失，app:layout_collapseMode="parallax"。不要忘记在NestedScrollview属性中添加app:layout_behavior="@string/appbar_scrolling_view_behavior"，并清理项目以内部生成这个字符串资源。如果你遇到问题，可以直接设置字符串，"android.support.design.widget.AppBarLayout$ScrollingViewBehavior"，这将帮助你定位问题。

当我们点击一个工作机会时，需要导航到OfferDetailActivity，并且我们需要发送该工作机会的信息。正如你可能从初级水平就知道，要在活动之间发送信息，我们使用意图。在这些意图中，我们可以放置数据或序列化的对象。为了能够发送JobOffer类型的对象，我们必须创建一个实现Serializable的JobOffer类。一旦我们这样做，就可以在JobOffersAdapter中检测元素的点击，如下所示：

public class MyViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener, View.OnLongClickListener{

  public TextView textViewName;
  public TextView textViewDescription;

  public  MyViewHolder(View v){
    super(v);
    textViewName = (TextView)v.findViewById(R.id.rowJobOfferTitle);
    textViewDescription = (TextView)v.findViewById(R.id.rowJobOfferDesc);
    v.setOnClickListener(this);
    v.setOnLongClickListener(this);
  }

  @Override
  public void onClick(View view) {
    Intent intent = new Intent(view.getContext(), OfferDetailActivity.class);
    JobOffer selectedJobOffer = mOfferList.get(getPosition());
    intent.putExtra("job_title", selectedJobOffer.getTitle());
    intent.putExtra("job_description",selectedJobOffer.getDescription());
    view.getContext().startActivity(intent);
  }

一旦我们开始这个活动，就需要获取标题并将其设置到工具栏上。首先使用虚拟数据在NestedScrollView内的TextView描述中添加一段长文本进行测试。我们希望能够滚动以测试动画效果：

public class OfferDetailActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_offer_detail);

    String job_title = getIntent().getStringExtra("job_title");

    CollapsingToolbarLayout collapsingToolbar =
    (CollapsingToolbarLayout) findViewById(R.id.collapsingtoolbar);
    collapsingToolbar.setTitle(job_title);

  }

}

最后，确保在 values 文件夹中的styles.xml文件默认使用不带操作栏的主题：

<resources>

  <!-- Base application theme. -->
  <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
    <!-- Customize your theme here. -->
</style>

</resources>

现在我们准备测试行为。启动应用并滚动到底部。看看图片如何折叠以及工具栏如何固定在顶部。它将与以下截图类似：

我们遗漏了一个属性，以实现动画中的良好效果。仅仅折叠图片还不够；我们需要让图片以平滑的方式消失，由工具栏的背景色替换。

在CollapsingToolbarLayout中添加contentScrim属性，这将使用主题的主色调渐变显示图片，这与当前工具栏使用的颜色相同：

<android.support.design.widget.CollapsingToolbarLayout
    android:id="@+id/collapsingtoolbar"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    app:layout_scrollFlags="scroll|exitUntilCollapsed"
    app:contentScrim="?attr/colorPrimary">

使用这个属性，应用在展开和折叠时看起来会更好：

我们只需通过改变颜色和为图片添加边距来稍微调整一下应用的风格；我们可以在styles.xml中更改主题的颜色：

<resources>
  <!-- Base application theme. -->
  <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
    <item name="colorPrimary">#8bc34a</item>
    <item name="colorPrimaryDark">#33691e</item>
    <item name="colorAccent">#FF4081</item>
  </style>
</resources>

将AppBarLayout的大小调整为190dp，并在 ImageView 中添加50dp paddingLeft和paddingRight以实现以下效果：

后退导航和向上导航

有两种方法可以导航到上一个屏幕。一种称为后退导航，是通过后退按钮执行的导航，这可以是硬件或软件按钮，具体取决于设备。

向上导航是随着 Android 3.0 中的操作栏引入的一种导航方法；在这里，我们可以使用指向左边的箭头返回到上一个屏幕，该箭头显示在操作栏中，如下面的截图右侧所示：

有时我们需要覆盖后退导航的功能。例如，如果我们有一个自定义的WebView并通过浏览器导航，当我们点击后退时，后退按钮默认会让我们离开活动；然而，我们想要的是在浏览器使用历史中后退：

@Override
public void onBackPressed() {
  if (mWebView.canGoBack()) {
    mWebView.goBack();
    return;
  }

  // Otherwise defer to system default behavior.
  super.onBackPressed();
}

除了这一点，后退导航是默认实现的，而向上导航则不是。要实现向上导航，我们需要一个操作栏（或者作为操作栏的工具栏），并且需要通过setDisplayHomeAsUpEnabled(true)方法激活此导航。在我们的活动中的onCreate内，我们将添加以下几行代码，以将我们的工具栏设置为操作栏并激活向上导航：

final Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);

这将在我们活动的顶部显示后退箭头，如下面的截图所示。但目前，我们还没有任何功能：

一旦激活，我们需要捕获操作栏中后退箭头的点击。这将检测到菜单中带有android.R.id.home ID 的动作选择；我们只需要在我们的活动中添加以下代码：

@Override
public boolean onOptionsItemSelected(MenuItem item) {
  switch (item.getItemId()) {
    case android.R.id.home:
    finish();
    return true;
  }
  return super.onOptionsItemSelected(item);
}

总结

在本章中，我们的应用程序发生了巨大变化；我们完全改变了职位列表，现在它看起来类似于一张张精美的手写纸卡，钉在软木板上。同时，你学习了来自材料设计的概念以及如何使用应用栏和工具栏。设计支持库中还有更多小部件，如InputText或FloatingButton，它们非常容易实现。只需将小部件添加到视图中，这就是为什么我们专注于更复杂的组件，如CoordinatorLayout或CollapsingToolbarLayout。

在下一章中，我们将了解如何下载公司标志、直接通过 URL 发布职位广告、讨论内存管理，并看看如何确保我们的应用程序中没有内存泄漏。

第七章：图片处理与内存管理

在本章中，我们将探讨如何展示从 URL 下载的图片。我们将会讨论如何使用 Android 原生 SDK 以及常用的第三方库来实现这一点。我们将考虑诸如下载、压缩、缓存系统以及内存或磁盘存储等关键概念和特性。

我们还将讨论九宫格是什么以及如何创建它，并通过引入矢量图来讲述不同尺寸和密度文件夹中的 drawables。

最后一个部分将专注于内存管理。在我们的应用中识别内存泄漏是一项关键任务，通常在使用图片时会发生。我们将看看可能导致这些泄漏的常见错误以及如何预防的一般性建议。

• 显示网络图片

  • 传统方式

  • Volley ImageDownloader

  • 毕加索

• 图片

  • 矢量图

  • 动画矢量图

  • 九宫格

• 内存管理

  • 检测和定位泄漏

• 防止泄漏

下载图片

使用ImageView在单行代码中下载并显示图片是可能的。自从 Android 开发开始，这是每个开发者都做过的事情。Android 是一项超过五年历史的技术，因此我们可以预期这项技术相当先进，并且可以找到简化它的第三方解决方案。话虽如此，如果这本书不解释在没有任何第三方库的情况下下载图片并显示的过程，它就不会被称为《精通 Android》。

在您的应用中使用最新的库是好的，但更好地理解您正在实施的解决方案，甚至能自己构建这个库会更好。

在处理图片时，我们需要从网络连接到数组字节的下载以及它们转换为位图的一切。在某些情况下，将图片存储在磁盘上有意义，这样下次我们打开应用时，这些图片就已经在那里了。

即使我们能够显示一张图片，事情并没有就此结束；我们应该能够在列表视图中管理图片的下载。下载、存储和显示系统需要同步，以便应用无故障地运行并拥有流畅的列表，可以无问题地滚动。请记住，当我们浏览列表时，视图是被回收的。这意味着如果我们快速滚动，可能会开始下载一张图片。等到下载完成时，这个视图可能已经不再屏幕上显示，或者它会被回收用于另一个视图。

下载图片的传统方式

要在不使用任何第三方库的情况下显示图像（互联网上带有 URL 的图像），我们需要使用 HttpURLConnection 建立连接。我们需要打开一个输入流并消费信息，这可以通过工厂方法 BitmapFactory.decodeStream(InputStream istream) 转换为 Bitmap 图像。我们可以将其从输入流转为文件，以便将图像存储在磁盘上，以后再访问。目前，让我们尝试先下载它并将其转换为 Bitmap 图像，我们将其保存在内存中并在 ImageView 中显示。

我们将在 OfferDetailActivity 中为每个优惠展示公司的标志。记得在 Parse 中，我们创建了一个数据库，并且创建了一个名为 imageLink 的字段。你只需要将这个字段填充为公司标志的 URL。

我们需要在 OfferDetailActivity 中拥有图像链接；为此，我们需要在 JobOfferAdapter 中点击卡片时发送一个额外的参数。使用以下代码：

@Override
public void onClick(View view) {
  Intent intent = new Intent(view.getContext(), OfferDetailActivity.class);
  JobOffer offer = mOfferList.get(getPosition());
  intent.putExtra("job_title", offer.getTitle());
  intent.putExtra("job_description",offer.getDescription());
  intent.putExtra("job_image",offer.getImageLink());
  view.getContext().startActivity(intent);
}

负责图像下载的方法将是一个静态方法，可以在应用程序的任何位置调用。这个方法将被放置在名为 utils 的包中的 ImageUtils 类内。我们首先检查 URL 是否正确，然后从 HttpURLConnection 中获取内容，将输入流转为之前解释过的 Bitmap 图像：

public static Bitmap getImage(String urlString) {

  URL url = null;

  try {
    url = new URL(urlString);
  } catch (MalformedURLException e) {
    return null;
  }

  HttpURLConnection connection = null;
  try {
    connection = (HttpURLConnection) url.openConnection();
    connection.connect();
    int responseCode = connection.getResponseCode();
    if (responseCode == 200) {
      return BitmapFactory.decodeStream(connection.getInputStream());
    } else
      return null;
  } catch (Exception e) {
    return null;
  } finally {
    if (connection != null) {
      connection.disconnect();
    }
  }
}

我们将创建一个名为 displayImageFromUrl() 的方法，该方法接收 ImageView 和带有链接的字符串，以代替在 onCreate 中处理所有这些逻辑。在 onCreate 中，我们只需要检索参数并调用该方法：

String imageLink = getIntent().getStringExtra("job_image");
ImageView imageViewLogo = (ImageView) findViewById(R.id.logo);

displayImageFromUrl(imageViewLogo,imageLink);

在这个阶段，我们可能想要调用 ImageUtils.getImage(link) 方法并将 Bitmap 设置到 ImageView 中。但请注意，我们忽略了一件事；我们不能在主活动线程中直接调用打开网络连接的方法。我们需要在后台执行这些操作，否则可能会引发异常。AsyncTask 方法正是解决这一问题的好方法：

String imageLink = getIntent().getStringExtra("job_image");
ImageView imageViewLogo = (ImageView) findViewById(R.id.logo);

displayImageFromUrl(imageViewLogo,imageLink);

public void displayImageFromUrl(ImageView imageView, String link){

  new AsyncTask<Object,Void,Bitmap>(){

    ImageView imageView;
    String link;

    @Override
    protected Bitmap doInBackground(Object... params) {
      imageView = (ImageView) params[0];
      link = (String) params[1];

      return ImageUtils.getImage(link);
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
      super.onPostExecute(bitmap);
      imageView.setImageBitmap(bitmap);
    }

  }.execute(imageView, link);
}

根据所使用的图像的形状和背景，使用 ImageView 属性 scaleType，设置为 centerInside 或 centerCrop 值会看起来更好。centerInside 值将缩小图像以确保它适合于接收者同时保持比例。centerCrop 值将放大图像直到它填满接收者的最短边。图像的其余部分将超出 ImageView 的边界。

在本章开头，我提到过这个功能其实可以用一行代码就完成，但正如你所见，我们自己动手做远不止一行代码，还涉及了后台线程、HttpURLConnection等不同的概念。这仅仅是开始；我们实现了最简单的情况。如果我们以同样的方式在列表视图的行中设置图像，会遇到问题。这些问题之一就是在滚动时无限触发AsyncTask调用。如果我们有一个带有最大AsyncTask数量的队列以及一个取消机制，用以忽略或取消不在屏幕上的视图的请求，这种情况是可以控制的。

当我们启动AsyncTask时，我们有一个对ImageView的引用，在PostExecute中，我们将Bitmap设置给它。这个下载操作可能需要一些时间，这样在滚动时ImageView可能会被回收。这意味着我们正在下载一个图像，用于在列表的不同位置回收的ImageView以显示不同的元素。例如，如果我们有一个带有联系人面孔的列表，我们可能会看到与名字不符的人脸。为了解决这个问题，我们可以做的是将图像链接的字符串设置为ImageView的标签，myImageView.setTag(link)。如果视图被回收，它将有一个带有新链接的不同项；因此，我们可以在onPostExecute中检查，在显示图像之前，当前的链接是否与ImageView标签中的链接相同。

这两个是常见问题及其相应的解决方案，但我们还没有就此结束。如果我们继续这条路，最繁琐的事情就是创建一个缓存系统。根据应用和情况的不同，我们可能希望永久存储下载的图像。例如，如果我们正在创建一个带有你最喜欢的专辑列表的音乐应用，将专辑封面存储在磁盘上是有意义的。如果你每次打开应用都会看到最喜欢的列表，并且我们知道封面不会改变，为什么不永久存储图像，以便下次打开应用时加载更快，不消耗任何数据呢？对于用户来说，这意味着每次都能瞬间加载首屏，这对用户体验将是一个巨大的提升。为此，我们需要将图像下载到文件中，并有一个第三种方法稍后从文件中读取图像，包括检查我们是否已经下载了此图像，或者这是我们第一次请求它。

另一个例子可以是新闻源阅读应用。我们知道图像几乎每天都会改变，所以将它们保存在磁盘上没有意义。然而，在我们浏览应用时，可能仍然希望将它们保存在内存中，以避免在同一个会话中返回某个活动时重新下载。在这种情况下，我们需要密切关注内存使用情况。

是时候引入一些第三方库来帮助解决这个问题了。我们可以从 Volley 开始，就是之前用于实现网络请求的那个 Volley。

使用 Volley 下载图像

Volley 提供了两种请求图像的机制。第一种机制ImageRequest与我们刚才使用 Volley 请求队列和按需调整图像大小完成的AsyncTask非常相似。以下是请求的构造函数：

public ImageRequest(String url, Response.Listener<Bitmap> listener, int maxWidth, int maxHeight, Config decodeConfig, Response.ErrorListener errorListener) { … }

maxWidth和maxHeight参数将用于调整图像大小；如果我们不想调整大小，可以将其值设置为0。这是我们示例中用于获取图像的方法：

public void displayImageWithVolley(final ImageView imageView, String url){

  ImageRequest request = new ImageRequest(url,
  new Response.Listener<Bitmap>() {
    @Override
    public void onResponse(Bitmap bitmap) {
      imageView.setImageBitmap(bitmap);
    }
  }, 0, 0, null,
  new Response.ErrorListener() {
    public void onErrorResponse(VolleyError error) {

    }
  });

  MAApplication.getInstance().getRequestQueue().add(request);
}

第二个机制，真正有趣的是ImageLoader。它可以同时处理多个请求，并且是我们在上一节中解释的原因下，在列表视图中使用的机制。我们可以创建我们希望它使用的缓存机制——内存或磁盘。

它通过使用一种特殊的ImageView：NetworkImageView来工作。当ImageLoader对象准备好后，我们可以仅用一行代码通过NetworkImageView下载图片：

myNetworkImageView.setImage(urlString, imageloader);

它允许我们执行不同的操作，例如设置默认图像或设置在请求失败时的图像。使用以下代码：

myNetworkImageView.sesetDefaultImageResId(R.id.default_image);
myNetworkImageView.setErroImageResId(R.id.image_not_found);

如果说这里有复杂性，那就是在我们实现ImageLoader的时候。首先，我们需要以在Application类中创建RequestQueue相同的方式来创建它，这样我们的应用中任何地方都可以访问到：

@Override
public void onCreate() {
  super.onCreate();

  sInstance = this;

  mRequestQueue = Volley.newRequestQueue(this);

  mImageLoader = new ImageLoader(mRequestQueue, new myImageCache());

构造函数需要一个缓存实现。Google 是一个基于内存的缓存示例，其大小等于三屏图像的大小：

public class LruBitmapCache extends LruCache<String, Bitmap>
implements ImageCache {

  public LruBitmapCache(int maxSize) {
    super(maxSize);
  }

  public LruBitmapCache(Context ctx) {
    this(getCacheSize(ctx));
  }

  @Override
  protected int sizeOf(String key, Bitmap value) {
    return value.getRowBytes() * value.getHeight();
  }

  @Override
  public Bitmap getBitmap(String url) {
    return get(url);
  }

  @Override
  public void putBitmap(String url, Bitmap bitmap) {
    put(url, bitmap);
  }

  // Returns a cache size equal to approximately three screens worth of images.
  public static int getCacheSize(Context ctx) {
    final DisplayMetrics displayMetrics = ctx.getResources().
    getDisplayMetrics();
    final int screenWidth = displayMetrics.widthPixels;
    final int screenHeight = displayMetrics.heightPixels;
    // 4 bytes per pixel
    final int screenBytes = screenWidth * screenHeight * 4;

    return screenBytes * 3;
  }
}

我们可以看到，在缓存实现之间的选择是一个手动过程；我们必须创建带有所需实现的类，并将其设置在ImageLoader的构造函数中。这就是为什么接下来我们要了解的库在推出时是一次革命。

介绍 Picasso

创建OkHttp的同一批人将 Picasso 带到了 Android 社区。Picasso 允许我们仅用一行代码下载并显示图像，无需创建ImageLoader，并且具有自动使用磁盘和内存的缓存实现。它包括图像转换、ImageView回收和请求取消等功能。所有这些都是免费的。Square 团队带给社区的东西令人难以置信。

如果这还不够，调试模式会在图像中显示指示器，角落里的小三角形，不同的颜色表示我们第一次下载图像（即从网络获取时）、从内存缓存获取时以及从磁盘缓存获取时：

掌握图像处理

在结束关于图像这一章节之前，我们必须介绍本书中的两个概念。你知道，根据屏幕密度，图像可以被放置在多个文件夹中——从低密度的drawable-ldpi到高密度的drawable-hdpi，以及超超超高密度的drawable-xxxhdpi，将来可能还会有更多。当我们这样做时，需要考虑我们是希望在所有屏幕上获得高质量图像，还是一个轻量级的 APK。复制图像将增加我们安装程序的大小。在 Android 5.0 中引入的以下组件将解决这个问题。

矢量图形

这些图形基于矢量图形；矢量图形可以放大或缩小而不损失任何质量。有了这个，我们只需要一个图形资源，无论在什么屏幕上使用，它都会有出色的质量，无论是 Android 手表还是 Android 电视。

矢量图形（Vector drawables）是以与定义形状相同的方式定义的——在 XML 文件中。下面是一个简单的vectordrawable.xml文件示例：

<vector  android:height="64dp" android:width="64dp" android:viewportHeight="600" android:viewportWidth="600">
  <group>
    <path android:fillColor="@color/black_primary" android:pathData="M12 36l17-12-17-12v24zm20-24v24h4V12h-4z" />
  </group>
</vector>

请注意，矢量标签具有高度和宽度属性；如果我们把这个图形设置在ImageView中，且大小小于容器，它看起来会变得像素化。

你可能会问，我们从哪里获取pathData属性？你可能有一个.svg格式的图像，这是一种可缩放图形的格式。这个图像可以用文本编辑器打开，你应该能看到类似于此处路径数据的内容：

<svg  width="48" height="48" viewBox="0 0 48 48">
  <path d="M12 36l17-12-17-12v24zm20-24v24h4V12h-4z"/>
</svg>

谷歌提供了一套材料设计图标，这些图标带有 SVG 版本；有了这个，你可以开始为你的应用添加无限可缩放的图像。我们展示的路径是这套图标中的媒体播放器图标。

矢量图形将被添加到设计支持库中，因此它可以在之前的 Android 版本中使用，不仅仅是 5.0 版本。

下一个组件可能不会包含在设计支持库中，因此我们需要考虑是否要根据 5.0 版本及以上版本的普及程度来决定是否使用它。无论如何，它值得解释，因为迟早它会因为其惊人的效果而被更广泛地看到。

使用 AnimatedVectorDrawable 进行动画处理

顾名思义，AnimatedVectorDrawable是一个带有动画的矢量图形，这是一个重要的特性。这些动画不仅仅是旋转、缩放、透明度等我们在之前的 Android 中见过的类型；这些动画还允许我们变换图形的pathData属性。这意味着我们可以有一个图形能够改变形状，或者转换成另一个图形。

这带来了无限多的 UI 可能性。例如，我们可以有一个播放按钮转换成一个不断旋转作为进度条的半圆，或者一个播放按钮变成暂停按钮。

我们可以定义传统的动画，比如旋转，如下所示：

<objectAnimator

  android:duration="6000"
  android:propertyName="rotation"
  android:valueFrom="0"
  android:valueTo="360" />

下面是如何定义从三角形到矩形的形状变换的方法：

<set
  >
  <objectAnimator
    android:duration="3000"
    android:propertyName="pathData"
    android:valueFrom="M300,70 l 0,-70 70,70 0,0   -70,70z"
      android:valueTo="M300,70 l 0,-70 70,0  0,140 -70,0 z"
    android:valueType="pathType"/>
</set>

要将它们组合在AnimatedVectorDrawable对象中，请执行以下代码：

<animated-vector

  android:drawable="@drawable/vectordrawable" >
  <target
    android:name="rotationGroup"
    android:animation="@anim/rotation" />
  <target
    android:name="v"
    android:animation="@anim/path_morph" />
</animated-vector>

这仅限于具有相同长度和相同命令长度的路径。

使用九宫格图像

在解释九宫格是什么之前，我将先展示它何时是必需的。如果我们正在开发一个消息应用程序，并且需要显示用户在聊天气泡中写入的内容，我们可以考虑创建TextView并将消息气泡的图像设置为背景。如果消息非常长，这就是在没有九宫格背景和有九宫格背景的情况下分别发生的情况。

我们可以看到第一张图片被拉伸了，看起来很糟糕；然而，我们并不希望拉伸边界。我们想要的是保持边界不变，但根据信息内容使文本区域变高或变宽。

九宫格图像是一种可以根据内容调整大小的图像，但它涉及留出一些无需拉伸的区域。它可以从 PNG 文件中的图像创建。基本上，它和 PNG 文件一样，只是在每个边上多了一个像素，并以.9.png扩展名保存。当我们将其放在drawable文件夹中时，Android 会知道在额外的像素中，有信息了解哪些区域需要拉伸，哪些不需要。

如果你观察图像，你会看到左侧和顶部额外的像素行用于指定哪些内容是可缩放的，底部和右侧的线条用于指定哪些空间可以被填充。我们希望完全填满盒子，但我们只想将左侧的某部分进行缩放。

Android 提供了一个工具来创建这些九宫格图像，你可以在 SDK 文件夹下的tools中找到它。只需打开draw9patch并将图像拖入其中。

内存管理

每个 Java 开发者都听说过垃圾回收器（GC）；这是一种自动为我们释放内存资源的机制。在某些情况下，我们可以防止垃圾回收器释放某些资源；如果资源持续增长，我们不可避免地会遇到OutOfMemoryError。

如果发生这种情况，我们需要定位泄漏并阻止它。在本节中，我们将了解如何定位问题的来源以及一系列防止这种情况发生的好习惯。

这不是只有在发生错误时才要关注的事情；我们的应用程序可能存在泄漏，这些泄漏不足以通过快速测试检测出来，但在内存堆较小的设备上可能导致错误。因此，在发布应用程序之前，对内存水平进行快速检查是很有好处的。

检测和定位泄漏

Android Studio 提供了一种快速检查内存状态的方法。在底部窗口中，你会在logcat和ADB日志旁边找到一个名为Memory的标签。

如果你点击我们称为垃圾回收器的小卡车图标，你会看到空闲内存如何增加。

不要将此作为空闲内存的参考，因为堆内存是动态的。这意味着堆内存最初可能是 64 MB；我们有 60 MB 已分配和 4 MB 空闲，但我们再分配 10 MB。堆内存可能会增长，最终我们会有一个 128 MB 的堆内存，其中 70MB 已分配和 58 MB 空闲。

要检测泄漏，我们需要获取已分配内存的引用。不断点击垃圾回收器，并在应用中导航，打开和关闭活动，加载图片，滚动列表，并多次执行这些操作。如果分配的内存持续增长且从不下降，这意味着我们在泄漏内存，阻止了一些资源的回收。我们可以大致确定泄漏发生在哪个活动或片段，因为我们将始终在相同点看到增长（假设我们不止有一个泄漏）。

要更精确地定位来源，我们需要使用Android 设备监视器：

选择你的应用进程，并点击更新堆内存：

选择此项后，我们可以看到对象的分配情况；如果出现位图或线程泄漏，这将是一个很好的线索：

如果我们仍然不清楚是什么在泄漏内存，可以点击转储 HPROF 文件按钮，并使用 Eclipse 的记忆分析工具MAT打开此文件。为此，我们将需要下载 Eclipse。

导入文件后，我们可以双击我们的进程，并点击列出对象，这将识别正在发生的情况。例如，我们可以看到活动中有多少对象以及使用了多少堆内存：

防止泄漏

比起修复内存泄漏，更好的做法是根本不让它发生。如果在开发过程中，我们牢记导致泄漏最常见的原因，这将为我们将来省去许多问题。

Activity 和上下文引用

Activity 的引用是这个问题的主要原因之一。将我们活动的引用发送给下载监听器或事件监听器是非常常见的。如果另一个对象持有我们活动的引用，这将阻止垃圾回收器释放我们的活动。例如，如果我们改变方向，我们的活动默认会再次创建，而具有旧方向的旧活动将被销毁。

记得在我们的 Activity 的onDestroy方法中取消监听器的订阅，并注意你发送 Context 的对象；这是我们 Activity 的强引用。

使用 WeakReference

在 Java 中创建对象时，默认情况下它是以强引用创建的。不同与 null 且具有强引用的对象不会被垃圾回收。

只包含弱引用的对象将在下一个周期被垃圾回收。同一个对象可以有多个引用；因此，如果我们需要临时使用一个对象，可以创建一个指向它的弱引用，当强引用被移除时，它将被垃圾回收。

这是一个包含在 Facebook SDK 源代码中的真实世界示例。他们创建了一个名为ToolTipPopup的自定义弹出窗口，它看起来类似于以下图片：

这个弹出窗口需要一个锚视图，这个锚视图是通过弱引用来引用的：

private final WeakReference<View> mAnchorViewRef;

这背后的原因是，在弹出窗口显示的时候，我们不再需要锚视图了。一旦弹出窗口显示，可以将锚视图设置为 null 或使其消失，这不会影响我们。因此，使用弱引用，如果原始锚视图被销毁并失去了其强引用，它也会在ToolTipPopup类中释放弱引用对象。

总结

在本章中，你学习了如何在不依赖任何第三方库的情况下下载图片，以理解它们的使用方法。对 Volley 和 Picasso 的概览使我们可以准备好实现任何处理完美的应用程序。我们还花了一些时间讨论了添加到我们应用程序中的图片，如矢量可绘制资源和九宫格图片。为了完成本章，我们还了解了如何管理应用程序中的内存问题，更重要的是，如何预防这些问题。

在下一章中，我们将创建一个 SQLite 数据库。我们将通过内容提供者导出这个数据库，并通过CursorLoader与内容提供者同步 UI 数据。

第八章：数据库和加载器

在本章中，我们将按照数据库契约创建一个 SQLite 数据库，并使用名为DAO（数据访问对象）的数据库执行读写操作。我们还将解释查询与原始查询之间的区别。

你将学习什么是内容提供者以及如何创建它，这将允许我们从CursorLoader访问这个数据库。我们将通过内容解析器访问内容提供者，同时查询数据库的不同表格，你将学会如何在内容提供者中使用联接查询。

使用CursorLoader ，我们可以通过创建一个机制来将列表视图与数据库同步，如果我们存储或修改数据库中的任何数据，这些更改将自动反映在我们的视图中。

最后，我们将添加流行的下拉刷新功能，以便按需更新内容。因此，在本章中，将涵盖以下主题：

• 创建数据库

  • 数据库契约

  • 数据库开放助手

  • 数据库访问对象

• 创建和访问内容提供者

  • 内容提供者

  • 内容解析器

• 同步数据库与 UI

  • CursorLoader

  • RecyclerView 和 CursorAdapter

• 下拉刷新

创建数据库

为了理解 Android 中的数据库是如何工作的，我们将继续在我们的示例应用MasteringAndroidApp上工作，创建一个数据库来存储工作机会，这些工作机会将用于在离线模式下查看内容。这意味着如果我们打开应用一次，工作机会将被保存在设备上，即使在没有互联网连接的情况下打开，我们也能看到信息。

在 Android 中有四种机制来持久化数据：

• 共享偏好设置：这些偏好设置用于以键值结构存储基本信息

• 内部存储：这种存储保存的是你应用私有的文件

• 外部存储：这种存储保存可以与其他应用共享的文件

• SQLite 数据库：这个基于流行的 SQL 的数据库允许我们以结构化的方式编写和读取信息

我们可以创建简单的结构，比如单表数据库，也可以创建包含多个表格的复杂结构。我们可以合并不同表格的输出以创建复杂的查询。

我们将创建两个表格，以展示如何使用内容提供者创建联接查询。

将有一个公司表格，包含公司 ID，一些关于它们的信息，如名称、网站、额外信息等。第二个表格将包含工作机会；这也需要包含一个带有公司 ID 的列。如果我们想要一个整洁的结构，而不是一个包含众多字段的大型表格，最好是将公司信息放在公司表格中，将工作机会放在工作表格中，只需引用公司即可。

为了清晰起见，也为了专注于 SQLite，我们不会改变 Parse 中的数据结构。因此，我们将下载内容并手动拆分公司和职位信息，将它们分别插入不同的表中。

我们的公司表将具有以下结构：

RowId	名称	图片链接
0	Yahoo	….
1	Google	…

rowId列是 Android 自动添加的，因此在创建表时我们不需要指定这个列。

下表是职位提供表：

RowId	标题	描述	薪水	地点	类型	Company_id
24	高级安卓开发..	2 倍开发者	55.000	英国伦敦	固定职位	1
25	初级安卓开发..	有经验的开发者	20.000	英国伦敦	固定职位	0

我们将创建一个视图，作为这两个表连接的结果；在这里，连接将基于company_id：

标题	描述	薪水	地点	类型	公司 ID	名称	图片链接
高级安卓开发	2 倍开发者..	55.000	英国伦敦	固定职位	1	Google	…
初级安卓开发	有经验的开发者	20.000	英国伦敦	固定职位	0	Yahoo	…

这个视图将允许我们获取所需的所有数据，每一行都包含完整信息。

数据库契约

数据库契约是一个类，我们在其中定义了数据库的名称以及所有表和列的名称作为常量。

它有两个目的：首先，它是一种一眼就能了解数据库结构的好方法。

要创建数据库包和DatabaseContract.java类，请使用以下代码：

public class DatabaseContract {

  public static final String DB_NAME = "mastering_android_app.db";

  public abstract class JobOfferTable {

    public static final String TABLE_NAME = "job_offer_table";

    public static final String TITLE = "title";
    public static final String DESC = "description";
    public static final String TYPE = "type";
    public static final String SALARY = "salary";
    public static final String LOCATION = "location";
    public static final String COMPANY_ID = "company_id";
  }

  public abstract class CompanyTable {

    public static final String TABLE_NAME = "company_table";

    public static final String NAME = "name";
    public static final String IMAGE_LINK = "image_link";
  }
}

其次，使用对常量的引用可以避免错误，并允许我们只更改常量值一次，并在整个应用程序中传播这个更改。

例如，在数据库中创建此表时，我们需要使用 SQL 语句CREATE TABLE "name"..；我们将要做的是使用契约中的表名，即CREATE TABLE DatabaseContract.CompanyTable.TABLE_NAME..。

数据库契约只是第一步。它不创建数据库；它只是一个我们用作模式的文件。要创建数据库，我们需要SQLiteOpenHelper的帮助。

数据库打开助手

打开助手是一个管理数据库创建和更新的类。更新是我们需要牢记的重要方面。考虑到我们将应用上传到 Play 商店，一段时间后，我们想要更改数据库的结构。例如，我们想要向表中添加一列，而不丢失之前版本用户在旧模式中存储的数据。将新版本上传到 Play 商店，当用户更新我们的应用时删除先前信息，这对用户体验来说是非常不好的。

为了知道何时需要更新数据库，我们有一个静态整数，其中包含数据库版本，如果我们更改数据库，需要手动增加这个版本，如下所示：

/**
* DATABASE VERSION
*/
private static final int DATABASE_VERSION = 1;

我们需要创建一个扩展 SQLiteOpenHelper 的 DatabaseOpenHelper 类。在扩展这个类时，要求我们实现两个方法：

@Override
public void onCreate(SQLiteDatabase db) {
  //Create database here
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  //Update database here
}

SQLiteOpenHelper 类在我们创建此类对象时会自动调用 onCreate 方法。但是，它仅在数据库尚未创建过且仅调用一次时这样做。同样，当我们将数据库版本升级时，它会调用 onUpgrade 方法。这就是为什么在我们创建此类对象时，需要传递带有数据库名和当前版本的参数：

public DBOpenHelper(Context context){
  super(context, DatabaseContract.DB_NAME, null, DATABASE_VERSION);
}

让我们从创建数据库开始；onCreate 方法需要在数据库上执行一条 SQL 语句来创建表：

db.execSQL(CREATE_JOB_OFFER_TABLE);
db.execSQL(CREATE_COMPANY_TABLE);

我们将把这些语句定义在静态变量中，如下所示：

/**
* SQL CREATE TABLE JOB OFFER sentence
*/
private static final String CREATE_JOB_OFFER_TABLE = "CREATE TABLE "
+ DatabaseContract.JobOfferTable.TABLE_NAME + " ("
+ DatabaseContract.JobOfferTable.TITLE + TEXT_TYPE + COMMA
+ DatabaseContract.JobOfferTable.DESC + TEXT_TYPE + COMMA
+ DatabaseContract.JobOfferTable.TYPE + TEXT_TYPE + COMMA
+ DatabaseContract.JobOfferTable.SALARY + TEXT_TYPE + COMMA
+ DatabaseContract.JobOfferTable.LOCATION + TEXT_TYPE + COMMA
+ DatabaseContract.JobOfferTable.COMPANY_ID + INTEGER_TYPE + " )";

默认情况下，Android 在每一行中创建一个 column_id 列，该列是唯一的且自动递增的；因此，在 companies 表中我们不需要创建列 ID。

如您所见，我们在变量中也有逗号和类型，以避免错误。直接编写语句时遗漏逗号或出错是很常见的，而且找出错误非常耗时：

/**
* TABLE STRINGS
*/
private static final String TEXT_TYPE = " TEXT";
private static final String INTEGER_TYPE = " INTEGER";
private static final String COMMA = ", ";

我们已经看到了如何创建我们的表，现在我们必须管理更新。在这种情况下，我们将简单地删除以前的信息并重新创建数据库，因为表中没有重要的信息。更新后打开应用时，它将再次下载职位信息并填充新数据库：

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  db.execSQL(DROP_JOB_OFFER_TABLE);
  db.execSQL(DROP_COMPANY_TABLE);
  onCreate(db);
}

/**
* SQL DELETE TABLE SENTENCES
*/
public static final String DROP_JOB_OFFER_TABLE = "DROP TABLE IF EXISTS "+ DatabaseContract.JobOfferTable.TABLE_NAME;
public static final String DROP_COMAPNY_TABLE = "DROP TABLE IF EXISTS "+ DatabaseContract.CompanyTable.TABLE_NAME;

我们类的完整版本将如下所示：

public class DBOpenHelper extends SQLiteOpenHelper {

  private static final int DATABASE_VERSION = 1;

  /**
  * TABLE STRINGS
  */
  private static final String TEXT_TYPE = " TEXT";
  private static final String INTEGER_TYPE = " INTEGER";
  private static final String COMMA = ", ";

  /**
  * SQL CREATE TABLE sentences
  */
  private static final String CREATE_JOB_OFFER_TABLE = "CREATE TABLE "
  + DatabaseContract.JobOfferTable.TABLE_NAME + " ("
  + DatabaseContract.JobOfferTable.TITLE + TEXT_TYPE + COMMA
  + DatabaseContract.JobOfferTable.DESC + TEXT_TYPE + COMMA
  + DatabaseContract.JobOfferTable.TYPE + TEXT_TYPE +

  COMMA       + DatabaseContract.JobOfferTable.SALARY + TEXT_TYPE +

  COMMA       + DatabaseContract.JobOfferTable.LOCATION + TEXT_TYPE +

  COMMA + DatabaseContract.JobOfferTable.COMPANY_ID +

  INTEGER_TYPE + " )";

  private static final String CREATE_COMPANY_TABLE = "CREATE TABLE "
  + DatabaseContract.CompanyTable.TABLE_NAME + " ("
  + DatabaseContract.CompanyTable.NAME + TEXT_TYPE + COMMA
  + DatabaseContract.CompanyTable.IMAGE_LINK + TEXT_TYPE +  " )";

  /**
  * SQL DELETE TABLE SENTENCES
  */
  public static final String DROP_JOB_OFFER_TABLE = "DROP TABLE IF EXISTS "+ DatabaseContract.JobOfferTable.TABLE_NAME;
  public static final String DROP_COMPANY_TABLE = "DROP TABLE IF EXISTS "+ DatabaseContract.CompanyTable.TABLE_NAME;

  public DBOpenHelper(Context context){
    super(context, DatabaseContract.DB_NAME, null, DATABASE_VERSION);
  }

  @Override
  public void onCreate(SQLiteDatabase db) {
    db.execSQL(CREATE_JOB_OFFER_TABLE);
    db.execSQL(CREATE_COMPANY_TABLE);
  }

  @Override
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    db.execSQL(DROP_COMPANY_TABLE);
    db.execSQL(DROP_JOB_OFFER_TABLE);
    onCreate(db);
  }
}

数据库访问对象

数据库访问对象，通常称为 DAO，是一个管理应用中所有数据库访问的对象。从概念上讲，它是介于数据库和我们的应用之间的一个类：

这是在 J2EE （Java 2 Enterprise Edition）服务器端通常使用的模式。在这种模式中，数据库实现可以被更改，并增加一层独立性，从而允许在不更改应用中的任何数据的情况下更改数据库实现。即使我们在 Android 中不更改数据库的实现（它始终是通过 SQLiteOpenHelper 获取的 SQLite 数据库），使用这种模式仍然是有意义的。从结构的角度来看，我们将在同一个地方拥有所有数据库访问操作。同时，将 DAO 作为单例对象，并使用同步方法，可以防止诸如同时从两个不同的地方尝试打开数据库的问题，如果我们正在写入，可能会被锁定。当然，从应用中的任何地方获取此单例的可能性也使得访问数据库变得非常容易。

在下一节中，我们将了解如何创建一个内容提供者，它可以替换我们的 DAO 对象；然而，如果我们只是想从数据库中存储和读取数据，实现内容提供者是非常繁琐的。让我们继续使用MasteringAndroidApp，创建一个名为MasteringAndroidDAO的类，它将存储工作机会和公司信息，并从数据库中显示信息，以便拥有一个离线工作的应用。

这个类将是单例模式，有两个公共的同步方法：一个用于存储工作机会（在工作机会表和公司表中），另一个用于读取。即使我们将信息分成两个表，读取时我们还会将其合并，以便我们可以继续使用当前适配器显示工作机会，而无需进行重大更改。通过这种方式，你将学会如何在查询中连接两个表。

如果一个方法是同步的，我们保证它不能同时从两个地方执行。因此，请使用以下代码：

public class MasteringAndroidDAO {

  /**
  * Singleton pattern
  */
  private static MasteringAndroidDAO sInstane = null;

  /**
  * Get an instance of the Database Access Object
  *
  * @return instance
  */
  public static MasteringAndroidDAO getInstance(){
    if (sInstane == null){
      sInstane = new MasteringAndroidDAO();
    }
    return sInstane;
  }

  public synchronized boolean storeOffers(Context context, List<JobOffer> offers){
    //Store offers
  }

  public synchronized List<JobOffer> getOffersFromDB(Context context){
    //Get offers
  }

}

我们将从storeOffers()方法开始。首先需要使用DatabaseOpenHelper打开数据库，然后我们需要在数据库中开始一个事务。我们将存储一个项目列表，因此为每个项目执行事务是没有意义的。如果我们打开一个事务，执行所有需要的插入操作，然后结束事务，批量提交所有更改，这样效率会更高：

try {
  SQLiteDatabase db = newDBOpenHelper(context).getWritableDatabase();

  db.beginTransaction();
  //insert single job offer
  db.setTransactionSuccessful();
  db.endTransaction();
  db.close();
} catch ( Exception e){
  Log.d("MasteringAndroidDAO",e.toString());
  return false;
}

提示

最后不要忘记使用db.close()关闭数据库。否则，它将保持打开状态并消耗资源，如果我们尝试再次打开它，将会得到一个异常。

如果我们只需要在单个表中插入数据，我们只需要创建一个ContentValue对象——一个基于我们想要存储的列构建的键值对象，并调用db.insert(contentValue)。然而，我们的例子稍微复杂一些。为了存储一个工作机会，我们需要知道公司 ID，而要获得这个 ID，我们需要询问数据库是否已经存储了该公司。如果没有，我们需要存储它并知道分配给它的 ID，因为如我们之前提到的，ID 是自动生成并增加的。

要找出公司是否已经在表中，我们需要执行一个查询，搜索所有行，看是否有任何行与我们要查找的公司名称相匹配。有两种执行查询的方法：query()和rawQuery()。

执行查询

查询需要以下参数：

• tableColumns：这是投影。我们可能想要返回整个表中我们希望在游标中返回的列。在这种情况下，它将是 null，等同于SELECT * FROM。或者，我们可能只想返回一列，new String[]{"column_name"}，甚至是一个原始查询。（这里，new String[]{SELECT ….}）。

• whereClause：通常使用"column_name > 5"条件；然而，如果参数是动态的，我们使用"column_name > ?"。问号用于指定参数的位置，这些参数将在下面的whereArgs参数中给出。

• whereArgs：这是where子句中的参数，将替换问号。

• groupBy（having，orderby和limit）：这些是其余的参数，如果不用可以设置为 null。

在我们的案例中，这就是我们询问数据库中是否存在某公司的操作方式。它将返回一个只包含一列游标，这正是我们获取 ID 所需：

Cursor cursorCompany = db.query(DatabaseContract.CompanyTable.TABLE_NAME,
  new String[]{"rowid"},
  DatabaseContract.CompanyTable.NAME +" LIKE ?",
  new String[]{offer.getCompany()},
  null,null,null);

使用QueryBuilder而不是rawQuery的好处是能够防止 SQL 注入。同时，它不容易出错。在性能方面，它并没有任何优势，因为它内部创建了rawQuery。

使用原始查询

原始查询只是一个带有 SQL 查询的字符串。在我们的示例中，它将是如下形式：

String queryString = "SELECT rowid FROM company_table WHERE name LIKE '?'"; 
Cursor c = sqLiteDatabase.rawQuery(queryString, whereArgs);

在大多数情况下，原始查询的可读性更强，实现所需的代码也较少。在这种情况下，有不良意图的用户可能会在whereArgs变量中添加更多的 SQL 代码以获取更多信息，产生错误或删除任何数据。它并不能防止 SQL 注入。

介绍游标

当我们调用query()或rawQuery()时，结果会以游标的形式返回。游标是包含许多用于访问和遍历它的方法的行集合。当不再使用时，它应该被关闭。

遍历游标最简短的方式是在循环中调用moveToNext()方法，该方法在没有下一个元素时会返回 false：

Cursor c = query….
while (c.moveToNext()) {
  String currentName = c.getString(c.getColumnIndex("column_name"));
}

要读取这些信息，我们有不同的方法，如getString()，它接收所需值列的索引。

要知道公司是否已经在表中，我们可以执行一个查询，这将返回一个只包含一列整数的 ID 的行集合。如果有结果，ID 将在索引为0的列中：

public int findCompanyId(SQLiteDatabase db, JobOffer offer){
  Cursor cursorCompany = db.query(DatabaseContract.CompanyTable.TABLE_NAME,
  new String[]{"rowid"},
  DatabaseContract.CompanyTable.NAME +" LIKE ?",
  new String[]{offer.getCompany()},
  null,null,null);

  int id = -1;

  if (cursorCompany.moveToNext()){
    id = cursorCompany.getInt(0);
  }
  return id;
}

另一个选项是将公司名称的列定义为唯一，并使用insertWithOnConflict指定忽略冲突。这样，如果公司已经存在于数据库中或刚刚被插入，它将返回 ID：

db.insertWithOnConflict(DATABASE_TABLE, null, initialValues, SQLiteDatabase.CONFLICT_IGNORE);

我们可以为查询创建一个方法，如果查询结果存在，则从游标中获取 ID。如果没有结果，则结果为-1。在存储工作机会之前，我们将检查公司是否存在。如果不存在，我们将存储公司，并在插入时返回 ID：

public boolean storeOffers(Context context, List<JobOffer> offers){

  try {
    SQLiteDatabase db = new DBOpenHelper(context).getWritableDatabase();

    db.beginTransaction();

    for (JobOffer offer : offers){

      ContentValues cv_company = new ContentValues();
      cv_company.put(DatabaseContract.CompanyTable.NAME, offer.getCompany());
      cv_company.put(DatabaseContract.CompanyTable.IMAGE_LINK,offer.getImageLink());

      int id = findCompanyId(db,offer);

      if (id < 0) {
        id = (int) db.insert(DatabaseContract.CompanyTable.TABLE_NAME,null,cv_company);
      }

      ContentValues cv = new ContentValues();
      cv.put(DatabaseContract.JobOfferTable.TITLE,offer.getTitle());
      cv.put(DatabaseContract.JobOfferTable.DESC,offer.getDescription());
      cv.put(DatabaseContract.JobOfferTable.TYPE, offer.getType());
      cv.put(DatabaseContract.JobOfferTable.DESC, offer.getDescription());
      cv.put(DatabaseContract.JobOfferTable.SALARY,offer.getSalary());
      cv.put(DatabaseContract.JobOfferTable.LOCATION,offer.getLocation());
      cv.put(DatabaseContract.JobOfferTable.COMPANY_ID,id);

      db.insert(DatabaseContract.JobOfferTable.TABLE_NAME,null,cv);
    }

    db.setTransactionSuccessful();
    db.endTransaction();

    db.close();

  } catch ( Exception e){
    Log.d("MasteringAndroidDAO", e.toString());
    return false;
  }

  return true;
}

在测试这个之前，理想的情况是准备好从数据库读取的方法，这样我们就可以检查是否所有内容都正确存储。我们的想法是同时查询这两个表，通过连接查询以获取包含我们所需所有字段的一个游标。

在 SQL 中，这将是一个如下的查询语句：SELECT * FROM job_offer_table JOIN company_table ON job_offer_table.company_id = company_table.rowid ...

我们需要使用数据库合约中表的名字来执行查询。以下是它将呈现的样子：

public List<JobOffer> getOffersFromDB(Context context){

  SQLiteDatabase db = new DBOpenHelper(context).getWritableDatabase();

  String join = DatabaseContract.JobOfferTable.TABLE_NAME + " JOIN " +
  DatabaseContract.CompanyTable.TABLE_NAME + " ON " +
  DatabaseContract.JobOfferTable.TABLE_NAME+"."+DatabaseContract.JobOfferTable.COMPANY_ID
  +" = " + DatabaseContract.CompanyTable.TABLE_NAME+".rowid";

  Cursor cursor = db.query(join,null,null,null,null,null,null);

  List<JobOffer> jobOfferList = new ArrayList<>();

  while (cursor.moveToNext()) {
    //Create job offer from cursor and add it
    //to the list
  }

  cursor.close();
  db.close();

  return jobOfferList;
}

下一步是从游标行创建一个工作机会对象，并将其添加到工作机会列表中：

while (cursor.moveToNext()) {

  JobOffer offer = new JobOffer();
  offer.setTitle(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.TABLE_NAME)));
  offer.setDescription(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.DESC)));
  offer.setType(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.TYPE)));
  offer.setSalary(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.SALARY)));
  offer.setLocation(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.LOCATION)));
  offer.setCompany(cursor.getString(cursor.getColumnIndex(DatabaseContract.CompanyTable.NAME)));
  offer.setImageLink(cursor.getString(cursor.getColumnIndex(DatabaseContract.CompanyTable.IMAGE_LINK)));

  jobOfferList.add(offer);
}

在这个例子中，当我们添加新数据时，我们将清除数据库。为此，我们将在MasteringAndroidDAO中创建一个方法：

/**
* Remove all offers and companies
*/
public void clearDB(Context context)
{
  SQLiteDatabase db = new DBOpenHelper(context).getWritableDatabase();
  // db.delete(String tableName, String whereClause, String[] whereArgs);
  // If whereClause is null, it will delete all rows.
  db.delete(DatabaseContract.JobOfferTable.TABLE_NAME, null, null);
  db.delete(DatabaseContract.CompanyTable.TABLE_NAME, null, null);
}

一旦数据库访问对象拥有了我们将需要所有方法，我们必须转向ListFragment并实现逻辑。理想的流程是首先显示数据库中的数据，并启动下载以获取新的工作机会。在后台，当更新完成时，将更新工作机会并刷新列表。我们将通过内容提供者和自动将数据库与列表视图连接的游标加载器来实现这一点。在这个例子中，为了测试 DAO，如果网络连接不可用，我们将简单地从数据库中显示数据，或者获取新的工作机会列表。当新列表下载完成后，我们将清除数据库并存储新的工作机会。

如果我们想要构建一个系统，该系统保存工作机会的历史记录，而不是清除数据库，我们需要做的是检查是否有来自服务器的新工作机会尚未存储在数据库中，并只保存新的工作机会。通过创建一个新的列，带有来自 Parse 的 ID，我们可以轻松地做到这一点，这样我们就可以使用唯一标识符比较工作机会。

为了检查是否有网络连接，我们将使用以下代码向连接管理器查询：

public boolean isOnline() {
  ConnectivityManager cm =
  (ConnectivityManager) getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
  NetworkInfo netInfo = cm.getActiveNetworkInfo();
  return netInfo != null && netInfo.isConnectedOrConnecting();
}

在onCreateView方法中，我们需要询问是否有连接。如果有连接，我们可以下载新的工作机会列表，该列表将显示并存储在数据库中，从而清除之前的工作机会：

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
  // Inflate the layout for this fragment
  View view = inflater.inflate(R.layout.fragment_list, container, false);

  mRecyclerView = (RecyclerView) view.findViewById(R.id.my_recycler_view);

  // use this setting to improve performance if you know that changes
  // in content do not change the layout size of the RecyclerView
  mRecyclerView.setHasFixedSize(true);

  // use a linear layout manager
  mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));

  //Retrieve the list of offers

  if (isOnline()){
    retrieveJobOffers();
  } else {
    showOffersFromDB();
  }

  return view;
}

public void retrieveJobOffers(){
  ParseQuery<JobOffer> query = ParseQuery.getQuery("JobOffer");
  query.findInBackground(new FindCallback<JobOffer>() {

    @Override
    public void done(List<JobOffer> jobOffersList, ParseException e) {
      MasteringAndroidDAO.getInstance().clearDB(getActivity());
      MasteringAndroidDAO.getInstance().storeOffers(getActivity(), jobOffersList);
      mListItems = MasteringAndroidDAO.getInstance().getOffersFromDB(getActivity());
      JobOffersAdapter adapter = new JobOffersAdapter(mListItems);
      mRecyclerView.setAdapter(adapter);
    }

  });
}

public void showOffersFromDB(){
  mListItems = MasteringAndroidDAO.getInstance().getOffersFromDB(getActivity());
  JobOffersAdapter adapter = new JobOffersAdapter(mListItems);
  mRecyclerView.setAdapter(adapter);
}

目前，我们将创建一个带有新元素列表的适配器。如果我们想要在屏幕上的列表视图中更新新的工作机会，并且我们使用这个方法，它将重新启动适配器，这将使列表在瞬间为空，并将滚动位置移到顶部。我们不应该创建一个适配器来刷新列表；现有的适配器应该更新元素列表。

要实现这一点，我们不得不在适配器中创建一个updateElements()方法，该方法将替换当前的工作机会列表，并调用notifiyDataSetChanged()，导致适配器刷新所有元素。如果我们确切知道更新了多少元素，我们可以使用notifyItemInserted()或notifyRangeItemInserted()来仅更新和动画新增的元素，这比notifyDataSetChanged()更有效。

没有必要手动将视图与数据同步。Android 为我们提供了CursorLoader，这是一种直接将列表视图与数据库连接的机制。因此，我们需要做的就是将新的工作机会存储在数据库中，列表视图将自动反映我们的更改。然而，所有这些自动化都有代价；它需要一个内容提供者才能工作。

内容提供者

内容提供者与 DAO 的概念非常相似；它是数据与应用程序之间的接口，允许不同的应用程序交换信息。我们可以决定它是公开的还是私有的，是否允许其他应用程序从中获取数据，以及它是否只在我们自己的应用程序内部使用。数据可以存储在数据库中，例如我们即将创建的数据库。它可以存储在文件中；例如，如果我们想要访问图库中的视频或图片，我们将使用 Android 内置的媒体内容提供者。或者，它也可以从网络获取：

内容提供者必须在清单文件中声明，因为它是我们应用程序的一个组件，并且要指定它是否可以被其他应用程序访问，这是由 exported 属性控制的。让我们从创建我们自己的内容提供者开始。

要创建一个内容提供者，请创建一个MAAProvider类并继承ContentProvider。系统将要求我们实现以下方法：

public class MAAProvider extends ContentProvider {

  @Override
  public boolean onCreate() {
    return false;
  }

  @Override
  public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
    return null;
  }

  @Override
  public Uri insert(Uri uri, ContentValues values) {
    return null;
  }

  @Override
  public int delete(Uri uri, String selection, String[] selectionArgs) {
    return 0;
  }

  @Override
  public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
    return 0;
  }

  @Override
  public String getType(Uri uri) {
    return null;
  }
}

OnCreate方法将在提供者启动时被调用；它将初始化提供者工作所需的所有元素。提供者将在应用程序启动时同时启动。系统知道要启动哪个提供者，因为这在清单文件中定义了。接下来的四个方法是访问和管理数据的方法。最后一个方法返回对象的 MIME 类型。

如我们之前提到的，手机中有不同的内容提供者可供使用；例如，我们可以通过内容提供者访问短信、联系人或媒体库中的项目。因此，必须有方法来识别和访问它们每一个。这是通过URI（统一资源标识符）实现的，它类似于我们在浏览器中访问网站时使用的 URL。

URI 由前缀"content://"、一个称为权限的字符串标识组成。它通常是类名加上包名"com.packtpub.masteringandoridapp.MAAProvider"，然后是一个斜杠和表名，例如"/company_table"。还可以选择性地在表内行的编号后面加上斜杠"/2"。

因此，公司表的完整 URI 将是"content://com.packtub.masteringandroidapp.MAAProvider/company_table"。

带有 ID 编号 2 的公司的完整 URI 将是"content://com.packtub.masteringandroidapp.MAAProvider/company_table/2"。这个 URI 在一般情况下可以表示为company_table/#，其中#将被一个整数替换。

鉴于我们有两个不同的表和一个通过连接得到的第三个表（可以访问以获取表中的所有元素或获取单行数据），我们有六个可能的 URI：

• content://com.packtub.masteringandroidapp.MAAProvider/company_table

• content://com.packtub.masteringandroidapp.MAAProvider/company_job_offer

• content://com.packtub.masteringandroidapp.MAAProvider/offer_join_company

• content://com.packtub.masteringandroidapp.MAAProvider/company_table/#

• content://com.packtub.masteringandroidapp.MAAProvider/company_job_offer/#

• content://com.packtub.masteringandroidapp.MAAProvider/offer_join_company/#

我们只有一个内容提供者；理论上，这个提供者可以为所有六个 URI 实现query、insert、update、delete和getType方法，每个方法都有六种不同的实现。因此，当执行myMAAProvider.insert(URI …)时，我们需要有一个if语句来查看哪个表需要插入，并选择正确的实现。这会是类似这样的：

@Override
public Uri insert(Uri uri, ContentValues values) {
  if (uri.equals("content://com.packtub.masteringandroidapp.MAAProvider/company_table")){
    //Do an insert in company_table
} else if (uri.equals("content://com.packtub.masteringandroidapp.MAAProvider/offer_table")){
//Do an insert in offer table
} else if ... {
  .
  .
  .
}
}

通过比较字符串，您可以看出这看起来不太对，如果我们添加一个带有整数结尾的 URI，我们需要有一种机制来验证"company_table/2"是否与通用 URI"company_table/#"相对应。这就是我们有UriMatcher的原因。UriMatcher将包含与整数相关联的可能 URL 列表。因此，当它接收到一个 URI 时，它会告诉我们使用哪个整数以及使用字符串模式。

创建UriMatcher并定义所有可能的情况后，我们只需将可能的情况添加到UriMatcher中，并调用UriMatcher.match(Uri uri)，这将返回带有情况的整数。我们需要做的就是切换以检查我们处于哪种情况：

public class MAAProvider extends ContentProvider {

  public final String authority = "com.packtpub.masteringandroidapp.MAAProvider";

  private UriMatcher mUriMatcher;

  private static final int COMPANY_TABLE = 0;
  private static final int COMPANY_TABLE_ROW = 1;
  private static final int OFFER_TABLE = 2;
  private static final int OFFER_TABLE_ROW = 3;
  private static final int JOIN_TABLE = 4;
  private static final int JOIN_TABLE_ROW = 5;

  @Override
  public boolean onCreate() {
    mUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    mUriMatcher.addURI(authority,DatabaseContract.CompanyTable.TABLE_NAME,COMPANY_TABLE);
    mUriMatcher.addURI(authority,DatabaseContract.CompanyTable.TABLE_NAME+"/#",COMPANY_TABLE_ROW);
    mUriMatcher.addURI(authority,DatabaseContract.JobOfferTable.TABLE_NAME,OFFER_TABLE);
    mUriMatcher.addURI(authority,DatabaseContract.JobOfferTable.TABLE_NAME+"/#",OFFER_TABLE_ROW);
    mUriMatcher.addURI(authority,DatabaseContract.OFFER_JOIN_COMPANY,JOIN_TABLE);
    mUriMatcher.addURI(authority,DatabaseContract.OFFER_JOIN_COMPANY+"/#",JOIN_TABLE_ROW);

    mDB = new DBOpenHelper(getContext()).getWritableDatabase();

    return true;
  }

  @Override
  public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
    switch (mUriMatcher.match(uri)){
      case COMPANY_TABLE:
      //Query company table
      break;
      case COMPANY_TABLE_ROW:
      //Query company table by id
      break;
      .
      .

我们可以开始实现查询方法，以获取与公司合并的优惠列表，并将其设置到适配器中，以检查到目前为止一切是否运行良好。我们需要有以下几个与数据库有关的变量：

private SQLiteDatabase mDB;

这将在onCreate中如下分配：

mDB = new DBOpenHelper(getContext()).getWritableDatabase();

同时，在查询方法中，我们需要为六种可能性创建一个查询，如下所示：

@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
  switch (mUriMatcher.match(uri)){
    case COMPANY_TABLE:
    return mDB.query(DatabaseContract.CompanyTable.TABLE_NAME, projection,selection,selectionArgs,null,null,sortOrder);
    case COMPANY_TABLE_ROW:
    selection = "rowid LIKE "+uri.getLastPathSegment();
    return mDB.query(DatabaseContract.CompanyTable.TABLE_NAME, projection,selection,selectionArgs,null,null,sortOrder);
    case OFFER_TABLE:
    return mDB.query(DatabaseContract.JobOfferTable.TABLE_NAME, projection,selection,selectionArgs,null,null,sortOrder);
    case OFFER_TABLE_ROW:
    selection = "rowid LIKE "+uri.getLastPathSegment();
    return mDB.query(DatabaseContract.JobOfferTable.TABLE_NAME, projection,selection,selectionArgs,null,null,sortOrder);
    case JOIN_TABLE:
    return mDB.query(DBOpenHelper.OFFER_JOIN_COMPANY, projection,selection,selectionArgs,null,null,sortOrder);
    case JOIN_TABLE_ROW:
    selection = "rowid LIKE "+uri.getLastPathSegment();
    return mDB.query(DBOpenHelper.OFFER_JOIN_COMPANY, projection,selection,selectionArgs,null,null,sortOrder);
  }
  return null;
}

我们需要用以下定义的DBOpenHelper.OFFER_JOIN_COMPANY变量这样做：

public static final String OFFER_JOIN_COMPANY = DatabaseContract.JobOfferTable.TABLE_NAME + " JOIN " +
DatabaseContract.CompanyTable.TABLE_NAME + " ON " +
DatabaseContract.JobOfferTable.TABLE_NAME+"."+DatabaseContract.JobOfferTable.COMPANY_ID
+" = " + DatabaseContract.CompanyTable.TABLE_NAME+".rowid";Content Resolver

要访问内容提供者，我们将使用ContentResolver。这是一个通用实例，它提供了对所有可用的内容提供者的访问权限以及 CRUD 操作（创建、读取、更新和删除）：

ContentResolver cr = getContentResolver();

要使用内容解析器，我们需要一个指向内容提供者的 URI。我们可以在调用之前从字符串变量中创建它：

Uri uriPath = Uri.parse("content://"+MAAProvider.authority + "/" + DatabaseContract.OFFER_JOIN_COMPANY);
Cursor cursor = cr.query(uriPath, null, null, null, null);

另外，我们可以在提供者中将 URI 列表定义为静态变量，以便访问它们。

如果我们现在尝试运行这段代码，我们会得到错误，'failed to find provider info for com.packtub.masteringandroidapp.MAAProvider'。这意味着系统找不到提供者，因为我们还没有将其添加到清单中。

要添加提供者，我们需要在<application>标签内添加<provider>元素；它需要我们提供者的路径和名称以及权限。在我们的情况下，这两者是相同的：

.
.
.
    <activity
        android:name=".OfferDetailActivity"
        android:label="@string/title_activity_offer_detail" >
    </activity>
    <provider android:name="com.packtpub.masteringandroidapp.MAAProvider"
        android:authorities="com.packtpub.masteringandroidapp.MAAProvider">
    </provider>
</application>

即使我们使用CursorLoader显示数据，并且没有使用工作机会的内容列表，创建一个临时方法来显示内容提供者中的工作机会列表也不是一个坏主意。这有助于确保在深入CursorLoader的道路之前，内容提供者是可访问的并返回预期数据：

public void showOffersFromContentProvider(){
  ContentResolver cr = getActivity().getContentResolver();
  Uri uriPath = Uri.parse("content://"+MAAProvider.authority + "/" + DatabaseContract.OFFER_JOIN_COMPANY);
  Cursor cursor = cr.query(uriPath, null, null, null, null);

  List<JobOffer> jobOfferList = new ArrayList<>();
  while (cursor.moveToNext()) {

    JobOffer offer = new JobOffer();
    offer.setTitle(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.TITLE)));
    offer.setDescription(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.DESC)));
    offer.setType(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.TYPE)));
    offer.setSalary(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.SALARY)));
    offer.setLocation(cursor.getString(cursor.getColumnIndex(DatabaseContract.JobOfferTable.LOCATION)));
    offer.setCompany(cursor.getString(cursor.getColumnIndex(DatabaseContract.CompanyTable.NAME)));
    offer.setImageLink(cursor.getString(cursor.getColumnIndex(DatabaseContract.CompanyTable.IMAGE_LINK)));

    jobOfferList.add(offer);
  }
  JobOffersAdapter adapter = new JobOffersAdapter(jobOfferList);
  mRecyclerView.setAdapter(adapter);
}

通过将showOffersFromDB()的调用替换为showOffersFromContentProvider()，我们应当能够以相同的顺序看到完全相同的信息：

if (isOnline()){
  retrieveJobOffers();
} else {
  showOffersFromContentProvider();
}

一旦创建了提供者，CursorLoader对象就可以很容易地实现。在这个阶段，我们可以认为大部分工作已经完成。

将数据库与用户界面同步

当我们使用CursorLoader与内容提供者配合时，游标返回的数据与数据库中的数据直接关联，这样数据库中的任何更改都会立即反映在用户界面上。当我们拥有这套系统运行时，我们只需要关心将数据存储在数据库中以及更新数据。当我们准备好这套系统后，我们将讨论如何实现流行的下拉刷新系统，以在用户需要时更新工作机会。目标是在 Parse 中添加新的工作机会，下拉列表刷新，并立即看到新元素的到来，所有这些都在后台通过内容提供者处理。

实现CursorLoader

为了完成这个目标，下一步是创建CursorLoader。我们之前在书中讨论过加载器；正如我们提到的，它们是在后台加载数据的机制。这个特定的加载器将返回游标中的数据，并从内容提供者中加载。它还在检测到源中的任何更改时刷新数据。

要开始使用CursorLoader，我们的活动或片段—在我们的案例中是FragmentList—需要实现LoaderManager.LoaderCallback<Callback>。这个接口将要求我们实现以下方法：

public class ListFragment extends android.support.v4.app.Fragment implements LoaderManager.LoaderCallbacks<Cursor>

@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args) {
  return null;
}

@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {

}

@Override
public void onLoaderReset(Loader<Cursor> loader) {

}

让我们从第一个方法开始—onCreateLoader。这个方法接收一个整数 ID 作为参数，这将是我们的加载器的 ID。我们可以在同一个活动中拥有多个加载器，因此我们将为它们分配 ID 以便能够识别它们。我们的加载器将定义为：

public static final int MAA_LOADER = 1;

当我们告诉LoaderManager初始化我们的加载器时，将执行OnCreateLoader方法。这可以在onCreateView()中完成：

getLoaderManager().initLoader(MAA_LOADER, null, this);

这个方法必须创建所有可以初始化的不同加载器（它们可以是不同类型的加载器）；在我们的案例中，我们只有一个，那就是CursorLoader。它将查询表并将工作机会的表与公司的表连接起来作为结果。带有内容 URI 的字符串之前已在MAAProvider中定义：

public static final String JOIN_TABLE_URI =  "content://" + MAAProvider.authority + "/" + DatabaseContract.OFFER_JOIN_COMPANY;
@Override
public Loader<Cursor> onCreateLoader(int loaderID, Bundle bundle)
{
  switch (loaderID) {
    case MAA_LOADER:
    return new CursorLoader(
    getActivity(),   // Parent activity context
    Uri.parse(MAAProvider.JOIN_TABLE_URI),
    // Table to query
    null,            // Projection to return
    null,            // No selection clause
    null,            // No selection arguments
    null             // Default sort order
    );
    default:
    //Invalid ID
    return null;
  }
}

当我们告诉加载器管理器初始化我们的加载器时，它会自动创建并开始运行到数据库的查询；异步地，它会调用我们实现的第二个方法，即onLoadFinished。在这个方法中，例如，我们可以检索游标并显示数据，就像我们之前从内容解析器获取游标时所做的那样。通过将我们从课程中创建职位信息的代码移动到JobOffer类的静态方法中，我们的onLoadFinished方法将类似于以下内容：

@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {

  List<JobOffer> jobOfferList = new ArrayList<>();

  while (cursor.moveToNext()) {
    jobOfferList.add(JobOffer.createJobOfferfromCursor(cursor));
  }

  JobOffersAdapter adapter = new JobOffersAdapter(jobOfferList);
  mRecyclerView.setAdapter(adapter);
}

这个解决方案在后台查询数据库，并异步显示结果，但它还远非完美。我们将遍历游标来创建一个对象列表，在这之后，我们会将这个列表发送给适配器，适配器会再次遍历这个列表来创建元素。如果我们有一个能直接从游标构建列表的适配器会怎样呢？我们问题的解决方案已经存在，它就是CursorAdapter。但在转向使用这个之前，我们需要实现第三个方法，这个方法目前还未完成。

第三个方法，onLoaderReset，在数据无效时被调用。例如，如果数据源改变了，这种情况就可能发生。它移除了对游标的引用，防止内存泄漏，并且通常与CursorAdapter一起使用。这是三个方法中最容易实现的。在我们的示例中，我们可以让它为空；因为我们不会在方法外部使用游标，所以不会有内存泄漏。如果我们使用CursorAdapter，那么在onLoadFinished方法外部会有一个对它的引用，我们需要将适配器设置为null：

@Override
public void onLoaderReset(Loader<Cursor> loader) {
  //mAdapter.changeCursor(null);
}

RecyclerView和CursorAdapter

CursorAdapter类基于游标创建适配器，用于与ListsView配合使用。它继承自BaseAdapter。

传递给适配器的游标必须有一个名为_id的列。为此，我们不需要更改我们的数据库；我们可以在创建CursorLoader时，简单地将rowid字段重命名为_id。

这是一个基本的CursorAdapter的示例：

SimpleCursorAdapter mAdapter =
new SimpleCursorAdapter(
  this,                // Current context
  R.layout.list_item,  // Layout for a single row
  null,                // No Cursor yet
  mFromColumns,        // Cursor columns to use
  mToFields,           // Layout fields to use
  0                    // No flags
);

创建后，我们可以在onLoadFinished中传递给它新的游标：

mAdapter.changeCursor(cursor);

如果你正在使用ListView，这个解决方案是完美的；不幸的是，RecyclerView使用RecyclerView.Adapter，并且与BaseAdapter不兼容。因此，CursorLoader类不能与RecyclerViews一起使用。

在这一点上，我们有两个选择：一个是寻找开源解决方案，例如CursorRecyclerAdapter（gist.github.com/quanturium/46541c81aae2a916e31d#file-cursorrecycleradapter-java）并将这个类包含在我们的应用程序中。

第二个选项是创建我们自己的适配器。为此，我们将创建一个名为JobOfferCursorAdapter的类，它继承自RecyclerView.Adapter<JobOffersAdapter.MyViewHolder>。这个类与JobOfferAdapter一样，将具有onCreateView和onBindView方法。它们的实现方式相同，除了职位信息在光标中而不是列表中。为了从光标行获取JobOffer，我们将创建一个名为getItem(int position)的额外方法。除此之外，我们还需要getCount方法，它将返回光标的大小，以及一个changeCursor方法，它将允许我们在适配器中更改光标。请看以下代码：

public class JobOfferCursorAdapter extends RecyclerView.Adapter<JobOfferCursorsAdapter.MyViewHolder>{

  Cursor mDataCursor;

  @Override
  public int getItemCount() {
    return (mDataCursor == null) ? 0 : mDataCursor.getCount();
  }

  public void changeCursor(Cursor newCursor) {
    //If the cursors are the same do nothing
    if (mDataCursor == newCursor){
      return;
    }

    //Swap the cursors
    Cursor previous = mDataCursor;
    mDataCursor = newCursor;

    //Notify the Adapter to update the new data
    if (mDataCursor != null){
      this.notifyDataSetChanged();
    }

    //Close previous cursor
    if (previous != null) {
      previous.close();
    }
  }

  private JobOffer getItem(int position) {
    //To be implemented
    return null;
  }

  @Override
  public JobOfferCursorAdapter.MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    //To be implemented
    return null;
  }

  @Override
  public void onBindViewHolder(MyViewHolder holder, int position) {
    //To be implemented
  }

  private class MyViewHolder..

}

getItem方法需要从光标中的一行获取Joboffer。为此，我们首先需要使用moveToPosition(int position)方法将光标移动到这个位置，之后，我们可以提取这一行的值：

private Object getItem(int position) {
  mDataCursor.moveToPosition(position);
  return JobOffer.createJobOfferfromCursor(mDataCursor);
}

准备好这个方法后，我们可以根据之前的JobOffersAdapter在适配器上实现其他功能：

@Override
public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
  View v = LayoutInflater.from(parent.getContext()).inflate(R.layout.row_job_offer, parent, false);
  return new MyViewHolder(v);
}

@Override
public void onBindViewHolder(JobOfferCursorAdapter.MyViewHolder holder, int position) {
  JobOffer jobOffer =  getItem(position);
  holder.textViewName.setText(jobOffer.getTitle());
  holder.textViewDescription.setText(jobOffer.getDescription());
}

public class MyViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener{

  public TextView textViewName;
  public TextView textViewDescription;

  public  MyViewHolder(View v){
    super(v);
    textViewName = (TextView)v.findViewById(R.id.rowJobOfferTitle);
    textViewDescription = (TextView)v.findViewById(R.id.rowJobOfferDesc);
    v.setOnClickListener(this);
  }

  @Override
  public void onClick(View view) {
    Intent intent = new Intent(view.getContext(), OfferDetailActivity.class);
    JobOffer selectedJobOffer = getItem(getAdapterPosition());
    intent.putExtra("job_title", selectedJobOffer.getTitle());
    intent.putExtra("job_description",selectedJobOffer.getDescription());
    intent.putExtra("job_image",selectedJobOffer.getImageLink());
    view.getContext().startActivity(intent);
  }
}

当我们自己的适配RecyclerView的CursorAdapter完成后，我们就可以创建光标并在加载器管理器完成时设置适当的光标了。在OncreateView中，我们将从服务器检索新数据，同时用当前数据更新视图：

mAdapter = new JobOfferCursorAdapter();
mRecyclerView.setAdapter(mAdapter);

getLoaderManager().initLoader(MAA_LOADER, null, this);

retrieveJobOffers();

return view;

为了显示数据，我们将在加载器管理器完成后更改光标：

@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
  Log.d("ListFragment", "OnLoader Finished :" + cursor.getCount());
  mAdapter.changeCursor(cursor);
}

@Override
public void onLoaderReset(Loader<Cursor> loader) {
  mAdapter.changeCursor(null);
  Log.d("ListFragment", "OnLoader Reset :");
}

当数据库中已有先前数据时，这个方法工作得很好。但是，如果我们尝试卸载应用然后第一次运行它，我们会发现列表是空的。同时，查看日志，我们可以看到我们在后台正确地存储了新的职位信息：

07-25 16:45:42.796  32059-32059/com.packtpub.masteringandroidapp D/ListFragment﹕ OnLoader Finished :0
07-25 16:45:43.507  32059-32059/com.packtpub.masteringandroidapp D/ListFragment﹕ Storing offers :7

这里发生的情况是，我们数据库中的变化目前没有被检测到，但当我们使用CursorLoaders时，这个问题很容易解决。无需手动注册内容观察者或重新启动加载器；我们可以在光标中设置一个CursorLoader使用的监听器，并在数据库中进行任何更改时通知它。在我们的提供者中，我们可以将通知 URI 设置为光标：

case JOIN_TABLE:
Cursor cursor =  mDB.query(DBOpenHelper.OFFER_JOIN_COMPANY, projection,selection,selectionArgs,null,null,sortOrder);
cursor.setNotificationUri(getContext().getContentResolver(), uri);
return cursor;

每当数据库发生变化时，我们可以调用：

Context.getContentResolver().notifyChange(Uri.parse(MAAProvider.JOIN_TABLE_URI), null);

因此，CursorLoader将自动刷新列表。如果我们是从内容提供者中进行插入、更新或删除操作，我们可以在这些操作之前加上这一行来通知任何内容变化。在我们的示例中，我们只需在从 Parse 接收到的新数据存储到数据库后手动添加即可。你可以使用以下代码实现这个功能：

public void done(List<JobOffer> jobOffersList, ParseException e) {
  Log.d("ListFragment","Storing offers :"+jobOffersList.size());
  MasteringAndroidDAO.getInstance().clearDB(getActivity());
  MasteringAndroidDAO.getInstance().storeOffers(getActivity(), jobOffersList);
  getActivity().getContentResolver().notifyChange(Uri.parse (MAAProvider.JOIN_TABLE_URI), null);
}

现在我们可以卸载应用然后重新安装，我们会发现当职位信息在后台下载时列表会空几秒钟。下载一完成，光标加载器就会刷新列表，所有职位信息都会出现。为了锦上添花，我们将实现下拉刷新功能。

引入通过 SwipeRefreshLayout 下拉刷新功能

通过这个功能，用户可以在列表视图处于顶部时向上滚动，随时刷新列表。这是在如 Gmail 和 Facebook 等应用中常见的流行功能。

为了实现这个功能，Google 发布了一个名为SwipeRefreshLayout的组件，它包含在 v4 支持库中。在此库的修订版 21之前，这显示为屏幕顶部的水平线，颜色会变化。后来，它被改为一个随着下拉动作旋转的半圆形的圆形。

要使用这个功能，我们需要在视图中用这个元素包裹我们的列表：

<android.support.v4.widget.SwipeRefreshLayout  android:id="@+id/swipeRefreshLayout" android:layout_width="match_parent" android:layout_height="match_parent">
  <android.support.v7.widget.RecyclerView android:id="@+id/my_recycler_view" android:scrollbars="vertical" android:layout_width="match_parent" android:layout_height="match_parent" />
</android.support.v4.widget.SwipeRefreshLayout>

我们可以创建一个名为mSwipeRefreshLayout的类变量，并设置一个onRefresh监听器，当用户想要刷新时会被调用：

mSwipeRefreshLayout = (SwipeRefreshLayout) view.findViewById(R.id.swipeRefreshLayout);
mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
  @Override
  public void onRefresh() {
    retrieveJobOffers();
  }
});

当数据下载完成后，我们需要调用setRefresh，并传递false值以停止圆圈无限旋转：

@Override
public void done(List<JobOffer> jobOffersList, ParseException e) {
  Log.d("ListFragment","Storing offers :"+jobOffersList.size());
  MasteringAndroidDAO.getInstance().clearDB(getActivity());
  MasteringAndroidDAO.getInstance().storeOffers(getActivity(), jobOffersList);
  getActivity().getContentResolver().notifyChange(Uri.parse(MAAProvider.JOIN_TABLE_URI), null);
  mSwipeRefreshLayout.setRefreshing(false);
}

在刷新时，它应该类似于以下截图：

我们还可以在使用SwipeRfreshLayout和setColorScheme()方法旋转时改变箭头的颜色。只需在 XML 中定义三种颜色，并设置三种不同颜色的 ID：

<resources>
  <color name="orange">#FF9900</color>
  <color name="green">#009900</color>
  <color name="blue">#000099</color> 
</resources>

setColorSchemeResources(R.color.orange, R.color.green, R.color.blue);

我们已经实现了我们的目标。有一个简单的方法可以测试整个系统是否工作正常，从SwipeToRefreshLayout到后台的 Parse 请求，内容提供者，数据库以及游标加载器。我们可以打开应用，在列表界面时，去 Parse 创建一个新的工作机会，然后返回应用，并下拉刷新。在刷新后，我们应该能看到新的工作机会出现。

总结

在本章中，你学习了如何创建数据库，使用数据库契约和数据库打开助手。我们了解了 DAO 的模式，并使用它进行了基本操作。此外，我们还用内容提供者替换了 DAO，解释了 URI 匹配器是如何工作的，并通过内容解析器访问它。

这使得我们可以使用CursorLoader与我们自己实现的兼容RecyclerView的CursorAdapter，以实现与数据库同步的 UI 系统。为了完成本章，我们学习了如何使用流行的下拉刷新功能按需更新内容。

在下一章中，我们将了解如何向我们的应用程序添加推送通知以及分析服务，并概述当前市场上可用的分析服务和推送通知选项之间的差异。

第九章：推送通知和分析

我们将从讨论推送通知开始本章。你将学习如何使用 Google Cloud Messaging 实现带通知的自定义解决方案，包括服务器端和应用程序端。然后，我们将在示例中添加 Parse 的通知。最后，我们将使用NotificationCompat显示自定义通知来结束通知部分。

在本章的后半部分，我们将讨论分析。拥有分析工具来追踪用户在我们应用中的行为对于了解用户的行为模式至关重要，这使我们能够识别模式并改善用户体验。我们将使用 Parse 实现一个示例，并概述市场上最受欢迎的解决方案。

• 推送通知

  • 使用 GCM 发送和接收

  • 来自 Parse 的通知

  • NotificationCompat

• 分析

  • 使用 Parse 的分析

• 错误报告

推送通知

推送通知对于吸引用户并提供实时更新非常重要。它们有助于提醒用户有待处理的事项。例如，在万事达卡创建的Qkr!应用中，用户可以在一些餐厅点餐点饮料，如果用户在一段时间后仍未付款，系统会发送通知提醒用户在离开餐厅前需要付款。

当我们需要告诉用户我们有新内容或者其他用户给他们发送了消息时，它们也非常有效。任何在服务器端发生的变化并且需要通知用户的情况都是使用通知的完美场景。

通知也可以从我们自己的应用程序本地发送；例如，我们可以设置一个闹钟并显示通知。它们不一定非要从服务器发送。

它们显示在屏幕顶部的状态栏中，这个地方被称为通知区域。

通知所需的最少信息包括一个图标、一个标题和详细文本。随着材料设计的到来，我们可以以不同方式自定义通知；例如，我们可以为它们添加不同的操作：

如果我们从屏幕顶部向下滚动，将会显示通知抽屉，我们可以在其中看到所有通知显示的信息：

通知不应作为双向通道通信的一部分。如果我们的应用需要与服务器持续通信，如即时通讯应用的情况，我们应该考虑使用套接字、XMPP 或任何其他消息传递协议。理论上，通知是不可靠的，我们无法控制它们何时会被确切接收。

然而，不要滥用通知；这是用户卸载你应用的一个很好的理由。尽量将通知数量降到最低，只在必要时使用。

你可以为通知分配一个优先级，从 Android Lollipop 开始，你可以根据这个优先级过滤你想接收的通知。

这些是处理通知时你应该记住的关键点和概念。在深入了解更多理论知识之前，我们将练习向我们的应用发送通知。

使用 GCM 发送和接收通知

市场上有很多不同的解决方案用于发送推送通知；其中一个是 Parse，它有一个友好的控制面板，任何人都可以轻松地发送推送通知。我们将以 Parse 为例，但首先，了解其内部工作原理以及如何构建我们自己的通知发送系统是有好处的。

GCM（Google Cloud Messaging）使用推送通知，我们将这些通知发送到我们的手机。谷歌有一些称为 GCM 连接服务器的服务器来处理这个过程。如果我们想发送推送通知，首先需要告诉这些服务器，然后它们会在稍后发送到我们的设备。我们需要创建一个服务器或使用第三方服务器，通过 HTTP 或 XMPP 与 GCM 服务器通信，因为可以使用这两种协议进行通信。

如我们之前所述，由于我们无法控制 GCM 服务器，因此不能精确控制消息的接收时间。GCM 服务器会将消息排队并在设备在线时发送。

要创建我们自己的解决方案，首先需要在 Google 开发者网站上的我们的应用中启用消息传递服务：developers.google.com/mobile/add?platform=android。

创建应用后，启用 GCM 消息传递，系统会提供发送者 ID 和服务器 API 密钥。发送者 ID 之前被称为项目编号。

如果我们想接收 GCM 消息，我们需要将我们的客户端（即我们的移动应用）注册到这个项目。为此，我们的应用将使用 GCM API 进行注册并获得一个令牌作为确认。完成此操作后，GCM 服务器将知道你的设备已准备好接收来自这个特定项目/发送者的推送通知。

我们需要添加游戏服务以使用此 API：

 compile "com.google.android.gms:play-services:7.5.+"

通过实例 ID API 进行注册，调用instanceID.getToken方法，并将SenderID作为参数：

InstanceID instanceID = InstanceID.getInstance(this);
String token = instanceID.getToken(getString(R.string.gcm_defaultSenderId),
GoogleCloudMessaging.INSTANCE_ID_SCOPE, null);

我们需要异步调用此方法，并在我们的应用中保持一个布尔变量，以记住我们是否已成功注册。我们的令牌可能会随时间变化，当变化发生时，我们会通过onRefreshToken()回调得知。令牌需要发送到我们的服务器：

@Override
public void onTokenRefresh() {
  //Get new token from Instance ID with the code above
  //Send new token to our Server
}

完成这些后，我们需要创建一个GCMListener并在 Android 清单中添加一些权限：

<uses-permission android:name="android.permission.GET_ACCOUNTS" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />

<permission android:name="com.example.gcm.permission.C2D_MESSAGE"
  android:protectionLevel="signature" />
<uses-permission android:name="com.example.gcm.permission.C2D_MESSAGE" />

<application ...>
  <receiver
    android:name="com.google.android.gms.gcm.GcmReceiver"
    android:exported="true"
    android:permission="com.google.android.c2dm.permission.SEND" >
    <intent-filter>
      <action android:name="com.google.android.c2dm.intent.RECEIVE" />
      <category android:name="com.example.gcm" />
    </intent-filter>
  </receiver>
  <service
    android:name="com.example.MyGcmListenerService"
    android:exported="false" >
    <intent-filter>
      <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    </intent-filter>
  </service>
  <service
    android:name="com.example.MyInstanceIDListenerService"
    android:exported="false">
    <intent-filter>
      <action android:name="com.google.android.gms.iid.InstanceID"/>
    </intent-filter>
  </service>
</application>

</manifest>

GCMListener将包含onMessageReceived方法，当我们接收到任何消息时会被调用。

这就是我们需要的客户端方面的全部内容；至于服务器端，由于它完全取决于选择的技术和语言，本书将不详细介绍。在网络上可以轻松找到用于发送通知的 Python、Grails、Java 等不同的代码片段和脚本。

实际上，我们并不需要一个服务器来发送通知，因为我们可以直接与 GCM 进行通信。我们需要做的就是向 gcm-http.googleapis.com/gcm/send 发送一个 POST 请求。这可以通过任何在线 POST 发送服务轻松完成，例如 hurl.it 或 Postman（一个用于发送网络请求的 Google Chrome 扩展程序）。我们的请求需要如下所示：

Content-Type:application/json
Authorization:key="SERVER_API_LEY"
{
  "to" : "RECEIVER_TOKEN"
  "data" : {
    "text":"Testing GCM"
  },
}

继续使用 MasteringAndroidApp，我们将实现 Parse 的推送通知功能。

使用 Parse 的推送通知

对于我们的示例，我们将坚持使用 Parse。主要原因是，我们不需要担心服务器端，而且使用这个解决方案不需要在 Google 开发者控制台创建应用程序。另一个原因是它有一个很好的内置控制面板来发送通知，如果我们提前跟踪了具有不同参数的不同用户，我们还可以针对这些用户。

使用 Parse，我们不需要创建一个 GCM 监听器。相反，它使用 Parse 库中已经包含的服务，我们只需为此服务注册一个订阅者。我们需要做的就是向我们的应用程序添加权限和接收器，然后就可以开始了：

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="android.permission.VIBRATE" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.GET_ACCOUNTS" />
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
<permission android:protectionLevel="signature" android:name="com.packtub.masteringandroidapp.permission.C2D_MESSAGE" />
<uses-permission android:name="com.packtpub.masteringandroidapp.permission.C2D_MESSAGE" />

确保最后两个权限与您的包名相匹配。接收器需要放在 application 标签内：

<service android:name="com.parse.PushService" />
<receiver android:name="com.parse.ParseBroadcastReceiver">
  <intent-filter>
    <action android:name="android.intent.action.BOOT_COMPLETED" />
    <action android:name="android.intent.action.USER_PRESENT" />
  </intent-filter>
</receiver>

<receiver android:name="com.parse.ParsePushBroadcastReceiver"
  android:exported="false">
  <intent-filter>
    <action android:name="com.parse.push.intent.RECEIVE" />
    <action android:name="com.parse.push.intent.DELETE" />
    <action android:name="com.parse.push.intent.OPEN" />
  </intent-filter>
</receiver>

<receiver android:name="com.parse.GcmBroadcastReceiver"
  android:permission="com.google.android.c2dm.permission.SEND">
  <intent-filter>
    <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
    <category android:name="com.packtpub.masteringandroidapp" />
  </intent-filter>
</receiver>

</application>

为了监听通知，我们可以在 Application 类的 OnCreate 方法中注册一个订阅者：

ParsePush.subscribeInBackground("", new SaveCallback() {
  @Override
  public void done(com.parse.ParseException e) {
    if (e == null) {
      Log.d("com.parse.push", "successfully subscribed to the broadcast channel.");
    } else {
      Log.e("com.parse.push", "failed to subscribe for push", e);
      }
  }
});

现在，一切就绪。只需进入 Parse 网站，选择 推送 选项卡，然后点击 + 发送推送。您可以指定受众，选择立即发送还是延迟发送以及其他参数。它会跟踪已发送的推送，并指出发送给了哪些人。

如果您在 已发送推送 列中看到 1，然后查看设备中的通知，那么一切正常。您设备中的通知应如下所示：

使用 NotificationCompat

目前，我们可以看到由 Parse 接收器创建的默认通知。但是，我们可以设置自己的接收器，并使用 NotificationCompat 创建更美观的通知。这个组件在支持库 v4 中引入，可以显示 Android L 和 M 以及之前版本直到 API 4 的最新功能的通知。

简而言之，我们需要做的是利用NotificationCompat.Builder创建一个通知，并通过NotificationManager.notify()将这个通知传递给系统：

public class MyNotificationReceiver  extends BroadcastReceiver {

  @Override
  public void onReceive(Context context, Intent intent) {
    Notification notification = new NotificationCompat.Builder(context)
    .setContentTitle("Title")
    .setContentText("Text")
    .setSmallIcon(R.drawable.ic_launcher)
    .build();
    NotificationManagerCompat.from(context).notify(1231,notification);
  }

}

这将显示我们的通知。标题、文本和图标是必须的；如果我们不添加这三个属性，通知就不会显示。要开始使用我们的自定义接收器，需要在清单文件中指定我们想要使用的注册，而不是 Parse 推送接收器：

receiver android:name="com.packtpub.masteringandroidapp.MyNotificationReceiver" android:exported="false">
  <intent-filter>
    <action android:name="com.parse.push.intent.RECEIVE" />
    <action android:name="com.parse.push.intent.DELETE" />
    <action android:name="com.parse.push.intent.OPEN" />
  </intent-filter>
</receiver>

我们讨论了如何使用NotificationCompat显示自定义通知。通知有自己的设计指南，它们是材料设计的重要组成部分。建议查看这些指南，并在在应用中使用此组件时牢记它们。

注意

你可以在以下链接找到指导方针：developer.android.com/design/patterns/notifications.html。

数据分析的重要性

了解用户如何使用你的应用非常重要。分析帮助我们理解哪些屏幕访问最多，用户在我们的应用中购买哪些产品，以及为什么某些用户在注册过程中退出，同时获取有关性别、位置、年龄等信息。

我们甚至可以追踪应用中用户遇到的崩溃问题，以及设备型号、Android 版本、崩溃日志等信息。

这些数据帮助我们改善用户体验，例如，如果我们发现用户的行为并不像我们预期的那样。它有助于定义我们的产品；如果我们的应用中有不同的功能，我们可以确定哪个功能使用最多。它帮助我们了解受众，这对市场营销是有益的。通过崩溃报告，更容易保持应用无错误和崩溃。

我们将以 Parse 为例，开始追踪一些事件。

使用 Parse 进行数据分析

在不添加任何额外代码的情况下，仅通过我们已经在使用的Parse.init()方法，在 Parse 控制台的分析标签下就能看到一些统计数据。

在受众部分，我们可以看到每日、每周和每月的活跃安装量和活跃用户数。这有助于我们了解有多少用户以及他们中有多少是活跃的。如果我们想知道有多少用户卸载了应用，可以查看留存部分。

我们将追踪一些事件和崩溃，以在这两个部分显示信息，但首先，我们将看看资源管理器。如果你点击左侧的资源管理器按钮，你应该看到以下选项：

这将显示一个表格，我们可以从中看到过滤我们应用数据的各种选项。一旦开始追踪事件和动作，这里将会有更多的列，我们将能够创建复杂的查询。

默认情况下，如果我们点击运行查询，我们会看到以下表格图像：

它显示了在默认列下可用的所有信息；目前不需要额外的列。我们可以看到所有不同的请求类型以及操作系统、操作系统版本和我们应用程序的版本。

我们可以使用过滤器来生成不同的输出。一些有趣的输出可能是，例如，按应用程序版本排序和分组，以便了解有多少人在使用每个版本。

如果我们使用相同的 Parse 数据库用于不同的平台，比如安卓和 iOS，我们可以按平台进行过滤。

这是一个按操作系统版本过滤的示例，我们可以看到我们的用户当前正在使用的所有安卓版本：

为了收集更多关于应用程序何时以及被打开频率的数据，我们可以在欢迎屏幕或第一个活动的onCreate方法中添加以下行。

ParseAnalytics.trackAppOpenedInBackground(getIntent());

这是一个我们可以跟踪的事件示例，但通常说到事件跟踪，我们指的是自定义事件。例如，如果我们想跟踪哪个职位报价访问量最大，我们将在JobOfferDetailActivity中跟踪带有访问文章标题的事件。我们还可以在点击行打开报价的onlick监听器中跟踪此事件。这方面没有固定的规则；实现可能有所不同。但是，我们需要知道目标是当报价被查看时跟踪事件。

在OfferDetailActivity的OnCreate方法中选择跟踪事件的选项的代码将与以下代码类似：

public class OfferDetailActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_offer_detail);

    String job_title = getIntent().getStringExtra("job_title");

    Map<String, String> eventParams = new HashMap<>();
    eventParams.put("job_title", job_title);
    ParseAnalytics.trackEventInBackground("job_visited", eventParams);

trackEventInBackground方法启动一个后台线程来为我们创建网络上传请求。参数作为具有最多八个的Map字符串发送。

如果我们在不同时间访问不同的报价，并进入分析浏览器部分，我们可以轻松创建一个查询来查看每个职位报价被打开的次数。

通过按维度分组数据，这些维度包括我们随事件跟踪发送的不同参数，并使用计数的聚合，我们可以得到每个职位报价被访问的次数。

接下来，我们将看看如何利用这种事件跟踪的优势，将 Parse 作为错误报告工具。

错误报告

当我们的应用程序分发时报告崩溃对于维护一个无错误和崩溃的应用程序至关重要。市场上有成百上千种安卓设备，即使在发布应用程序时最好的质量保证人员或测试员也可能在不同情况下犯错，最终导致应用程序崩溃。

我们需要假设我们的应用程序将会崩溃。我们必须尽可能编写最好的代码，但如果发生崩溃，我们需要有工具来报告并修复它。

Parse 允许我们使用以下代码跟踪错误：

Map<String, String> dimensions = new HashMap<String, String>(); dimensions.put('code', Integer.toString(error.getCode())); ParseAnalytics.trackEvent('error', dimensions);

然而，这种解决方案仅能让我们追踪到受控代码块的错误。例如，假设我们有一个网络请求，它返回了一个错误。这种情形可以轻松处理；我们只需追踪来自服务器的错误响应事件。

当我们的应用程序中出现NullPointerException时，就会出现问题，这是因为我们遇到了一个由于无法在代码中检测到的意外情况而导致的崩溃。例如，如果一个职位的图片链接为 null，而我尝试读取链接而不检查属性是否为 null，我将得到NullPointerException，应用程序将崩溃。

如果我们不能控制发生错误的代码部分，我们该如何追踪呢？幸运的是，市场上我们有工具可以帮我们做到这一点。HockeyApp 是一个帮助分发测试版本并收集实时崩溃报告的工具。这是一个在网页面板上显示我们应用程序错误报告的工具。它真的很容易集成；我们只需要在库中添加以下内容：

compile 'net.hockeyapp.android:HockeySDK:3.5.0-b.4'

然后，我们需要调用以下方法来报告错误：

CrashManager.register(this, APP_ID);

APP_ID将在你将 APK 上传到 Hockey 或在你手动在 Hockey 网站上创建新应用程序时找到。

一旦我们知道App_ID并注册了崩溃报告，如果我们遇到崩溃，我们将看到一个带有发生次数列表的界面，如下面的截图所示：

我们将以分析的话题结束，Parse 只是众多选择之一；同样常见的还有使用 Google Analytics，它包含在 Google Play 服务库中。Google Analytics 允许我们创建更复杂的报告，例如漏斗追踪，以查看在漫长的注册过程中我们失去了多少用户，我们还可以在不同的图表和直方图中查看数据。

如果你属于一个大机构，可以看看 Adobe Omniture。它是一个企业工具，能帮助你将不同的事件作为变量进行追踪，并创建公式来展示这些变量。它还允许你将移动分析数据与其他部门（如销售、市场营销和客户服务）的数据结合起来。根据我的个人经验，我见过的使用 Omniture 的公司通常会有专人全职负责分析研究。在这种情况下，开发者需要知道的只是如何实现 SDK 和追踪事件；创建复杂报告不是开发者的任务。

总结

在本章中，你学习了如何为我们的应用程序添加通知。我们使用 Parse 实现了推送通知，并讨论了如何使用 Google Cloud Messaging 创建我们自己的自定义通知服务，包括客户端所需的所有代码和测试服务器端的工具。在章节的后半部分，我们介绍了分析，解释了它们的重要性，并用 Parse 跟踪事件。在分析领域，一个重要的方面是错误报告。我们还使用 Parse 和 HockeyApp 跟踪了应用程序中的错误。最后，我们概览了其他分析解决方案，例如 Google Analytics 和 Adobe Omniture。

在下一章中，我们将使用位置服务，并学习如何将MapView添加到我们的示例中，显示带有位置标记的谷歌地图。

第十章：位置服务

在本章中，我们将学习如何使用 Google 的地图片段向我们的应用程序添加地图视图。我们将在地图上添加标记，用于指出感兴趣的位置。

为了做到这一点，我们还将讨论如何在 Google 开发者控制台创建项目，并设置我们的应用程序以使用 Google Play Services SDK，这是在任何 Android 应用程序中使用 Google 服务的必要条件。

Parse 中的每个工作机会都有一个位置字段；基于此，我们将在地图上显示标记。

• 配置项目

  • 获取 Google Maps API 密钥

  • 配置AndroidManifest.xml

• 添加地图

  • 为 ViewPager 创建片段

  • 实现地图片段

• 添加标记

  • 从 Parse 检索数据

  • 为每个位置显示一个标记

• 添加标题

配置项目

为了使我们能够使用 Google Play Service API，我们需要使用 Google Play Services SDK 配置我们的项目。如果你还没有安装，请进入 Android SDK 管理器并获取 Google Play Service SDK。

既然我们的应用使用了 Google Play 服务，为了测试应用，你必须确保在以下设备之一上运行应用：

1. 带有 Google Play 商店的 Android 2.3 或更高版本的 Android 设备（推荐）。

2. 已设置 Google Play 服务的模拟器。如果你使用 Genymotion，Google Play 服务默认不会安装：

我们需要让 Google Play 服务 API 对应用可用。

打开应用的build.gradle文件，并在依赖项下添加play-services库。添加到build.gradle文件的行应该类似于这样：

compile 'com.google.android.gms:play-services:7.8.0'

确保你将其更改为最新版本的play-services，并在发布新版本时更新。

保存文件并点击与 Gradle 文件同步项目。

获取 API 密钥

为了使用 Google Maps API，我们需要在 Google 开发者控制台注册我们的项目，并获得一个 API 密钥，然后将其添加到我们的应用中。

首先，我们需要获取我们唯一应用程序的 SHA-1 指纹。我们可以从调试证书或发布证书中获得。

• 调试 证书在完成调试构建时会自动创建。此证书仅应用于目前正在测试的应用。不要使用调试证书发布应用程序。

• 发布 证书是在完成发布构建时生成的。也可以使用keytool程序创建证书。当应用准备发布到 Play 商店时，必须使用此证书。

显示调试证书指纹

• 找到名为debug.keystore的调试密钥库文件。这个文件通常位于 Android 虚拟设备文件所在的目录中：

  • OS X 和 Linux：~/.android/

  • Windows Vista 和 Windows 7：C:\Users\your_user_name\.android\

• 要显示 SHA-1 指纹，请打开终端或命令提示符窗口，并输入以下内容：

  • OS X 和 Linux：我们使用命令 keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android。

  • Windows Vista 和 Windows 7：我们使用命令 keytool -list -v -keystore "%USERPROFILE%\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android。

输入命令并按下回车键后，您将看到类似这样的输出：

Alias name: androiddebugkey
Creation date: Dec 16, 2014
Entry type: PrivateKeyEntry
Certificate chain length: 1
Certificate[1]:
Owner: CN=Android Debug, O=Android, C=US
Issuer: CN=Android Debug, O=Android, C=US
Serial number: 32f30c87
Valid from: Tue Dec 16 11:35:40 CAT 2014 until: Thu Dec 08 11:35:40 CAT 2044
Certificate fingerprints:
         MD5:  7E:06:3D:45:D7:1D:48:FE:96:88:18:20:0F:09:B8:2A
         SHA1: BD:24:B2:7C:DA:67:E5:80:78:1D:75:8C:C6:66:B3:D0:63:3E:EE:84
         SHA256: E4:8C:BD:4A:24:CD:55:5C:0E:7A:1E:B7:FC:A3:9E:60:28:FB:F7:20:C6:C0:E9:1A:C8:13:29:A6:F2:10:42:DB
         Signature algorithm name: SHA256withRSA
         Version: 3

创建 Google 开发者控制台项目

访问console.developers.google.com/project，如果您还没有账户，请创建一个账户。首先，使用您想要的名字创建一个新项目。项目创建后，执行以下步骤：

1. 在左侧边栏中，点击APIs & auth，然后选择APIs选项：

2. 选择Google Maps Android API并启用它。

3. 打开凭据，然后点击[创建新密钥]。

4. 选择Android 密钥，输入您的SHA-1指纹，然后是您的项目包名称，两者之间用分号分隔，如下所示：

   BD:24:B2:7C:DA:67:E5:80:78:1D:75:8C:C6:66:B3:D0:63:3E:EE:84;com.packtpub.masteringandroidapp
   

5. 完成此操作后，您将能够像以下截图一样查看凭据：

配置 AndroidManifest.xml

既然我们已经获得了 Android 应用的 API 密钥，我们需要将其添加到AndroidManifest.xml文件中。

打开您的AndroidManifest.xml文件，并在<application>元素下添加以下代码作为子元素：

<meta-data
  android:name="com.google.android.geo.API_KEY"
  android:value="API_KEY"/>

将value属性中的API_KEY替换为 Google 开发者控制台给出的 API 密钥。

我们还需要在AndroidManifest中添加其他几个设置。如下设置 Google Play 服务的版本：

<meta-data
  android:name="com.google.android.gms.version"
  android:value="@integer/google_play_services_version" />

如下设置必要的权限：

• INTERNET：此权限用于从 Google Maps 服务器下载地图数据。

• ACCESS_NETWORK_STATE：这将允许 API 检查连接状态，以确定是否能够下载数据。

• WRITE_EXTERNAL_STORAGE：这将允许 API 缓存地图数据。

• ACCESS_COARSE_LOCATION：这允许 API 使用 Wi-Fi 或移动数据获取设备的位置。

• ACCESS_FINE_LOCATION：这将比ACCESS_COARSE_LOCATION提供更精确的位置，并且还将使用 GPS 以及 Wi-Fi 或移动数据。看看以下代码：

  <uses-permission android:name="android.permission.INTERNET"/>
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
  

您还需要设置 OpenGL ES。地图 API 使用 OpenGL ES 来渲染地图，因此需要安装它才能显示地图。为了通知其他服务这一需求，并防止不支持 OpenGL 的设备在 Google Play 商店显示您的应用，请在您的AndroidManifest.xml文件中的<manifest>标签下添加以下内容：

<uses-feature
  android:glEsVersion="0x00020000"
  android:required="true"/>

您当前的AndroidManifest.xml文件应类似于以下代码：

<?xml version="1.0" encoding="UTF-8"?>
<manifest  package="com.packtpub.masteringandroidapp">
  <uses-feature android:glEsVersion="0x00020000" android:required="true" />
  <uses-permission android:name="android.permission.INTERNET" />
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  <application android:name=".MAApplication" android:allowBackup="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme">
    <activity android:name=".SplashActivity" android:label="@string/app_name">
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>
    <activity android:name=".MainActivity" android:label="@string/title_activity_main" />
    <activity android:name=".OfferDetailActivity" android:label="@string/title_activity_offer_detail" />
    <provider android:name=".MAAProvider" android:authorities="com.packtpub.masteringandroidapp.MAAProvider" />
    <meta-data android:name="com.google.android.geo.API_KEY" android:value="AIzaSyC9o7cLdk_MIX_aQhaOLvoqYywK61bN0PQ" />
    <meta-data android:name="com.google.android.gms.version" android:value="@integer/google_play_services_version" />
  </application>
</manifest>

添加地图

既然我们的应用程序已经配置好了可以使用地图服务，那么我们可以开始讨论如何在应用程序中添加一个可视化的地图。对于地图，我们将创建另一个 Fragment，它将被加载到ViewPager的第二个页面。

有两种方法可以显示谷歌地图；一个MapFragment或MapView对象可以表示它。

添加 Fragment

在我们的fragments目录中创建一个名为MyMapFragment的新 Java 类。这个类应该继承Fragment类型。然后，重写OnCreateView方法，并让它返回fragment_my_map的填充视图：

package com.packtpub.masteringandroidapp.fragments;

import …

/**
* Created by Unathi on 7/29/2015.
*/
public class MyMapFragment extends Fragment {

  @Nullable
  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.fragment_my_map, container, false);

    return view;
  }
}

接下来，为 Fragment 创建布局文件，并将其命名为fragment_my_map。将布局的根元素设置为FrameLayout。我们将在布局中暂时添加TextView以验证其是否有效。fragment_my_map.xml文件的代码应类似于以下这样：

<?xml version="1.0" encoding="UTF-8"?>
<FrameLayout  android:layout_width="match_parent" android:layout_height="match_parent">
  <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="This is a TextView" android:layout_gravity="center" android:textSize="25dp" />
</FrameLayout>

将我们的 Fragment 添加到应用程序的最后一步将是编辑MyPagerAdapter.java文件，将其作为第二个页面显示。为此，将getItem方法中的第二个 case 更改为返回MyMapFragment的实例，并将getPageTitle方法中第二个 case 的页面标题更改为返回MAP：

@Override
public Fragment getItem(int i) {
  switch (i) {
    case 0 :
    return new ListFragment();
    case 1 :
    return new MyMapFragment();
    case 2 :
    return new SettingsFragment();
    default:
    return null;
  }
}

@Override
public CharSequence getPageTitle(int position) {
  switch (position) {
    case 0 :
    return "LIST";
    case 1 :
    return "MAP";
    case 2 :
    return "SETTINGS";
    default:
    return null;
  }
}

现在，当你运行应用程序时，ViewPager的第二个页面应该被我们新的 Fragment 替换。

实现 MapFragment

我们现在将使用MapFragment在我们的应用程序上显示地图。我们可以通过添加一个带有android:name为com.google.android.gms.maps.MapFragment的<fragment>布局来实现这一点。这样做将自动将MapFragment添加到activity中：

以下是fragment_my_map.xml的代码：

<?xml version="1.0" encoding="UTF-8"?>
<FrameLayout  android:layout_width="match_parent" android:layout_height="match_parent">
  <fragment android:name="com.google.android.gms.maps.MapFragment" android:id="@+id/map" android:layout_width="match_parent" android:layout_height="match_parent" />
</FrameLayout>

接下来，为了能够处理我们添加到布局中的MapFragment，我们需要使用FragmentManager，我们从getChildFragmentManager获取它，通过findFragmentById来找到。这将在OnCreateView方法中完成：

FragmentManager fm = getChildFragmentManager();
mapFragment = (SupportMapFragment) fm.findFragmentById(R.id.map);
if (mapFragment == null) {
  mapFragment = SupportMapFragment.newInstance();
  fm.beginTransaction().add(R.id.map, mapFragment).commit();
}

我们将把我们的 Fragment 分配给SupportMapFragment，而不是仅仅MapFragment，这样应用程序就可以支持低于12的 Android API 级别。使用以下代码：

以下是MyMapFragment.java的代码：

public class MyMapFragment extends Fragment{

  private SupportMapFragment mapFragment;

  @Nullable
  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.fragment_my_map, container, false);

    FragmentManager fm = getChildFragmentManager();
    mapFragment = (SupportMapFragment) fm.findFragmentById(R.id.map);
    if (mapFragment == null) {
      mapFragment = SupportMapFragment.newInstance();
      fm.beginTransaction().add(R.id.map, mapFragment).commit();
    }

    return view;
  }

}

现在，当我们运行应用程序时，地图将在屏幕上显示。

添加标记

现在谷歌地图已经可见，但它还没有为用户显示任何有用的数据。为了实现这一点，我们将添加地图标记来指示用户感兴趣的点。这些将是不同职位提供的位置，我们将从 Parse 数据库下载这些位置。

我们还将学习如何将用于在地图上标记点的图标更改为自定义图像，并在标记上加上标题。这将使我们的应用程序看起来更有趣、更具有信息性。

从 Parse 检索数据

在我们能够显示所有标记之前，我们需要从 Parse 下载所有必要的数据。

在 MyMapFragment.java 中，我们将使用 ParseQuery 获取位置列表，并使用它来获取每个职位在显示之前的相关信息。执行以下步骤：

• 创建一个名为 googleMap 的私有成员变量，其类型为 GoogleMap，并重写 onResume() 方法。

• 在 onResume() 中，检查 googleMap 是否为空；如果是，这意味着我们还没有向当前地图实例添加标记。如果 googleMap 为空，从我们已经创建的 MapFragment 分配地图。这是使用 getMap() 实现的：

  if (googleMap == null) {
  
    googleMap = MapFragment.getMap();
  
  }
  

• 创建一个 ParseQuery，它将检索我们 Parse 数据库中 JobOffer 表的所有数据。使用 findInBackground() 函数和 FindCallback，这样我们就可以在数据下载完成后开始处理数据。使用以下代码：

  ParseQuery<JobOffer> query = ParseQuery.getQuery("JobOffer");
  query.findInBackground(new FindCallback<JobOffer>() {
    @Override
    public void done(List<JobOffer> list, ParseException e) {
  
    }
  });
  

为每个位置显示标记

现在，我们将遍历从 Parse 收到的职位列表，并使用 addMarker() 向 googleMap 添加标记。执行以下步骤：

1. 当 findInBackground 执行完毕后，创建一个 ParseGeoPoint 变量和一个循环，该循环将遍历列表中的每个项目。我们将使用 ParseGeoPoint 变量来存储来自 Parse 数据库的坐标：

   ParseGeoPoint geoPoint = new ParseGeoPoint();
   
   for(int i =0;i<list.size();i++){
   
   }
   

2. 在循环内，从列表中获取 GeoPoint 数据并将其保存到我们的 ParseGeoPoint 变量中：

    geoPoint = list.get(i).getParseGeoPoint("coordinates");
   

3. 最后，在每次迭代中使用 addMarker() 向 googleMap 添加标记：

   googleMap.addMarker(new MarkerOptions()
   .position(new LatLng(geoPoint.getLatitude(), geoPoint.getLongitude())));
   

你的 MyMapFragment.java 文件应类似于以下内容：

public class MyMapFragment extends Fragment{

  private SupportMapFragment mapFragment;
  private GoogleMap googleMap;

  @Nullable
  @Override
  public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.fragment_my_map, container, false);

    FragmentManager fm = getChildFragmentManager();
    mapFragment = (SupportMapFragment) fm.findFragmentById(R.id.map);
    if (mapFragment == null) {
      mapFragment = SupportMapFragment.newInstance();
      fm.beginTransaction().add(R.id.map, mapFragment).commit();
    }

    return view;
  }

  @Override
  public void onResume() {
    super.onResume();

    if (googleMap == null) {
      googleMap = mapFragment.getMap();

      ParseQuery<JobOffer> query = ParseQuery.getQuery("JobOffer");
      query.findInBackground(new FindCallback<JobOffer>() {
        @Override
        public void done(List<JobOffer> list, ParseException e) {

          ParseGeoPoint geoPoint;

          for(int i =0;i<list.size();i++){
            geoPoint = list.get(i).getParseGeoPoint("coordinates");

            googleMap.addMarker(new MarkerOptions()
            .position(new LatLng(geoPoint.getLatitude(), geoPoint.getLongitude())));
          }

        }
      });

    }
  }
}

这些标记现在应该在应用中可见：

向标记添加标题

地图上标记的实用性不仅仅在于显示一个点，而且还在于为用户提供一种简单且易于访问的方式来获取此位置的信息。我们将通过在点击标记时显示标题来实现这一点。

这可以通过简单地在我们的 addMarker() 方法中添加 .title(string) 来实现：

googleMap.addMarker(new MarkerOptions()
.position(new LatLng(geoPoint.getLatitude(), geoPoint.getLongitude()))
.title(list.get(i).getTitle()));

现在我们有一个完全功能的地图显示，当用户点击标记时，它会在标记上方显示一个标题，如下面的图片所示：

总结

在本章中，你学习了如何向我们的应用添加地图。这需要我们在 Google Developer Console 上创建一个项目，并配置我们的应用以访问必要的 API。一旦我们的应用完全配置好，我们就继续将地图添加到我们选择的视图中。我们讨论了在另一个片段（MyMapFragment 中的 MapFragment）中处理片段。尽管单个 MapFragment 可以通过代码单独添加，但将其放在带有布局的另一个片段中，如果我们需要，可以让我们有可能向页面添加其他 UI 控件，例如 FloatingActionButton。最后，我们通过显示从 Parse 下载的位置的标记和信息，使地图变得有用。

在下一章中，你将学习如何调试和测试我们的应用程序。

第十一章：安卓上的调试与测试

在本章中，你将学习如何在 Android 中进行调试，这是一个在开发应用程序时查找和解决问题的基本实践，可以节省时间。

我们将学习如何创建自动化测试，可以测试按钮的点击或单个方法的结果。这是一组你可以在 Android Studio 中运行的测试，以确保每次开发新功能时，不会破坏现有的功能。

你还将学习如何使用Robolectric进行单元测试和 Espresso 进行集成测试。

在本章的最后，我们将讨论如何使用 Monkey 进行数百万次随机点击测试 UI，如何通过应用录制点击序列，以及如何使用 MonkeyTalk 配置基于这些记录的测试。

• 日志和调试模式

• 测试

  • 使用 Robolectric 进行单元测试

  • 使用 Espresso 进行集成测试

• UI 测试

  • 使用 MonkeyRunner 进行随机点击

  • 使用 MonkeyTalk 记录点击

• 持续集成

日志和调试模式

如果不提及日志以及如何通过调试解决问题，我们无法完成这本书。如果你知道如何解决自己的问题，那么在 Android 上开发不仅仅是复制粘贴 Stack Overflow 的内容。

调试模式和日志是帮助开发者定位问题的机制。随着时间的推移，每个开发者都会进步并减少使用这些技术的频率，但一开始，应用中充满了日志是很常见的。我们不希望用户在应用发布后能够看到日志，也不希望手动移除日志并在发布新版本时再次添加。我们将看看如何避免这种情况。

处理日志

Log 类用于打印实时可在LogCat中读取的消息和错误。以下是记录消息的示例：

Log.i("MyActivity", "Example of an info log");

Log类有五种方法，它们用于在日志上设置不同的优先级。这允许我们在LogCat中按优先级进行过滤。在某些情况下，我们会显示不同的日志，例如，查看每次请求下载的工作机会数量。如果我们的应用崩溃了，此时错误类型的日志是我们的优先事项，我们希望隐藏其他优先级较低的日志，以便尽快找到错误。

五个优先级分别是（从低到高）：详细、调试、信息、警告和错误。(Log.v , Log.d, Log.i, Log.w, 和 Log.e)

我们可以通过日志窗口顶部的栏按进程进行过滤。我们可以按优先级和关键词进行过滤，并且可以创建自定义过滤器，按标签、进程 ID 等进行过滤。

如果日志不显示或者它们是旧的且不刷新，尝试打开右边的下拉菜单，选择无 过滤，然后再次选择仅显示选定应用程序。这会强制控制台刷新。

为了完成日志，我们将创建一个包装器，并使用第三方库，以便只需更改布尔值就能在项目中禁用所有日志。为此，我们只需创建一个具有与Log类相同方法的类，这些方法依赖于这个布尔值：

public class MyLogger {

  static final boolean LOG = false;

  public static void i(String tag, String string) {
    if (LOG) android.util.Log.i(tag, string);
  }

  public static void e(String tag, String string) {
    if (LOG) android.util.Log.e(tag, string);
  }
  …

我们每次想要编写日志时都需要使用这个包装器——使用MyLogger.d()而不是Log.d()。这样，如果我们更改MyLogger类中的布尔值LOG，它将同时停止我们项目中的所有日志。

建议使用BuildConfing.DEBUG变量的值：

static final boolean LOG = BuildConfing.DEBUG; 

如果我们的应用处于调试模式，这将成立，发布应用时将变为假。因此，我们不需要记住在发布模式下关闭日志，也没有日志对最终用户显示的风险。

使用 Timber，日志包装器

Timber 是由 Jake Wharton 创建的日志包装器，它将日志提升到了一个高级水平，允许我们使用日志树概念来拥有不同的日志行为。看看以下代码：

compile 'com.jakewharton.timber:timber:3.1.0'

使用 Timber 的优点之一是，我们不需要在同一个活动中多次编写日志标签：

Timber.tag("LifeCycles");
Timber.d("Activity Created");

我们的树可以有不同的行为；例如，我可能想在发布模式下禁用日志，但我仍然想处理错误；所以，我会种植一个错误树，将错误报告给 Parse：

if (BuildConfig.DEBUG) {
  Timber.plant(new Timber.DebugTree());
} else {
  Timber.plant(new CrashReportingTree());
}

/** A tree which logs important information for crash reporting. */
private static class CrashReportingTree extends Timber.Tree {
  @Override protected void log(int priority, String tag, String message, Throwable t) {
    if (priority == Log.VERBOSE || priority == Log.DEBUG) {
      return;
    }
    //Track error to parse.com
  }
}

调试我们的应用

日志可用于开发过程中查找问题，但如果我们掌握了调试模式，会发现这个做法要快得多。

当我们处于调试模式时，可以在代码中设置断点。通过这些断点，我们指定一个代码行，我们希望执行在此处停止，以显示那一刻的变量值。要设置断点，只需在左侧边栏上双击：

我们在获取工作机会的方法的响应中设置了一个调试点。我们可以从顶部栏启动调试模式：

如果我们在调试模式下运行应用，当达到这一点时，Android Studio 将暂停执行：

Android Studio 会自动提示调试器窗口，我们可以在执行点查看变量。从前面的截图中，我们可以看到工作机会列表，并导航查看每个机会内部的内容。

这里的重要特性是左侧的绿色播放按钮，它将继续执行我们的应用到下一个断点，以及红色方块，它退出调试模式并继续执行应用。

我们还有不同的控件可用于转到下一行，进入一个方法，或离开方法。例如，假设我们在以下命令的第一行有一个断点：

MasteringAndroidDAO.getInstance().clearDB(getActivity());
MasteringAndroidDAO.getInstance().storeOffers(getActivity(), jobOffersList);

在这种情况下，单步跳过（指向下方的蓝色箭头）将把我们的执行移到下一行。如果我们点击单步进入（指向右下角的蓝色箭头），我们将进入getInstace()方法。结合这些控件，我们可以实时控制流程。

解释了调试模式之后，我们现在可以继续讨论自动化测试。

在 Android 上测试

任何新功能在完成之前都需要先进行测试。我们作为开发者，曾多次掉入在未先编写通过测试的情况下提交代码更改的陷阱，结果发现在未来的迭代中预期行为被破坏了。

我们通过艰难的方式了解到，编写测试可以提高我们的生产力，提高代码质量，并帮助我们更频繁地发布。因此，Android 提供了几种工具，以帮助我们从早期阶段开始测试应用程序。

在接下来的两节中，我们将讨论我最喜欢的设置：用 Robolectric 进行单元测试，用 Espresso 进行集成测试。

使用 Robolectric 的单元测试

直到 Robolectric 出现，编写单元测试意味着我们必须在真实设备或模拟器上运行它们。这个过程可能需要几分钟，因为 Android 构建工具必须打包测试代码，将其推送到连接的设备，然后运行它。

Robolectric 通过使我们能够在工作站的 JVM 中运行单元测试，而无需 Android 设备或模拟器，从而缓解了这个问题。

要使用 Gradle 包含 Robolectric，我们可以在build.gradle文件中添加以下依赖：

testCompile "org.robolectric:robolectric:3.0"

我们使用testCompile来指定我们希望此依赖包含在测试项目中。对于测试项目，默认源目录是src/test。

Robolectric 配置

在撰写本文时，Robolectric 3.0 版本支持以下 Android SDK：

• Jelly Bean，SDK 版本 16

• Jelly Bean MR1，SDK 版本 17

• Jelly Bean MR2，SDK 版本 18

• KitKat，SDK 版本 19

• Lollipop，SDK 版本 21

默认情况下，测试将针对AndroidManifest文件中定义的targetSdkVersion运行。如果你想针对不同的 SDK 版本运行测试，或者你当前的targetSdkVersion不被 Robolectric 支持，你可以手动覆盖它，通过位于src/test/resources/robolectric.properties的属性文件，内容如下：

robolectric.properties
sdk=<SDK_VERSION>

我们的第一单元测试

我们将从设置一个非常简单且常见的场景开始：一个带有登录按钮的欢迎活动，该按钮使用户导航到登录活动。欢迎活动的布局如下：

<?xml version="1.0" encoding="UTF-8"?>
<LinearLayout  android:layout_width="match_parent" android:layout_height="match_parent">
  <Button android:id="@+id/login" android:text="Login" android:layout_width="wrap_content" android:layout_height="wrap_content" />
</LinearLayout>

在WelcomeActivity类中，我们只需将登录按钮设置为启动登录活动：

public class WelcomeActivity extends Activity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.welcome_activity);

    View button = findViewById(R.id.login);
    button.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View view) {
        startActivity(new Intent(WelcomeActivity.this, LoginActivity.class));
      }
    });
  }
}

为了测试这一点，我们可以确保通过发送正确的Intent来启动LoginActivity。因为 Robolectric 是一个单元测试框架，LoginActivity实际上不会启动，但我们能够检查框架是否捕获了正确的意图。

首先，我们将在src/test/java/路径中正确的包内创建测试文件WelcomeActivityTest.java。Robolectric 依赖于 JUnit 4，因此我们将从指定 Robolectric 的 Gradle 测试运行器和一些额外的配置开始，框架将使用这些配置来查找AndroidManifest资源和资产。运行以下命令：

@RunWith(RobolectricGradleTestRunner.class)
@Config(constants = BuildConfig.class)

现在，我们可以编写我们的第一个测试。我们将从创建并使欢迎活动进入前台开始：

WelcomeActivity activity = Robolectric.setupActivity(WelcomeActivity.class);

既然我们已经有了WelcomeActivity的实例，点击登录按钮就变得简单了：

activity.findViewById(R.id.login).performClick();

最后，我们必须验证框架捕获了将启动LoginActivity的意图：

Intent expectedIntent = new Intent(activity, LoginActivity.class);
assertThat(shadowOf(activity).getNextStartedActivity(), is(equalTo(expectedIntent)));

shadowOf静态方法返回一个ShadowActivity对象，该对象存储了与当前测试活动的大部分交互。我们需要使用@Test注解，这告诉 JUnit 该方法可以作为测试用例运行。将所有内容放在一起，我们得到以下测试类（WelcomeActivityTest.java）：

@RunWith(RobolectricGradleTestRunner.class)
@Config(constants = BuildConfig.class)
public class WelcomeActivityTest {

  @Test
  public void loginPress_startsLoginActivity() {
    WelcomeActivity activity = Robolectric.setupActivity(WelcomeActivity.class);

    activity.findViewById(R.id.login).performClick();

    Intent expectedIntent = new Intent(activity, LoginActivity.class);
    assertThat(shadowOf(activity).getNextStartedActivity(), is(equalTo(expectedIntent)));
  }
}

运行单元测试

在能够运行单元测试之前，我们需要在 Android Studio 中选择正确的测试工件。为此，我们将打开构建变体工具栏，并选择单元测试工件，如下面的截图所示：

现在，从项目窗口中，我们可以通过右键点击测试类并选择运行选项来运行测试。确保项目路径中没有空格；否则，Robolectric 在执行单元测试之前会抛出异常。

我们还可以从命令行运行单元测试。为此，使用带有--continue选项的test任务命令调用：

./gradlew test --continue

如果我们已经配置了持续集成系统，例如 Jenkins、Travis 或 wercker，这个选项是理想的。

这就是 Robolectric 部分的结尾。接下来，我们将讨论使用Espresso进行集成测试。

使用 Espresso 进行集成测试

由于 Android 本身的特点以及市场上的大量设备，我们无法确定发布应用时它可能会如何表现。

我们自然会尽可能在许多不同的设备上手动测试我们的应用，这是一个繁琐的过程，每次发布时都必须重复。在本节中，我们将简要讨论 Espresso 以及如何编写将在真实设备上运行的测试。

Espresso 配置

在编写我们的第一个集成测试之前，我们需要安装并配置测试环境。执行以下步骤：

1. 从 Android SDK 管理器中，我们需要在Extras文件夹中选择并安装Android 支持仓库，如下面的截图所示：

2. 创建用于集成测试代码的文件夹；这应该位于app/src/androidTest。

3. 我们还需要在项目的build.gradle中指定一些依赖项。使用以下代码：

   dependencies {
     androidTestCompile 'com.android.support.test:runner:0.3'
     androidTestCompile 'com.android.support.test:rules:0.3'
     androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2'
     androidTestCompile 'com.android.support.test.espresso:espresso-intents:2.2'
   }
   

最近，Android 添加了对 JUnit 4 风格测试案例的支持。要使用它，我们将在build.gradle文件中将AndroidJUnitRunner添加为默认的测试仪器运行器：

android {
  defaultConfig {
    testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
  }
}

编写集成测试

对于这个例子，我们将从 Robolectric 停下的地方继续；我们将为LoginActivity编写一个测试。对于这个活动，我们将设置一个简单的布局，包含两个EditTexts和一个登录按钮。运行以下代码（activity_login.xml）：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
  android:orientation="vertical"
  android:layout_width="match_parent"
  android:layout_height="match_parent">

  <EditText
    android:id="@+id/input_username"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:inputType="textEmailAddress" />

  <EditText
    android:id="@+id/input_password"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:inputType="textPassword" />

  <Button
    android:id="@+id/button_signin"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/signin"/>
</LinearLayout>

在LoginActivity中，当用户点击登录按钮时，我们将使用以下代码（LoginActivity.java）将凭据发送到闪屏活动：

public class LoginActivity extends Activity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_login);

    final EditText inputUsername = (EditText) findViewById(R.id.input_username);
    final EditText inputPassword = (EditText) findViewById(R.id.input_password);

    Button buttonLogin = (Button) findViewById(R.id.button_signin);

    buttonLogin.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        startActivity(new Intent(getApplicationContext(), SplashActivity.class)
        .putExtra("username", inputUsername.getText().toString())
        .putExtra("password", inputPassword.getText().toString()));
        finish();
      }
    });
  }
}

对于这个测试，我们将在两个输入字段中输入用户凭据，并验证我们是否在意图中正确捆绑它们。

首先，我们将在src/test/androidTest/路径中正确的包内创建LoginActivityTest.java测试文件。我们将使用 JUnit 4，因此首先会指定AndroidJUnit4测试运行器。使用以下命令：

@RunWith(AndroidJUnit4.class)

与 Robolectric 的另一区别是，在 Espresso 中，我们需要指定一个规则来准备被测试的活动。为此，使用以下命令：

@Rule
public IntentsTestRule<LoginActivity> mActivityRule =
  new IntentsTestRule<>(LoginActivity.class);

现在，我们可以开始编写测试。首先，我们需要在两个输入字段中输入登录详情：

String expectedUsername = "mastering@android.com";
String expectedPassword = "electric_sheep";

onView(withId(R.id.input_username)).perform(typeText(expectedUsername));
onView(withId(R.id.input_password)).perform(typeText(expectedPassword));

然后，我们将通过点击登录按钮发送意图：

onView(withId(R.id.button_signin)).perform(click());

最后，我们必须验证捕获的意图是否包含登录凭据：

intended(hasExtras(allOf(
  hasEntry(equalTo("username"), equalTo(expectedUsername)),
  hasEntry(equalTo("password"), equalTo(expectedPassword)))));

把所有内容放在一起，我们将拥有以下测试类（LoginActivityTest.java）：

@RunWith(AndroidJUnit4.class)
public class LoginActivityTest {

  @Rule
  public IntentsTestRule<LoginActivity> mActivityRule =
  new IntentsTestRule<>(LoginActivity.class);

  @Test
  public void loginButtonPressed_sendsLoginCredentials() {
    String expectedUsername = "mastering@android.com";
    String expectedPassword = "electric_sheep";

    onView(withId(R.id.input_username)).perform(typeText(expectedUsername));
    onView(withId(R.id.input_password)).perform(typeText(expectedPassword));

    onView(withId(R.id.button_signin)).perform(click());

    intended(hasExtras(allOf(
    hasEntry(equalTo("username"), equalTo(expectedUsername)),
    hasEntry(equalTo("password"), equalTo(expectedPassword)))));
  }
}

运行集成测试

与我们使用 Robolectric 所做的类似，要运行集成测试，我们需要在 Android Studio 中切换到正确的测试工件（Test Artifact）。为此，我们将打开构建变种（Build Variants）工具栏并选择Android Instrumentation Tests工件：

现在，从项目窗口中，我们可以通过右键点击测试类并选择运行选项来运行测试。

我们还可以从命令行运行集成测试。为此，我们将调用connectedCheck（或cC）任务：

./gradlew cC

如果我们有连接设备或模拟器的持续集成系统，使用命令行是首选方式。当我们编写足够的集成测试后，可以轻松地在数百台真实设备上部署和运行它们，使用如Testdroid之类的服务。

从 UI 角度进行测试

我们现在将进行的测试与使用应用程序的人可能会进行的测试类似。实际上，在拥有质量保证（QA）的的公司中，人们将这些工具作为手动测试的补充。

UI 测试也可以自动化，但它们与单元测试和集成测试不同；这些是在屏幕上执行的操作，从点击按钮到使用记录的事件完成注册过程。

我们将从使用The Monkey进行压力测试开始。

启动 The Monkey

The Monkey 是一个可以从命令行通过 ADB 启动的程序。它在我们的设备或模拟器中生成随机事件，并使用一个种子，我们可以重现相同的随机事件。为了说明，让我们考虑一个带数字的例子。假设我执行了 Monkey，它产生了 1 到 10 的随机数字；如果我再次启动它，我会得到不同的数字。当我使用一个种子（这个种子是一个数字）执行 The Monkey 时，我得到了一组不同的 1 到 10 的数字，如果我用相同的种子再次启动它，我会得到相同的数字。这很有用，因为如果我们使用一个种子来生成随机事件并遇到崩溃，我们可以修复这个崩溃，并再次运行相同的种子，以确保我们解决了问题。

这些随机事件可以是从点击和滚动手势到系统级别事件（如音量增大、音量减小、截图等）的变化。我们可以限制事件的数量和类型，以及运行它的程序包。

终端中的基本语法是以下命令：

$ adb shell monkey [options] <event-count>

如果你从未使用过 ADB，你可以在 Android SDK 目录中的platform-tools文件夹里找到它，无论它安装在你的系统中的哪个位置：

../sdk/platform-tools/adb

当我们打开终端并导航到这个目录时，我们可以编写以下代码行：

adb shell monkey -p com.packtpub.masteringandroidapp -v 500

当你尝试使用adb而输出是command not found时，你可以使用adb kill-server、adb start-server和如果是 Linux 或 Mac 系统，使用./adb（点斜杠 adb）来重启adb。

我们可以将事件数量增加到5000，或者产生无限事件，但通常建议设置一个数字限制；否则，你可能需要重启设备来停止 The Monkey。当你执行命令时，你将能够看到产生的随机事件，并且它会指示所使用的种子，以便如果你想重复相同的事件链，可以知道种子：

根据应用程序的不同，我们可能需要调整事件之间的时间，使用节流毫秒属性来模拟真实用户。

使用下一个测试工具，我们将进行一种不同类型的 UI 测试，目的是跟随一个流程。例如，如果我们有一个由三个屏幕组成的注册流程，每个屏幕都有不同的表单，我们想要记录一个测试，用户填写表单并通过这三个屏幕逻辑地继续。在这种情况下，The Monkey 实际上并不太有帮助；在大量的事件中，它最终会用随机字符填写所有输入字段，并点击按钮进入下一个屏幕，但这并不是我们真正想要的。

使用 MonkeyTalk 记录 UI 测试

记录一系列测试（如注册过程）的目的是为了保存这些测试，以便在我们对代码进行更改时能够再次运行它。我们可能需要修改注册过程的网络请求，而不改变 UI，所以这些测试非常完美。我们可以在完成修改后直接运行它们，而无需手动完成注册或填写表单。这里我们并不是在偷懒；如果我们有数百个测试，这对于一个人来说将是大量的工作。此外，通过自动化测试，我们可以确保事件序列始终如一。

MonkeyTalk是一个免费且开源的工具，有两个版本；在我们的示例中，我们将使用社区版。

注意

有关社区版和专业版的比较列表，可以在他们的网站www.cloudmonkeymobile.com/monkeytalk上查看。

MonkeyTalk 可以在真实设备和模拟器上使用。它通过在录制模式下记录一系列事件来工作：

一旦我们通过点击工具中的录制进入这个录制模式，所有的事件将以执行的动作用到的参数的顺序被记录下来。在上面的截图中，我们可以看到点击TextView并在上面输入一些内容是如何被记录为两个事件的。

我们可以在一个脚本文件中创建这个，MonkeyTalk 将会重现它；因此，我们有了在不录制的情况下创建自己的事件序列的选项。对于前面的事件，我们将编写如下脚本：

Input username tap
Input username enterText us

如果我们点击立即播放按钮，我们将在任何设备上看到所有这些步骤的执行。我们可以在 Android 手机上录制脚本，然后在 iOS 设备上播放它们。

除了录制和播放脚本，我们还可以有验证命令。例如，如果我们有一个清除所有输入字段的按钮，我们可以在脚本执行过程中使用currentValue添加一个验证命令：

Input username tap
Input username enterText us
Input clearform click
Input currentvalue ""

这将报告执行过程中验证的结果，这样我们就能检查我们的所有验证是否正确通过。例如，点击清除表单的按钮就需要一个点击监听器来清除每个输入文本。如果由于某种原因我们进行了修改，元素的 ID 发生了变化，MonkeyTalk 测试会通过一个失败的命令验证来报告这个问题。

如果每次我们在应用中做出更改时，有一个工具能为我们运行这些 UI 测试，以及单元测试和集成测试，那岂不是很棒？这个解决方案是存在的，它被称为持续集成。

持续集成

我们的目的不是解释如何构建一个持续集成系统，因为这超出了本书的范围，而且通常不是 Android 开发者的职责来设置这个环境。但是，你应该了解它是什么以及它是如何工作的，因为它与 Android 直接相关。

一套良好的自动化测试套件与 CI 或持续集成解决方案结合使用总是更好的。这个解决方案将允许我们在每次代码更改时构建和测试我们的应用程序。

这就是大多数拥有大型项目的公司的工作方式。如果他们有一个开发团队，代码通常会在一个仓库中共享，并且他们会构建一个与仓库相连的持续集成（CI）系统。每当开发者在仓库中进行更改并提交时，都会执行测试集合，如果结果成功，就会构建一个新的 Android 可执行文件（APK）。

这样做是为了尽量减少问题的风险。在一个需要多年开发，不同人员参与的大型应用程序中，新开发人员在不破坏或更改现有功能的情况下开始进行更改是不可能的。这是因为项目中的所有人并不都了解所有代码的用途，或者代码过于复杂，修改一个组件可能会影响其他组件。

注意

如果你有兴趣实施这个解决方案，我们可以为你推荐Jenkins，其最初名为 Hudson，详情请访问wiki.jenkins-ci.org/display/JENKINS/Meet+Jenkins。

除了测试和构建我们的应用程序外，Jenkins 还将生成一个测试覆盖率报告，这将使我们能够了解单元测试和集成测试覆盖了我们代码的百分比。

总结

在本章中，我们开始学习如何在我们的应用程序中以高级方式使用日志，并快速概述了调试过程。我们解释了什么是测试，以及如何分别使用 Robolectric 和 Espresso 创建单元测试和集成测试。

我们还创建了 UI 测试，从使用 The Monkey 进行压力测试开始，然后生成随机事件，后来开始使用 MonkeyTalk 进行测试，记录可以再次播放以验证输出的事件流程。最后，我们讨论了持续集成，了解公司如何为 Android 应用程序将测试和构建系统集成在一起。

在下一章，也就是本书的最后一章中，我们将了解如何使我们的应用程序盈利，如何使用不同的构建风味构建应用程序，以及混淆代码，使其准备好上传到应用商店。

第十二章：营收化、构建过程和发布

这是本书的最后一章；我们需要完成的是实现应用的盈利化，生成不同的版本，并将其发布和上传到 Play 商店。

我们将通过创建不同的构建类型来完成构建过程，并生成不带广告的付费版本和带广告的免费版本的应用。所有这些都在同一个项目中，但将作为两个不同的应用导出。

一旦构建过程完成，我们将开始实施广告，并解释关于广告盈利的关键点；这将使我们的应用能够产生收入。

最后，我们将发布应用，并使用发布证书对我们的 APK 进行签名，混淆代码以防止被反编译。我们将上传到 Play 商店，并介绍在应用发布过程中需要注意的关键点。

• 构建变体

• 营收化

  • 广告盈利的关键点

  • 添加广告

• 发布

  • 混淆和签名

  • 使用 Gradle 导出

• 上传到 Play 商店

使用构建变体

为了解释在 Android 上通过广告实现盈利的机制，我们将在应用中添加广告，但在这一步之前，我们会设置一个构建过程，允许我们导出两个版本：付费版本和免费版本。这种策略在 Play 商店中很常见（提供一个带有广告的免费版本和一个不带广告的付费版本），这样所有用户都可以免费使用该应用，但不喜欢广告并希望支持应用的用户可以选择购买付费版本。

实现这一策略还有第二种方法，即只创建一个版本，并在应用内提供购买附加组件以移除广告的选项，通过应用内购买产品来实现。这种方式的缺点是，您的应用在 Play 商店中不会列为免费应用；它会被归类为“提供应用内购买”，因此可能有些用户对此感到不适应，或者家长不允许孩子使用付费应用或包含支付的应用。第二个问题是应用内购买不容易实现；这个过程非常复杂，涉及许多步骤，包括设置服务、在 Play 商店中创建产品、从应用中消费这些产品，以及设置一个测试环境，我们可以在不产生费用的前提下测试购买。

构建变体是构建类型和产品风味的组合。

如果我们有构建类型 A 和 B，以及产品风味 1 和 2，那么结果将产生以下构建变体：

A 1
A 2
B 1
B 2

为了更好地理解这一点，我们可以了解构建类型和构建风味是什么，以及如何创建它们。

创建构建类型

构建类型允许我们为调试或发布目的配置应用程序的打包。

让我们先看看我们的build.gradle文件：

buildTypes {
  release {
    minifyEnabled false
    proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
  }
}

在build.gradle文件中，我们可以看到发布构建类型有两个属性，我们将在本章末尾解释它们。

默认情况下，我们有两种构建类型：调试（debug）和发布（release）。即使我们没有看到调试构建类型，所有变体也将在发布和调试模式下生成。

我们可以创建更多具有不同参数的构建类型；我们可以使用的参数之一是：

• 签名配置

• 调试签名标志

• 更改版本名称或包名后缀

这意味着我们可以使用不同类型的证书来启用或禁用调试模式，并且可以有不同的包名。

构建类型并不是用来创建我们应用程序的不同版本，比如演示版或完整版，免费或付费等等。为此，我们有产品风味。每个构建类型都应用于每个构建风味，就像我们之前看到的，创建一个构建变体。

产品风味

我们将创建两个产品风味，并在build.gradle中使用以下代码声明它们：

productFlavors {
  paid {
    applicationId "com.packtpub.masteringandroidapp"
  }
  free {
    applicationId "com.packtpub.masteringandroidapp.free"
  }
}

我们有一个付费风味，这是没有广告的应用程序，还有一个名为免费（free）的风味，这是带有广告的免费版本。对于每个产品风味，我们可以在项目的../src/级别创建一个文件夹。我们的付费版本默认是主要的，所以不需要为其创建文件夹。

这样，我们就可以为每个构建版本使用不同的类和资源，甚至可以有不同的AndroidManifest.xml文件。我们的应用程序将在main文件夹中共享付费版本和免费版本的通用代码，在free文件夹中包含特定于广告的代码。

要在不同的版本之间切换，我们只需更改构建变体窗口中的下拉菜单，如下面的屏幕截图所示：

选择一个构建变体后，我们可以运行应用程序或导出它，相应地运行或导出所选的风味。这些可以配置为具有不同的包名和不同的版本名称。

现在，我们将看看如何向免费版本添加特定代码，这些代码不会包含在主付费版本中。

安卓应用的货币化

我们将描述通过应用程序赚钱的三种常见方式。

首先，我们可以在 Play Store 中为应用程序定价销售。在某些情况下，为你的应用收费比提供带有广告或应用内产品的免费应用更有意义。如果你为少数用户创造了具有大价值的应用，你绝对应该考虑这个选项。例如，如果我们发布一个为建筑师专业设计房屋的应用，我们会知道我们的应用不会被数百万用户下载；它是针对寻求高质量软件的特定目标受众。我们无法通过广告获得足够的利润，而我们的用户将愿意为使他们的工作更轻松的软件支付一笔不错的费用。要求用户预先支付费用总是存在风险的；即使用户可以选择退还应用，他/她可能也不够吸引人去尝试。这就是为什么我们应该考虑第二种模式。

第二种模式被称为免费增值模式。我们发布一个免费的应用程序，但其中包括应用内购买。同样以设计房屋的应用为例，我们可以提供三种免费设计，以便当用户对我们的产品感到满意时，我们可以要求他/她购买一次性许可或订阅以继续使用该应用。这在游戏中非常常见，你可以为你的角色购买物品。正是在游戏中，我们可以看到这个模式也可以与第三种模式结合以获得尽可能最大的收益。

盈利化的第三种模式是广告模式；我们在应用中放置广告，当用户点击它们时，我们获得收入。我们可以使用不同类型的广告——从全屏广告到底部的小横幅。我们将关注这个模式。实施它比你想象的要容易。但在实施之前，我们需要解释诸如CPC（每次点击成本）、CTR（点击通过率）、填充率等术语，这将帮助我们选择一个好的广告平台和提供商。这对于理解指标并能够阅读图表以了解应用中的广告表现也是必要的。在不同的地方放置广告可能会改变收入；然而，我们需要在不烦扰用户的情况下最大化收入。如果我们为用户提供以小额费用通过应用内产品或无广告的付费版本移除广告的选项，我们可以增加广告的数量。如果用户知道他们有选择，这对他们来说是最好的。如果他们选择与广告共存，这是他们的决定，它不会像我们在没有移除选项的情况下放置大量广告那样让他们感到烦恼。

广告盈利化的关键点

我们将解释理解广告盈利化如何运作的基础知识。在这个业务中有一些带有缩写的概念，初学者可能会感到困惑。

一旦我们在广告平台上注册，我们就会看到一个关于我们应用的统计数据报告页面。以下就是来自广告网络AdToApp的仪表板示例：

在这里，我们可以看到请求、填充率、展示量、点击量、CTR、eCPM 和收入。让我们逐一考虑它们。

请求是指我们的应用向广告网络请求广告的次数。例如，如果我们决定在应用开始时添加一个全屏广告，那么每次启动应用时，都会向服务器发送一个请求以获取广告。

我们的应用中并没有实际的广告；我们拥有的是一个占位符、一个框架和一个AdView，它将由广告网络提供的内容填充。有时，在请求时刻广告网络可能没有广告给我们，这就是下一个概念重要的原因。

填充率是通过已投放广告数量除以请求广告数量得出的百分比。例如，如果我们启动应用十次，只收到五次广告返回，那么我们的填充率就是 50%。在一个好的广告网络中，我们希望填充率是 100%。我们希望展示尽可能多的广告，并且有好的 CPC。

CPC，即每次点击成本，是指用户在我们的应用中每次点击广告时我们能赚到的钱；这个数值越高，我们获得的收入越多。广告商决定广告的 CPC。一些广告商可能愿意为每次点击支付更多的费用。

许多低 CPC 的点击并不一定比少数高 CPC 的点击更好。这就是为什么我们拥有的广告质量很重要。

展示量是指广告向用户展示的次数。在之前的例子中，如果有十次广告请求，其中五次失败，我们就会有五次展示量。如果用户没有点击，展示量不会产生收入。

点击量是指用户点击广告的次数。这是基于 CPC 产生收入的部分。因此，五次点击，每次点击 0.5 美元，将会产生 5x0.5，即 2.5 美元。

CTR，即点击通过率，是通过点击量除以展示量得出的百分比。如果我们有 100 次广告展示并获得一次点击，我们的 CTR 将是 1%。这个数值通常在 5%以下；用户不会点击他们看到的每一个广告，如果你通过强制用户点击广告来作弊，比如Admob这样的广告平台可能会取消你的账户和支付。假设我们在应用开始时显示一个对话框，要求用户点击广告以继续使用我们的应用。这将基本上给我们带来 100%的 CTR；每次展示都会有点击，这是不允许的。在任何情况下，我们都不可以推广点击。

广告提供商希望他们的广告能被对其感兴趣的人看到；他们不希望为那些对广告不感兴趣、一秒钟后就会关闭广告的人的点击付费。可能的情况是，你有一个高的点击率（CTR），因为你在应用中有一个好的广告位置，而且每个用户都对广告感兴趣。如果发生这种情况，你将不得不向你的广告网络解释，或者像Admob这样的广告网络可能会关闭你的账户。但我们也不应该对他们太不公平；他们这样做是因为他们发现很多人试图破坏规则，这样一个庞大的公司无法专注于个人，所以他们需要有客观的筛选机制。

其他广告网络公司在这方面更加灵活；他们通常会为你分配一个代理人，你可以通过 Skype 或电子邮件频繁联系他，如果遇到任何问题，他们通常会通知你。

eCPM 代表“每千次展示的有效成本”。它是通过将总收入除以总展示次数（以千为单位）来计算的。这基本上是通过一个数字快速了解你表现如何的方法——非常有助于比较广告网络。这个数字通常在\(0 到 3\)之间。

我们需要考虑的是，这并不包括填充率。它是每千次展示的成本，而不是每千次请求的成本。一个 50%填充率的三美元 eCPM 与 100%填充率的一块半美元 eCPM 是相同的。

使一个广告网络变得优秀的是高填充率和高 eCPM。我们需要这两个指标都高；如果点击费用昂贵但填充率不足，广告将不会产生任何收入，因为它们根本不会被展示。

AdToApp的团队制作了一张很好的图来解释这一点：

这张图展示了我们一直在讨论的内容；一个高 eCPM 但低填充率的优质广告网络被表现为一座高但空荡荡、灯光熄灭的大楼。

理论部分我们已经讲完了，现在可以开始集成广告解决方案了；在这种情况下，我们将选择 AdToApp。

使用 AdToApp 添加广告

没有办法知道哪个广告提供商更适合你；你能做的最好的事情就是尝试不同的广告提供商，并查看统计数据。

根据我们的经验，我们喜欢使用 AddToApp，除了因为它良好的投放效果外，它的集成过程非常简单，即使你的应用中已经有其他网络广告，也可以轻松加入。因此，衡量其性能真的很容易。

在这本书中使用它与MasteringAndroidApp非常合适，因为它允许我们使用不同类型的广告，包括全屏广告、横幅、视频等等。

有超过 20 个不同广告网络的调解器，因此包含他们的 SDK，我们将能够访问许多保证高填充率的广告。关于他们的 eCPM，他们会分析哪个网络能为你带来更好的结果；因此，如果他们可以从多个网络投放广告，他们将投放效果更好的广告。

我们可以开始创建一个账户，地址是adtoapp.com/?r=OZ-kU-W9Q2qeMmdJsaj3Ow。

创建账户后，我们将使用我们应用的包名创建一个应用。

我们将点击 SDK 按钮以下载他们的 SDK 并获得集成配置值。

集成非常直接；SDK 将包含一个AdToAppSDK.jar文件，我们需要将其复制到libs目录中。我们还需要在build.gradle中添加 Google Play 服务和支持库v7，但我们已经有了这些。

我们需要在清单中添加基本权限，我们已经有这些了，使用以下代码：

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />

然后，我们需要在清单中添加额外的必要资源，可以从同一网站复制，它包含我们账户的密钥。你可以在以下截图所示的第一部分找到它们：

最后，我们可以看看如何实现插屏广告和横幅广告或激励广告。激励广告是游戏中弹出的一种广告，提示观看此视频并获得（金币、宝石等）。是否观看这些广告完全取决于用户是否想要奖励：

如果我们选择插屏广告和横幅广告，我们需要根据是否只需要视频广告、只需要图片（横幅）广告，或者插屏中同时需要图片和视频广告来初始化它们。

在网站上，根据你想要的广告类型，将显示必要的代码。

SDK 非常灵活；我们可以更进一步，设置回调以了解横幅广告何时加载和点击。这使我们能够跟踪广告中的点击次数，并验证它们与 AdToApp 控制台中的是否相同，从而使过程透明化。

如果我们需要额外的帮助，我们可以在 SDK 中激活日志，它将在出现任何问题时通知我们。

现在，记住我们在本节开始时提到的最佳实践，即最大化广告数量而不过多打扰用户，并在你的应用中实施这些实践，开始获得收益！

将我们的应用发布到 Play 商店

最后，我们的应用准备好了！这是开发新应用时最棒的瞬间；是时候将其上传到 Play 商店，获取用户的反馈，并希望获得成千上万的下载量。

我们需要将应用导出为 APK 文件；为了上传到 Play 商店，它必须使用发布证书进行签名。这一点非常重要；一旦应用程序用证书签名，如果我们将其上传到 Play 商店，并在将来想要上传新版本，它必须使用相同的证书进行签名。

我们在发布过程中会创建这个证书。它需要一个别名和密码，请确保你记住这些细节并将证书文件保存在安全的地方。否则，假设你的应用得到了好的评分和大量的下载，当你想要更新版本时，如果没有证书或忘记了密码，那就无法更新。在这种情况下，你不得不以上传一个具有不同包名的全新应用，并且从零下载和零评分开始。

代码混淆

在发布应用时，还需要考虑的另一个重要事项是代码混淆。如果我们导出应用而不混淆代码，任何人都可以下载 APK 并反编译它，使他们能够看到你的代码，如果其中有 Parse IDs、服务器访问细节、GCM 项目编号等，这可能会成为安全问题。

我们可以使用 Proguard 来混淆代码。Proguard 是 Android 构建系统中包含的一个工具。它混淆、缩小和优化代码，移除未使用的代码，并重命名类、字段和方法，以防止逆向工程。

注意类和方法的重命名，这可能会影响你的崩溃和错误报告，因为堆栈追踪将会被混淆。然而，这不是问题，因为我们可以在发布应用时保存一个映射文件，用它可以重新追踪，这将允许我们将崩溃和报告转换成可读的、未被混淆的代码。

要激活 Proguard，我们需要在 buildTypes 中将 minifyEnabled 属性设置为 true。你可以执行以下代码来实现这一点：

buildTypes {
  release {
    minifyEnabled true
    proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
  }
}

在我们的项目中，有一个 proguard-rules.pro 文件，我们可以在混淆时考虑添加规则。例如，如果我们混淆一些第三方库，它们可能无法正常工作，并且不混淆这些库是没有风险的，因为它们不是我们创建的；我们只是将它们添加到我们的项目中。

为了防止第三方库被混淆，我们可以添加 -keep 规则以及 -dontwarn 规则来忽略警告。例如，我们添加了 calligraphy 以使用自定义字体；这样我们可以在混淆期间忽略它：

# DONT OBFUSCATE EXTERNAL LIBRARIES

# CALLIGRAPHY
-dontwarn uk.co.chrisjenx.calligraphy.**
-keep class uk.co.chrisjenx.calligraphy.** {*;}
# TIMBER
-dontwarn timber.log.**
-keep class timber.log.** {*;}

使用 keep 和包名，我们将保留该包内的所有类。

我们将在调试模式下添加 Proguard，故意创建一个崩溃，看看混淆后的堆栈追踪是什么样子：

Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.view.View.setVisibility(int)' on a null object reference
            at com.packtpub.masteringandroidapp.SplashActivity.onCreate(Unknown Source)

我们可以将这个stracktrace复制到文本文件中，然后前往app/build/outputs/mapping/product_flavor_name/ release_or_debug/mapping.txt获取我们的mapping.txt文件。

考虑我们在<sdk_root>/tools/proguard执行以下代码的 retrace 命令：

retrace.sh [-verbose] mapping.txt [<stacktrace_file>]

在这种情况下，我们将有正确的行号显示崩溃，如下所示：

Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'void android.view.View.setVisibility(int)' on a null object reference
at com.packtpub.masteringandroidapp.SplashActivity.onCreate(SplashActivity.java:21)
at android.app.Activity.performCreate(Activity.java:6289)

记得在每次发布应用时保存mapping.txt的副本；每次发布时这个文件都会被覆盖，因此在每次发布时保存文件非常重要。或者，如果你有一个仓库，并且你为每次发布标记提交，你可以回退并再次生成相同的发布，理论上这将具有相同的映射文件。

既然我们的应用已经针对逆向工程进行了保护，我们可以继续发布流程。

导出应用

当我们导出应用程序时，我们要做的是在发布模式下创建一个 APK 文件并用证书签名。这个证书是 Play Store 中应用属于我们的证明，有了它，我们可以像之前解释的那样上传同一个应用。这次我们将导出应用并创建一个证书。

要导出我们的应用程序，有两种方法：一种是在 Android Studio 中使用 Gradle 和终端，第二种是使用 Android Studio 中的向导。我们将介绍两种方法，但首先使用第二种方法创建证书。

导航到构建 | 生成签名的 Apk；你会看到一个与以下类似的对话框：

如果我们之前导出过这个应用并创建了证书，那么只需选择路径，输入别名和密码，这将使用现有证书签署导出一个新版本的应用。

对我们来说，这是第一次导出MasteringAndroidApp，因此我们将点击创建新的…。在下一个屏幕上，我们需要选择保存证书的路径，这是一个.keystore文件。

我们还需要为keystore和一个证书内的别名设置密码。对于有效日期，100 年应该是可以的；如果你的应用比你活得更久，那就不是你的问题了！最后，在这里至少需要一个字段填写个人信息：

最后，它会询问我们想要导出哪个版本的应用，并且会创建.apk文件，同时指出文件的路径。

这种方法很直接，但还有一种自动化的方法可以使用命令行和 Gradle 导出应用；例如，如果我们想用 Jenkins 构建应用，这会非常有用。

为此，我们需要在build.gradle中添加一个签名配置，这样当自动生成应用时，它会知道要使用哪个keystore以及哪个别名和密码。以下代码将有助于实现这一点：

signingConfigs {
  release {
    storeFile file("certificate.keystore")
    storePassword "android"
    keyAlias "android"
    keyPassword "android"
  }
}

不用说，这可能导致安全问题；密码写在build.gradle中，证书文件包含在我们的项目中。如果我们这样做，我们需要确保项目安全。如果这是一个关注点，你可以使用以下代码在运行时读取密码和别名：

storePassword new String(System.console().readPassword("\n\$ Enter keystore password: "))
keyAlias System.console().readLine("\n\$ Enter key alias: ")
keyPassword new String(System.console().readPassword("\n\$ Enter key password: "))

当我们运行生成签名 APK 的命令时，系统会要求我们输入密码别名和别名密码。我们可以使用以下代码行来完成这个操作：

>./gradlew assembleRelease

应用导出后，我们可以继续最后一步：上传到 Play 商店。

将我们的应用上传到 Play 商店

要发布应用，我们需要一个 Google 开发者账户。如果你没有，可以从play.google.com/apps/publish/获取一个。

创建发布商账户

创建发布商账户的第一步是输入基本信息，并阅读并接受开发者分销协议。第二步是支付 25 美元的开发许可费用以创建账户。这是我们发布应用所需支付的全部费用，只需一次性支付——一次付费，终身许可。考虑到 iOS 上每年要支付 99 美元，我们不应该抱怨。

最后的第三步需要开发者的名字，该名字将显示在我们的应用程序名称下方。以下是 Google Inc 的示例：

我们还需要电子邮件、手机号码以及可选的网站。根据谷歌的说法，这是为了在有人需要就发布的内容联系我们时使用。

Google Play Developer 控制台

当我们打开发布商账户时，如果我们还没有发布任何应用，我们将看到开发者控制台四个主要功能，如下面的图片所示：

第一个选项是发布一个 Android 应用，这也是我们将在书中遵循的选项。然而，在此之前，我们将快速描述其他需要考虑的选项。

第二个选项是关于 Google Play 游戏服务。如果你开发了一个游戏，希望玩家保存并提交他们的分数，并有一个分数排名，你将需要一个服务器来存储这些分数并检索它们，甚至可能需要玩家用户名和登录。游戏服务为我们完成这些工作。

它提供了一个 API，跨游戏共享，并与用户的 Google 账户关联，我们可以管理排行榜和成就。它甚至提供了实现多人游戏（包括实时多人和回合制）的 API 和基础设施。

左侧底部的第三个选项是关于分享开发者控制台的。我们可能希望允许其他开发者更新应用。例如，在公司中，这将有助于那些负责设置应用名称、描述、图片和总体市场营销的人员，以及其他负责应用上传和开发的人员。我们可以配置对控制台和特定应用的访问权限。

第四个也是最后一个选项是商家账户；如果我们想要销售付费应用或应用内产品，就需要这个。这是来自付费应用的商家账户示例；我们可以看到完成的支付和取消的支付。如果用户购买了我们的应用，他/她在两小时内可以申请退款，如果他/她不喜欢它的话。

因为我们还没有发布应用，所以我们看到了一个包含四个主要选项的空白开发者控制台；如果我们有已发布的应用，我们会看到这样的界面。在这种情况下，发布按钮位于顶部：

在初始屏幕上，我们可以看到不同的应用，无论它们是免费还是付费，活跃安装数和总安装数。活跃安装意味着目前拥有该应用并且下载后没有卸载的人数。总安装数意味着应用被安装的所有次数的总计。

我们还可以查看评分和崩溃次数。如果我们点击应用并进入详细视图，可以查看更多详细信息，比如用户的评论和错误崩溃报告。

发布应用

继续上传过程，当我们点击+ 添加新应用时，会被要求输入名称和默认语言。在此之后，我们可以选择通过上传 APK 或准备商店列表来开始流程。

这包括两个不同的过程：一个是上传 APK 文件，另一个是设置应用的标题、描述、图片、是否付费等——所有在 Play 商店中展示的不同选项。

让我们先从上传 APK 文件和不同的测试组开始。

上传 APK 文件

请记住，当我们上传 APK 时，我们应用的包名在 Play 商店中必须是唯一的；如果我们想要更新之前由我们发布的 app，并且使用初始下载签名的证书与新的 APK 签名证书相同，那么我们可以上传具有现有包名的 APK。

当我们点击上传 APK时，首先注意到的三个不同标签页的名称分别为：生产环境、测试版和Alpha 版。

我们可以在两个测试组以及生产环境中发布我们的应用程序。生产意味着它在 Play 商店中发布；它是公开的，对所有人可见。一段时间以来，这曾是开发者控制台中的唯一选项，直到他们增加了分阶段推出的功能。

分阶段推出允许我们将应用程序发布给一组有限的用户。为了选择这些用户，我们有不同的选项；我们可以通过电子邮件邀请这些用户，分享链接，或者创建一个 Google 群组或 G+社区，邀请用户加入该群组，并将应用程序的链接分享给他们。只有这些用户才会在 Play 商店中看到应用程序。这对于在应用程序向全世界发布之前从一些用户那里获得反馈非常有用，当然，也可以防止应用程序在生产环境中出现错误和差评。我们还可以选择在生产环境中发布我们应用程序的用户百分比；例如，如果我们有百万用户，我们可以首先向 10%的用户发布，并在进行大规模发布之前再次确认一切是否正常。

我们的应用程序可以在不同的阶段有不同的版本；例如，我们可以发布版本 1.0.0，1.0.1 进行 beta 测试，1.0.2 进行 alpha 测试。我们可以从 alpha 阶段滚动到 beta 阶段，从 beta 阶段滚动到生产阶段，但我们不能回滚。

我们现在要解释的概念非常重要。一旦我们发布了应用程序的一个版本，我们就无法回到之前的发布版本。可能会出现这样的情况：我们在 Play 商店中有一个应用程序的正常运行的版本，我们开发了一个新版本，在我们的设备上运行良好，我们认为它已经准备好上传了。现在是周五下午，我们不想进行测试，因为我们会想，“哦，我相信它没问题。我只是改了两行代码，不会影响任何东西”。我们上传了版本 1.0.4。几小时后，我们开始收到来自 Play 商店的崩溃报告。这是恐慌的时刻；我们现在能做的唯一事情是撤销当前应用程序的发布，以防止更多损害，并尽快开始修复。然而，如果修复不容易，最明智的做法是再次生成最后一个已知正常工作的版本（1.0.3），将版本号和代码增加到 1.0.5，并将其上传到 Play 商店。

然而，这可能会变得更糟；如果我们有一个数据库，并且其结构从 1.0.3 更改为 1.0.4，如果我们的代码还没有准备好接受从 1.0.4 降级到 1.0.3（更名为 1.0.5）的数据库，我们知道我们整个周末都要工作，只是为了在周一早上被解雇。总之，我们的观点是，预防胜于治疗；因此，使用分阶段推出，在发布之前进行所有必要的测试，并避免在周五下午发布，以防万一。

准备商店列表

对于开发者来说，准备商店列表可能是最无聊的部分，但为了发布应用程序，这是必须要完成的；有一些我们不能跳过的必填资产和字段。

首先，我们需要为我们的应用准备一个标题，一个最多 80 个字符的简短描述和一个最多 4000 个字符的长描述。标题将是我们搜索应用时首先看到的内容；简短描述可以在例如浏览应用时的平板电脑上看到。这是我们应用的elevator pitch，我们需要在这里描述其主要功能。

长描述将在我们查看此应用的详细视图时显示。为了在更多搜索中出现并获得可见性，在描述中识别并添加与应用相关的关键词是很好的做法。使用不相关关键词吸引下载是被 Google 禁止的，如果你这样做，你将在开发者控制台收到警告，并且你的应用在重新获得批准和发布之前需要做出一些更改。

在这一点上，我们可以选择国际化我们应用的列表，重复这些字段，用我们想要的任何语言，它们将根据用户的语言自动显示在不同的语言中。

下一步是开发图形，我们需要在这里进行截图。截图可以通过设备上的按键组合轻松完成；例如，在三星 Galaxy 3 上，这是通过同时按下音量减和菜单键完成的。也可以通过在 Android Studio 中选择 Android 视图中的相机图标来获取截图。

除了截图，我们还需要一个 512 x 512 高分辨率的图标；这必须与上传版本中我们应用所使用的图标相同或非常相似，否则会收到警告。因此，最好始终以 512 x 512 的尺寸创建图标，然后将其缩小以用于我们的应用。反其道而行将导致放大后图像质量变差。以下是图标显示的一个示例：

我们需要准备的最后一张图片是功能图。这是一张 1024 x 500 的图片，展示了我们应用的特点。这是在我们应用在 Google Play 上展示时会被用到的图片。它将在 Play 商店应用中展示；如果我们有促销视频，即使视频没有播放，功能图也会显示。

我们需要继续进行分类；根据我们的应用是否为游戏或应用程序，我们需要选择不同的类别。如果你不确定选择哪个类别，可以在 Play 商店查看类似你应用的 app。

此后，我们需要选择内容评级；从 2015 年 5 月开始，每个应用都需要有新的评级系统。根据谷歌的说法，这个新的内容评级为向用户传达熟悉且与本地相关的内容评级提供了一种简单方式，并通过针对你的内容定位合适的目标受众来帮助提高应用参与度，具体内容可参考support.google.com/googleplay/android-developer/answer/188189。

我们的联系方式会自动填写，所以我们还需要做的就是接受隐私政策，然后点击定价与分发。

在这里，我们决定应用是免费还是付费；这一步无法撤销。如果应用是付费的，我们可以设定一个价格，谷歌会将它转换成不同国家的不同货币；尽管如此，我们可以为每个国家设定不同的价格。我们可以选择加入不同的开发者群体；例如，如果我们开发了一个儿童应用，我们可以将其包含在为家庭设计中。这将增加我们在儿童专区被突出显示的机会，并分发到与儿童应用相关的第三方网络。

在这一部分，我们还可以选择我们希望应用分发的国家。这也可以用作首次发布应用时的分阶段发布策略。

完成以上所有步骤后，我们将能够通过点击右上角的发布来发布我们的应用。

如果按钮不可用，你可以点击为什么我不能发布？，它将在左侧列出要求。应用发布后，可能需要几个小时才能在 Play 商店中显示。确定应用是否已发布的最简单方法是使用包名在 URL 中导航到我们的应用。在我们的例子中，URL 将是 play.google.com/store/apps/details?id=com.packtpub.masteringandroidapp。

就这样！我们从初学者到更高级别完成了这本书，拥有足够的知识来上传一个设计精良、构建完善、向下兼容并实现盈利的应用。

我们祝愿你的应用成功，并希望你能打造出下一个《愤怒的小鸟》或下一个 WhatsApp！

注意

感谢购买并完成这本书。对于建议、改进或有任何反馈，请毫不犹豫地联系我 <Antonio@suitapps.com> 或在 Twitter 上关注我 @AntPachon。

总结

在本书的最后一章，我们开始学习如何创建应用的不同版本，通过结合构建类型与产品风味来获得构建变体。

之后，我们学习了如何对我们的应用程序进行货币化，添加了不同类型的广告，并解释了广告货币化的关键要点。

我们还从 Android Studio 和使用 Gradle 命令行导出了应用程序，进行了混淆并使用发布证书进行了签名。

最后，我们在 Play 商店上传并发布了我们的应用程序。