ADK-Arduino-入门指南-全-

ADK Arduino 入门指南（全）

原文：Beginning Android ADK with Arduino

协议：CC BY-NC-SA 4.0

零、前言

这本书解释了如何在 Android 开放附件开发工具包(ADK)的帮助下为与外部硬件通信的 Android 设备建立项目。您将学习如何配置您的开发环境，如何选择硬件并相应地设置电路，以及如何对 Android 应用和硬件进行编程。这本书将教你实现自己想法所需的基础知识。通过几个项目，您将了解 ADK 兼容的硬件板、传感器和致动器的功能，以及如何通过 Android 应用与它们进行交互。

谁应该读这本书

一般来说，任何对移动编程和硬件修补感兴趣的人都会喜欢 ADK 提供的众多可能性。有 Android 编程经验者优先，但不是完全必要。但是，您应该对 Java 编程语言和一般编程基础和算法有一个基本的了解。如果你以前做过电路实验，也会有所帮助。但是，如果您还没有，请不要担心，我将指导您完成电路设置，这样您就不会意外损坏您的硬件。这些项目被设计成建立在彼此的基础上，这样你就可以在这个过程中应用你已经学到的东西。总而言之，你应该享受实验和创新的乐趣。

需要额外资源

除了你的计算机(你需要它来编程)和一个 ADK 兼容的硬件板，你还需要一套软件和硬件组件来完成本书中解释的项目。

硬件组件大多是基本部件，如 led、电线以及其他无源和有源组件。我试图通过选择只需要基本的、负担得起的和容易获得的部件的项目来保持硬件成本最低。在特定项目中需要的地方详细描述了硬件部分。我预先编制了一份你在整本书中需要的所有必要硬件部件的清单，这样你就可以先把所有部件组装起来。没有什么比开始一个项目，却要等一个星期才能收到某些零件更让人恼火的了。

1 × ADK 兼容开发板(有关开发板的具体信息，请参考第一章)
1 ×试验板
试验板电线或普通电子电线
1 × LED，工作电压为 5V
1 ×红外发射器或红外 LED
1 × IR 检测器或 IR 光电晶体管
1 ×按钮或开关
1 ×电位计
1 ×压电蜂鸣器
1 ×照片性别歧视
1×4.7kω热敏电阻
1 × NPN 晶体管(BC547B)
1 ×伺服，工作电压为 3V 或 5V
1 × DC 电机，工作电压为 3V 或 5V(如果> 5V，则需要外部电池)
1 ×卷家用铝箔
1 ×胶带
电阻(220ω、10k 和 1Mω，或一整套)

所有的软件组件都是免费的，其中一些甚至是开源的。必要的软件列在第一章中，我提供了一个分步安装指南来正确设置您的工作环境。当您以后处理项目代码时，您可以在阅读本书的同时自己键入源代码示例，或者您可以直接从 Apress 网站下载源代码，以使用本书中的代码片段作为参考。你可以在[www.apress.com](http://www.apress.com)找到代码。

轮廓一览

这本书分为十章。在介绍了开发环境和 ADK 兼容板的设置后，您将立即投入到第一个项目中，熟悉设置 ADK 实验的过程。在很大程度上，以下章节相互借鉴，将教会你从制作简单的 LED 闪烁到设计利用不同传感器的高级报警系统，以及使用 Android 设备的功能。下面是章节的快速总结:

第一章:简介:简介给你一个关于 ADK 的概述，并展示一些支持 ADK 的硬件板。它还可以帮助你建立你的开发环境，这样你就可以跟踪每一章中的项目。
第二章 : Android 和 Arduino:相互了解:本章将指导您编写必要的软件，在您的 ADK 板和 Android 设备之间建立连接。您还将学习在两台设备之间实现通信的基础知识。
第三章:输出 : ADK 开发板为输出目的提供不同的手段。本章中的项目将向您展示如何通过控制 LED 的状态，在数字和模拟环境中利用这些输出特性。你将使用你的 Android 设备来打开和关闭 LED，你将能够控制它的强度。
第四章:输入:ADK 板的输入能力使你能够从传感器读取数据或测量施加到其输入引脚的电压变化。本章的项目将向您展示如何在数字和模拟环境中读取和处理接收到的输入值，方法是用一个按钮改变数字输入引脚的引脚状态，以及用一个电位计改变模拟输入读数。按下一个按钮，你的 Android 设备将振动给用户反馈，你将看到一个进度条模拟输入读数的变化。
第五章:声音:本章将向您展示如何使用压电蜂鸣器作为多用途组件，不仅可以产生声音，还可以感知附近的声音。您将使用您的 Android 设备来选择生成声音的频率，并且您将构建一个敲击传感器，在每次敲击时改变应用的背景。
第六章:光强度感应:识别周围环境光线的变化对很多应用都很有用。本章的项目将向你展示如何使用光敏电阻来感知这些照明变化。您的 Android 设备将评估这些变化，点亮或调暗屏幕，以适应当前的照明水平。
第七章 : 感温:电子设备经常要在极端条件下工作。因此，记录当前温度有时是必要的。本章将向您展示如何在热敏电阻的帮助下感应和计算当前温度。当前温度值将使用 Android 系统的 2D 图形功能绘制到您的 Android 设备的屏幕上。
第八章:触觉:触摸界面已经成为日常生活的一部分。当你有一个触摸界面来控制它时，每个项目都感觉更好。本章将向您展示如何构建自己的低成本触摸传感器。您将使用您的 Android 设备和触摸传感器来构建一个简单的游戏节目蜂鸣器，当被激活时，它会发出嗡嗡的声音并振动。
第九章:让东西动起来:机器人可能是爱好电子产品中最令人兴奋的实验品。由于机器人需要一些运动方式，你需要了解可以帮助你的执行器。本章将向你展示如何控制伺服和 DC 汽车，使你未来的项目以任何方式前进。您将使用您的 Android 设备的加速度传感器，通过沿 x 轴和 y 轴倾斜您的设备来控制您的致动器。
第十章:警报系统:在最后一章，你将利用你之前学到的知识来建造你自己的警报系统。在两个项目中，你将了解两种不同的触发警报的方式，一种是通过倾斜开关，另一种是通过自建的红外光栅，你还将了解你的 Android 设备如何增强警报系统。您还将学习如何通过 SMS 发送文本消息，并使用设备的摄像头拍摄可能的入侵者。

一、简介

2011 年 5 月，谷歌举行了年度开发者大会 Google IO，向大约 5000 名与会者展示了其最新技术。除了对谷歌 API 或核心搜索技术等已经众所周知的技术进行改进，谷歌还将重点放在了两大主题上:Chrome 和 Android。一如既往，Android 平台的最新进展得到了展示和讨论，但谷歌稍后在 Android keynote 上宣布的内容有点令人惊讶:谷歌的第一个 Android 设备与外部硬件通信的标准。Android 开放附件标准和附件开发工具包(ADK)将是与硬件通信和为 Android 设备构建外部附件的关键。为了鼓励开发，谷歌向感兴趣的与会者分发了 ADK 硬件包，并展示了一些 ADK 项目的例子，如将数据传输到连接的安卓设备的跑步机和可以用安卓设备控制的巨大倾斜迷宫。活动结束后不久，第一个 DIY 项目浮出水面，这已经显示了 ADK 的巨大潜力。

由于我不能参加这次活动，我没有机会得到其中的一个工具包；当时，谷歌 ADK 版只有一家经销商，而这家经销商并没有为如此大的需求做好准备。这并没有阻止我自己建立一个替代方案，并体验 Android 开发这一新领域的乐趣。随着时间的推移，越来越多的分销商生产了最初的谷歌 ADK 板的衍生产品，在大多数情况下，这些产品更便宜，而且只提供让你一起开始黑客项目的基础。

您可能只想一头扎进去，但是首先您应该了解 ADK 的具体情况，并设置您的开发环境。你不会在不知道怎么做或者没有合适的工具的情况下盖房子，是吗？

什么是 ADK？

附件开发套件(ADK)基本上是一个微控制器开发板，它遵循 Google 创建的简单开放附件标准协议作为参考实现。尽管这可能是任何符合 ADK 兼容规范的主板，但大多数主板都基于 Arduino 设计，这是 2005 年创建的开放式硬件平台。这些板是基于 Arduino Mega2560 和 Circuits@Home USB Host Shield 实现的支持 USB 的微控制器板。然而，还有其他已知的 ADK 兼容板设计，如基于 PIC 的板，甚至普通 USB 主机芯片板，如 FTDI 的 VNCII。Google 决定在 Arduino Mega2560 设计的基础上构建其参考套件，并以开源方式提供软件和硬件资源。这是一个聪明的举动，因为 Arduino 社区在过去的几年里发展迅速，使得设计师、爱好者和普通人可以很容易地将他们的想法变成现实。随着 Android 和 Arduino 爱好者群体的不断增长，ADK 有了一个很好的开始。

为了与硬件板通信，支持 Android 的设备需要满足某些标准。随着 Android Honeycomb 版本 3.1 和 backported 版本 2.3.4 的推出，引入了必要的软件 API。然而，这些设备还必须配备合适的 USB 驱动程序。该驱动程序支持通用 USB 功能，但特别支持所谓的附件模式。附件模式允许没有 USB 主机功能的 Android 设备与外部硬件通信，外部硬件反过来充当 USB 主机部分。

开放附件标准的规范规定，USB 主机必须为 USB 总线提供电源，并且可以枚举连接的设备。根据 USB 2.0 规范，外部设备必须在 5V 下提供 500mA 用于 Android 设备的充电目的。

ADK 还为开发板提供固件，固件以一组源代码文件、库和一个演示套件草图的形式出现，演示套件草图是 Arduino 术语，指项目或源代码文件。固件关心 USB 总线的枚举，并寻找与附件模式兼容的连接设备。

谷歌还为 Android 设备提供了一个示例应用，可以轻松访问和演示参考板及其传感器和执行器的功能。如果您使用的衍生板没有相同种类的传感器，您仍然可以使用示例应用，但您可能希望将代码剥离到通信的基本部分。

当你在 ADK 建立一个硬件项目时，你是在打造一个所谓的安卓配件。您的硬件项目是 Android 设备的附件，例如，键盘是 PC 的附件，不同之处在于您的附件为整个系统提供动力。配件需要支持已经提到的设备电源，并且它们必须遵守 Android 配件协议。该协议规定附件遵循四个基本步骤来建立与 Android 设备的通信:

附件处于等待状态，并试图检测任何连接的设备。
附件检查设备的附件模式支持。
如有必要，附件会尝试将设备设置为附件模式。
如果设备支持 Android 配件协议，则配件会建立通信。

如果你想了解更多关于 ADK 和开放附件标准的信息，请查看位于[developer.android.com/guide/topics/usb/adk.html](http://developer.android.com/guide/topics/usb/adk.html)的 Android 开发者页面。

硬件开发板

本节将概述目前市场上各种兼容 ADK 的开发板。请注意，我不能保证这个列表的完整性，因为社区发展的速度如此之快，以至于新的委员会可能会随时出现。在撰写本文时，我将集中讨论最受欢迎的主板。

谷歌 ADK

谷歌 ADK 是在 2011 年 5 月的谷歌 IO 上展示的参考套件，它是第一个遵循开放附件标准的主板。该套件带有 ADK 基板和演示屏蔽，如图图 1-1 所示。

图 1-1。谷歌 ADK 板和演示盾

基板(图 1-2 )包含 DC 电源连接器、连接手机或平板电脑的 USB 连接器(A 型插座)以及连接电脑用于编程和调试的微型 USB 连接器(微型 B 型插座)。它的顶部安装了 Atmel 的 ATmega2560 AVR 芯片，针对 C 编译代码进行了优化，这使得它非常快速且易于编程，而不是必须用汇编语言编程的可比微控制器。ATmega2560 有一个 256 千字节的内部闪存和一个 8 位 CPU，工作频率为 16MHz。它提供 8KB 的 SRAM 和 4KB 的 EEPROM。ATmega 芯片的 IO 端口控制 16 个模拟引脚，提供 10 位输入分辨率，支持 1，024 个不同值的模数转换。默认情况下，它们的测量范围是从地到 5V。该芯片有 54 个数字引脚，其中 14 个是 PWM(脉宽调制)使能的，例如，允许 led 变暗或控制伺服系统。板的中间是一个复位按钮，用于复位板上的程序执行。该板的工作电压为 5V。虽然您可以通过 USB 电缆为电路板供电，但如果您打算控制伺服系统或驱动电机，则应该考虑使用电源适配器。

图 1-2。近距离观察谷歌 ADK 董事会

Demo Shield 是一个附加板，包含各种不同的传感器和执行器。 Shield 是 Arduino 术语，指可以放在 Arduino 基板上的扩展板。这种连接是通过可堆叠的引脚接头实现的。基板的 IO 引脚大多委托给屏蔽层的引脚，因此可以重复使用。然而，某些屏蔽可能会占用引脚来操作它们的传感器。演示屏蔽罩本身预焊有插头，因此没有额外的屏蔽罩可以堆叠在上面。这并不令人惊讶，因为 shield 使用大多数引脚来让基板与其所有传感器进行通信。由于屏蔽隐藏了基板的重置按钮，它本身包含一个按钮，因此您仍然可以使用重置功能。然而，最重要的部分是传感器和致动器，而且数量很多。

一个模拟操纵杆
三个按钮
三个 RGB LEDs
起温度传感器作用的晶体管
具有用于光感测的集成光电二极管的 IC
安卓标志形式的电容式触摸区域
两个带螺丝端子的继电器，可切换 24V 至 1A 的外部电路
三个伺服连接器

谷歌 ADK 最初是由一家日本公司为谷歌 IO 生产的。可以在[www.rt-net.jp/shop/index.php?main_page=product_info&cPath=3_4&products_id=1](http://www.rt-net.jp/shop/index.php?main_page=product_info&cPath=3_4&products_id=1)订购。价格约为 400 美元(不包括销售税)，是最贵的主板之一。

Arduino ADK

Arduino ADK ( 图 1-3 )是 Arduino 系列制造商自己生产的 ADK 兼容基板。它也基于 ATmega2560，与 Google 参考板仅略有不同。

图 1-3。 Arduino ADK 板

Arduino ADK 板还有一个 DC 电源连接器和一个 USB 连接器(A 型插座),用于连接 Android 设备。然而，编程和调试连接器与标准 USB 连接器不同(B 型插座)。重置按钮位于电路板的远端，ATmega 芯片位于电路板的中间。IO 引脚布局与 Google board 中的完全相同，并且具有相同的模拟和数字引脚特性。然而，Arduino ADK 有两个 ICSP 6 针接头，用于微芯片的在线串行编程(ICSP)。Arduino ADK 和谷歌 ADK 共享相同的引脚布局和外形，与演示盾和其他基于 Arduino 的盾兼容。

Arduino ADK 在意大利制造，可以直接从 Arduino 网站[store.arduino.cc/ww/index.php?main_page=product_info&cPath=11_12&products_id=144](http://store.arduino.cc/ww/index.php?main_page=product_info&cPath=11_12&products_id=144)订购，也可以从遍布全球的经销商[arduino.cc/en/Main/Buy](http://arduino.cc/en/Main/Buy)处订购。

它的价格约为 90 美元(不包括可能的运输成本和税收)，对于普通爱好者和硬件黑客来说，它比谷歌 ADK 更实惠。

IOIO

IOIO(发音为 yo-yo)板(图 1-4 )是一种基于 PIC 微控制器的开发板，由 Sparkfun Electronics 在开放附件标准公布之前开发。

图 1-4。火花乐趣 IOIO 板

IOIO 板设计用于所有版本为 1.5 及以上的 Android 设备。最初的固件设计旨在与 Android Debug Bridge (ADB)配合使用，后者通常在 Android 应用的开发过程中用于调试过程和文件系统操作。在开放附件标准公布后，IOIO 被更新为新的固件，以支持开放附件协议和作为后备的 ADB 协议，从而仍然支持较旧的设备。在撰写本书时，固件仍处于测试阶段。因为你需要通过 PIC 编程器更新板的固件，以使板 ADK 兼容，它可能不是一个没有经验的修补程序的完美选择。

该板的硬件特性如下。IOIO 的外形尺寸约为常规 ADK 兼容板的四分之一，这使它成为目前最小的板之一。然而，它几乎跟上了它的老大哥的众多 IO 引脚。总共 48 个 IO 引脚中有许多都有几种工作模式，这可能会使引脚分配有点混乱。

在 48 个 IO 引脚中，所有引脚都可以用作通用输入输出端口。此外，其中 16 个引脚可用作模拟输入，3 对引脚可用于 I C 通信，1 个引脚可用作外设输入，28 个引脚可用于外设输入和输出。通常，这些引脚只能承受 3.3V 电压，但 22 个引脚能够承受 5V 输入和输出。I C 引脚提供快速简单的双线接口，与传感器板等外部集成电路通信。

除 IO 引脚外，该板还提供 3 个 Vin 引脚为板供电。在电路板的底部，您可以焊接一个额外的 JST 连接器来连接一个 LiPo 电池作为电源。应提供 5V 至 15V 的工作电压。此外，它有 3 个引脚用于 3.3V 输出，3 个引脚用于 5V 输出，9 个引脚用于接地。

该板上唯一的连接器是所需的 USB (A 型插座)连接器。这是因为不需要对硬件编程，不像其他 ADK 兼容板，硬件部分需要 C 编译代码。IOIO 提供了实现所有需求的固件。你只需要通过使用高级 API 来编写 Android 部分，以便于 pin 访问。

电路板上一个有趣的组件是一个小型微调电位计，可以限制 Android 设备的充电电流，以便在电路板处于电池模式时不会消耗太多电力。IOIO 有一个 PIC 微控制器芯片，而不是大多数其他板使用的 AVR 芯片。PIC24FJ256-DA206 芯片工作频率为 32MHz，具有 256KB 可编程存储器和 96KB RAM。

IOIO 由 Sparkfun Electronics 开发，可通过 Sparkfun 网站[www.sparkfun.com/products/10748](http://www.sparkfun.com/products/10748)或其经销商订购。

运费和税之前的价格约为 50 美元，这是最便宜的主板之一，但对初学者来说不是最友好的。

seeed uino ADK 主板

seedeuino ADK 板(图 1-5 )也源自 ATmega 板，看起来与标准的 Arduino ADK 板非常相似，但乍一看，它有一些不错的额外功能。

图 1-5。 Seeeduino ADK 董事会(图片由 Seeedstudio 提供)

它有 56 个数字 IO 引脚，其中 14 个支持 PWM，16 个模拟输入引脚和 1 个 ICSP 接头。板上的连接器与最初谷歌设计中的连接器类型相同。它有一个 DC 电源连接器、一个 USB 连接器(A 型插座)和一个微型 USB 连接器(微型 B 型插座)。

与大多数其他类似 Atmega 的板的最大区别是，Seeeduino ADK 板已经随 MicroBridge 固件一起发运，因此它可以在操作系统版本 2.3.4 及以上的 Android 设备上以 ADK 模式工作，在操作系统版本 2.3.4 之前的设备上以 ADB 模式工作，这与 IOIO 非常相似。

Seeeduino ADK 板由 Seeedstudio 开发，可在该公司网站[www.seeedstudio.com/depot/seeeduino-adk-main-board-p-846.html](http://www.seeedstudio.com/depot/seeeduino-adk-main-board-p-846.html)订购，也可从其经销商处订购。

它的售价为 79 美元(不含运费和税)，这使它成为一款非常实惠但功能强大的主板。

你应该使用哪种板？

现在，您已经了解了支持开放附件标准的各种电路板，您可能想知道哪种电路板最适合您自己的项目。这总是一个难题，没有唯一的答案。你应该提前计划好你的项目，分析哪种板最合适。

如果你是硬件开发和 ADK 的初学者，你应该坚持使用最常用的板。在撰写本文时，这将是谷歌 ADK 董事会，它被分发给数百名参加谷歌 IO 2011 的开发者。如果你不是幸运地收到这些主板中的一个，并且你的预算相当紧张——这是通常的情况——考虑标准的 Arduino ADK 主板。到目前为止，我所见过的大多数黑客和创客项目都使用这两种板，如果你有需要，它们周围有一个巨大的社区可以帮助你。

表 1-1 给出了正在讨论的电路板的概况。

支持的 Android 设备

随着越来越多支持 Android 的平板电脑的推出，在 Android Honeycomb 版本中，开放附件标准作为 Android API 的一部分被引入。为了不仅支持蜂窝设备，Google 决定将必要的类移植到 2.3.4 版本，使它们也可以用于手机。较新的功能作为 Google API 附加库被反向移植。这个库基本上是一个 JAR 文件，必须包含在 Android 项目的构建路径中。

第一批获得必要版本更新并支持开放配件模式的候选产品是摩托罗拉 Xoom 和谷歌 Nexus S。其他设备很快就会跟进，这很快导致了众所周知的片段问题。通常，当涉及不同版本的操作系统时，片段通常是一个问题，但现在的问题是，即使设备有必要的操作系统版本 2.3.4 或 3.1，开放附件模式仍有可能无法在设备上工作。怎么会这样呢？问题是仅仅更新系统软件是不够的。设备的 USB 驱动程序必须与开放附件模式兼容。很多开发者更新自己的设备甚至 rooted 安装了 Cyanogen mod 这样的自制 Mod 最终运行 2.3.4 版本，却发现设备厂商的 USB 驱动不兼容。

然而，有很多设备已经过测试，据说可以在开放附件模式下完美工作，其中一些是官方的，另一些是由 DIY mods 驱动的。以下是一些已经过社区验证可与 ADK 配合使用的设备列表:

谷歌 Nexus S
谷歌 Nexus One
摩托罗拉 Xoom
钢图标 A100
钢图标 A500
LG Optimus Pad
ASUS Eee 垫转座垫 TF101
三星 Galaxy Tab 10.1
三星 Galaxy S
三星 Galaxy Ace

就个人而言，我建议使用 Nexus S 这样的谷歌开发者设备，因为这些设备对最新的 API 和功能提供了最好的支持。

设置开发环境

你对 ADK 的历史和技术细节了如指掌，但是在你的想法变成现实之前，你需要建立你的工作环境。您需要为您的 Android 设备和硬件板编写软件，让双方能够相互通信，并控制执行器或读取传感器值。编程是在两个集成开发环境(ide)的帮助下完成的。要编写 Android 应用，Google 建议使用 Eclipse IDE。Eclipse IDE 是最常见的 Java 开发 IDE，拥有最大的社区之一、各种插件和出色的支持。由于硬件板基于 Arduino 设计，您将使用 Arduino IDE 对它们进行编程，以编写所谓的草图，这些草图将被上传到板上。为了让这些 ide 正常工作，您还需要 Java 开发工具包(JDK)，它比普通的 Java 运行时环境(JRE)具有更多的功能，并且您的系统可能已经安装了它。您还需要 Android SDK 来编写您的 Android 应用。

这个分步指南将帮助您建立必要的开发环境。请严格按照您选择的操作系统的步骤操作。如果您遇到任何问题，也可以参考软件网站上的官方安装指南。

Java 开发工具包

你首先需要的是 JDK。转到[www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)并点击 JDK 下载按钮(图 1-6 )。

图 1-6。 JDK 下载页面

接受许可协议并为您的操作系统选择文件(图 1-7 )。x86 文件适用于 32 位操作系统，x64 文件必须安装在 64 位系统上，因此请确保选择正确的文件。

图 1-7。 JDK 平台下载量

您可能会注意到，Mac OS 上没有 JDK 文件。这些并没有在甲骨文网站上发布，因为苹果提供了自己版本的 JDK。JDK 应该预装在您的 Mac OS X 系统上。您可以通过在终端窗口中键入java -version来验证这一点。您应该会在终端窗口中看到您当前安装的 Java 版本。

在 Windows 上安装

下载完可执行文件后，打开它并按照指导您完成安装过程的说明进行操作。之后，您应该将 JDK 路径设置为您的 Windows PATH变量。path 变量用于方便地从系统中的任何地方运行可执行文件。否则，您将不得不总是键入完整的路径，以便从命令行执行某些东西，比如C:\Program Files\Java\jdk1.7.0\bin\java。

Eclipse 也依赖于要设置的JAVA_HOME变量。要设置系统环境变量，您必须执行以下操作。

Right-click My Computer and select Properties as shown in Figure 1-8.

图 1-8。打开系统属性对话框
On the system Properties dialog select the Advanced tab. Near the bottom you should see the Environment Variables button (Figure 1-9), which opens the variables dialog to set User and System variables.

图 1-9。打开环境变量对话框
Click New in the System Variables area and insert the following:

变量名:JAVA_HOME

变量值:C:\Program Files\Java\jdk1.7.0
点击OK。
另外选择PATH变量进行编辑(图 1-10 ，点击Edit。在其他值前面插入%JAVA_HOME%/bin;。
点击OK。
Now your JDK is set up and ready for work.

图 1-10。设置环境变量

在 Linux 上安装

为您的系统(32 位/ 64 位)下载tar.gz文件，并将该文件移动到您想要安装 JDK 的位置。通常 JDK 安装在/usr/java/中，但是请记住，您需要 root 权限才能安装到该目录中。

打开包装并安装 JDK，包括:

# tar zxvf jdk-7-linux-i586.tar.gz

JDK 安装在当前目录下的/jdk1.7.0目录中。

为了让您的系统知道您在哪里安装了 JDK，并且能够从系统中的任何地方运行它，您必须设置必要的环境变量。为此，创建一个简短的 shell 脚本放在/etc/profile.d目录中是一个好主意。

在该目录中创建一个名为java_env.sh的脚本，并将以下内容添加到脚本中:

`#!/bin/bash

JAVA_HOME=/usr/java/jdk1.7.0

PATH=$JAVA_HOME/bin:$PATH

export PATH JAVA_HOME
export CLASSPATH=.`

最后要做的事情是在新创建的脚本上设置权限，以便系统在用户登录时执行它。

# chmod 755 java_env.sh

重新登录后，将设置环境变量。

在 Mac OS X 上安装

如前所述，Mac 版 JDK 不是通过 Oracle 下载网站发布的。JDK 预装在 Mac OS X 上，但也可以通过 Apple Store 下载。如果您的环境变量JAVA_HOME和PATH尚未设置，您可以参考 Linux 安装中使用的相应步骤，因为 Mac OS X 也是基于 Unix 的。您可以在终端窗口中使用以下命令检查变量是否已设置:

`# echo $JAVA_HOME And similar for the PATH variable:

echo $PATH`

Android SDK

为了能够编写 Android 应用，你需要 Android 软件开发工具包，它提供了 Google 目前支持的所有 Android 版本的所有库和工具。

你可以在[developer.android.com/sdk/index.html](http://developer.android.com/sdk/index.html)从 Android 开发者页面(图 1-11 )下载 SDK。

图 1-11。 Android SDK 下载页面

该网站提供了适用于 Windows、Linux 和 Mac 的 SDK 的压缩文档。还有另一个 Windows 版本，它是一个可执行文件，应该会引导您完成安装过程。由于所有平台的初始设置都是相同的，因此没有特定于操作系统的步骤。

下载完 SDK 档案后，将其移动到您选择的位置并解压缩。您将看到add-ons和platforms目录都是空的。只有tools目录包含几个二进制文件。现在该目录中的重要文件是android脚本。它启动 SDK 和 AVD 管理器(图 1-12 )。

图 1-12。 SDK 经理

SDK 管理器是 SDK 的核心。它管理已安装的 Android 版本，并更新新版本和附加包。使用 SDK 和 AVD 管理器，你还可以设置模拟器来测试 Android 应用。

在第一次启动时，它会连接到谷歌服务器检查版本更新，然后会提示您安装 SDK 包(图 1-13 )。这是一个好主意，只需点击接受所有并安装安装所有的 SDK 版本和额外的软件包。这可能需要很长时间，取决于您的互联网连接。如果您只想安装绝对必要的软件包，只需接受以下软件包，拒绝所有其他软件包:

Android SDK 平台-工具
Android SDK 的文档
Android 2.3.3、API 10 和所有更新版本的 SDK 平台
SDK API 10 和所有更新版本的示例
谷歌公司的谷歌 API，Android API 10 和所有更新的 API
谷歌 USB 驱动程序包
Android 兼容性包

图 1-13。 SDK 包安装

您可以通过单击“已安装和可用的软件包”来管理 SDK 安装，从而随时卸载和安装软件包。当 SDK 管理器下载完所有必要的包后，你会看到你的 SDK 目录已经增长，并且有了一些新的文件夹。我后面会讲到其中的一些，所以现在没有必要去理解。SDK 现在已经可以开发了。

Eclipse IDE

Eclipse 集成开发环境是软件开发人员最常用的 ide 之一。它有一个巨大的支持社区和一些针对各种开发场景的最强大的插件。您将需要 Eclipse 来开发您的 Android 应用。编写 Android 应用的编程语言是 Java。尽管您正在编写 Java 代码，但最终它将被编译成 Android 特有的dex代码，并打包成一个以文件结尾.apk的归档文件。这个存档文件将被放到您的 Android 设备上进行安装。

要下载 Eclipse，请前往[www.eclipse.org/downloads/](http://www.eclipse.org/downloads/)。在分发列表的右上角选择您的操作系统(图 1-14 )。

图 1-14。月食下载网站

您应该选择 Eclipse 经典版，因为它没有针对其他目的进行预配置。单击您的系统类型(32 位/64 位)的下载按钮。现在选择下载的默认镜像页面或选择离你最近的镜像(图 1-15 )。

图 1-15。下载镜像选择

根据您的操作系统，下载的文件可能是zip或tar.gz存档文件。您不需要安装 Eclipse，因为它已经打包好可以运行了。将归档文件移动到您希望放置 Eclipse 的目录中，并提取它。Eclipse IDE 现在可以进行普通的 Java 开发了。然而，您需要安装一个额外的插件并进行一些配置，以便为 Android 开发准备 Eclipse。

你首先需要的是谷歌的 Android 开发工具(ADT)插件。ADT 插件用一套强大的 Android 开发工具增强了 Eclipse。除了能够设置特定于 Android 的项目，您还将受益于用于用户界面(UI)开发、资源管理、调试和监控视图以及构建和分析工具的专用编辑器。关于 ADT 插件的细节可以在[developer.android.com/sdk/eclipse-adt.html](http://developer.android.com/sdk/eclipse-adt.html)找到。ADT 插件通过其更新机制从 Eclipse 中安装。

打开 Eclipse，点击Help。选择Install New Software ( 图 1-16 )。

图 1-16。 Eclipse 插件安装

点击右上角的Add。在存储库对话框中，您必须输入更新站点的 URL 和一个识别名称(图 1-17 )。名称可以是任何东西，但建议使用描述性的东西，如 ADT 插件。在 URL 字段中输入[dl-ssl.google.com/android/eclipse/](https://dl-ssl.google.com/android/eclipse/)。如果您在建立 SSL 连接时遇到困难，您也可以使用 http 作为协议，但是它不太安全。

图 1-17。添加插件网站

将列出更新站点可用软件。选中Developer Tools处的复选框，点击Next ( 图 1-18 )。

图 1-18。插件包选择

将会显示一个安装摘要，您可以点击Next。最后一步是接受许可协议并点击Finish ( 图 1-19 )。

图 1-19。许可协议

如果弹出一个对话框说真实性或有效性没有保证，点击OK。插件现在已经安装好了，Eclipse 将提示您要么重启 Eclipse，要么只应用更改。重启 Eclipse 总是一个好主意，这样在加载插件时就不会出现副作用。在您能够设置 Android 项目之前，您需要在 Eclipse 中设置一些首选项。在顶栏中选择Window和Preferences(图 1-20 )。

图 1-20。配置首选项

在左侧列表中选择Android。如果你第一次点击它，会弹出一个对话框，要求你发送使用统计数据到谷歌服务器。您不需要允许这样做，但是您必须做出选择并点击Proceed关闭对话框。现在您必须配置您的 Android SDK 位置。点击Browse…，选择放置 SDK 安装的目录，如图图 1-21 所示。

图 1-21。设置 Android SDK 路径

应用更改并点击OK。您已经完成了设置，现在准备开发 Android 应用。

Arduino IDE

与 Eclipse 相比，Arduino 集成开发环境是一个非常小的 IDE。您将使用它为基于 Arduino 的微控制器板编写代码。Arduino IDE 本身是基于 Java 的，但是您将使用 c 编写代码。IDE 使用 avr-gcc 编译代码。Arduino 的编写软件是一个所谓的草图。IDE ( 图 1-22 )本身包含一个带有语法高亮显示的代码编辑器，一个用于调试和信息目的的控制台，它通过串行连接(USB)连接到你的硬件板。IDE 附带了许多方便的库，用于各种 IO 操作。Arduino 社区有一个庞大的、不断增长的社区，由设计师、爱好者和开发人员组成，他们也制作各种各样的库和草图。

图 1-22。Arduino IDE

根据您的操作系统，您可以从位于[arduino.cc/en/Main/Software](http://arduino.cc/en/Main/Software)的 Arduino 网站(图 1-23 )下载 IDE 作为档案文件或磁盘映像。

图 1-23。 Arduino 下载网站

在 Windows 和 Linux 上安装 Arduino IDE

如果你使用的是 Windows 或者 Linux，你必须下载一个存档文件，你可以把它放在任何你喜欢的目录下。之后，解压存档文件。不需要安装，IDE 已经准备就绪。

在 Mac OS X 上安装 Arduino IDE

如果你使用的是 Mac OS X 系统，你必须下载一个.dmg文件，这是一个磁盘镜像。如果系统没有自动装载它，请双击该文件。安装后，您会看到一个名为Arduino.app的文件。将该文件移动到主目录中的应用文件夹中。IDE 现在已经安装完毕，可以开始编码了。

安装硬件驱动程序

外部硬件几乎总是需要所谓的驱动程序。驱动程序是一个软件，它让你的操作系统知道硬件。驱动程序使操作系统能够与外部设备通信。因为在编程阶段你有两个硬件设备要与之通信(ADK 板和 Android 设备)，所以你也必须为这些设备提供驱动程序。

在 Windows 上安装硬件驱动程序

尽管 ADK 板基于 ATmega 2560，其驱动程序已经与 Arduino IDE 一起部署，但 Windows 用户应该下载一个包含 ADK 型板驱动程序定义的档案文件。为此，请访问位于[arduino.cc/en/Main/ArduinoBoardADK](http://arduino.cc/en/Main/ArduinoBoardADK)的 Arduino ADK 详细页面。

您将在页面底部或以下网址找到存档文件:[arduino.cc/en/uploads/Main/Arduino_ADK.zip](http://arduino.cc/en/uploads/Main/Arduino_ADK.zip)。

归档文件只包含一个.inf文件。将你的 ADK 板连接到你的电脑上，你会被提示提供一个驱动程序或者让系统搜索一个。选择手动安装一个，指向提到的.inf文件。系统将安装驱动程序，并且系统知道您的 ADK 板。

Android 设备还需要一个驱动程序，以便您能够部署和调试您编写的应用。在大多数情况下，您的 Android SDK 安装提供的通用驱动程序就足够了。当您在 SDK 管理器中安装额外的 SDK 包时，您选择了一个名为Google USB Driver Package, revision x的包。当您第一次连接您的 Android 设备时，系统会提示您手动选择一个驱动程序或让系统搜索一个。再次选择手动分配驱动程序，并在% SDK_HOME%\extras\google\usb_driver的 SDK 安装目录中选择通用驱动程序。

注意在某些情况下你可能需要特定厂商的 USB 驱动。你可以在制造商主页上找到它们。例如，三星将其驱动程序与同步工具 Kies 打包在一起。

在 Linux 上安装硬件驱动程序

Linux 系统应该自动检测你的硬件板和你的 Android 设备。当您稍后将代码上传到 ADK 板时，您可以在 Arduino IDE 中选择 ATmega2560 设置。如果在 Linux 机器上设置开发板有任何问题，请参考[www.arduino.cc/playground/Learning/Linux](http://www.arduino.cc/playground/Learning/Linux)的安装指南。

在 Mac OS X 上安装硬件驱动程序

在 Mac 上，同样的情况也适用于 Linux 机器。应该可以自动检测设备。但是，如果你在使用 ADK 板时遇到了问题，安装你之前下载的磁盘镜像文件附带的 FTDI 驱动程序可能会有所帮助。双击名为FTDIUSBSerialDriver_xx_xx_xx_xx_xx_xx.mpkg的文件即可。遵循安装说明并重新启动系统。如果还是有问题，可以参考http://arduino.cc/en/Guide/MacOSX的安装指南。

ADK 参考包

为了给你的想法一个起点，谷歌提供了一个 ADK 参考包。该软件包包含用于制造的开发板的原始设计、固件、ADK 开发板的演示草图以及与 ADK 开发板通信的示例 Android 应用。可以在[dl-ssl.google.com/android/adk/adk_release_0512.zip](https://dl-ssl.google.com/android/adk/adk_release_0512.zip)下载。你应该下载参考资料包，因为它将是你的第一个项目和整本书的例子的基础。

注ADK 参考包的版本可能会不时更新。你可以在开发者页面的[developer.android.com/guide/topics/usb/adk.html](http://developer.android.com/guide/topics/usb/adk.html)ADK 组件部分找到当前链接。

Fritzing(可选软件)

虽然 Fritzing 是一个完全可选的开源软件组件，但并不一定需要，我想给你一个简短的概述，介绍它如何在以后的项目中帮助你。Fritzing 是一个强大的原型制作工具，可以让您以不同的形式可视化您的电路和硬件设计。它旨在支持业余爱好者、设计师和制造商的项目文档、可视化和制造。

使用 Fritzing，您可以创建如图 1-24 所示的试验板原理图。

图 1-24。油炸面包板示意图

您可以将您的设计抽象为电路原理图，如图图 1-25 所示。

图 1-25。烧结电路原理图

您甚至可以将您的设计转化为 PCB 设计(图 1-26 )，以便日后生产。

图 1-26。烧结 PCB 原理图

该工具有各种各样的部件，从最常见的，如电阻和常见的 IC(集成电路)，到 Sparkfun 目录中的几个部件，再到用户自己生成的部件。这个社区正在 Arduino 用户中成长，它越来越成为一个伪标准。虽然它可能不如 CadSoft 的 EAGLE 强大，它是电气工程的行业标准工具，但它仍然拥有业余爱好者或制造商需要的一切，而且完全免费。你会看到本书所有项目中使用的 Fritzing 原理图，以帮助可视化项目设置。如果你想更深入地了解它，你可以点击[fritzing.org](http://fritzing.org)阅读更多关于 Fritzing 的内容。

准备，集合，开始

恭喜你！您已经完成了为 Android 开放附件开发套件设置开发环境的繁琐任务。你也了解了一些关于仍然年轻的 ADK 的历史，以及哪些硬件存在于野外。接下来的章节将带领你创建一个 ADK 项目。接下来，我将通过设置不同种类的实验和项目来描述您需要了解的关于 ADK 板和可能的外部元件的基础知识。每个项目教给你一个具体的细节，你可能需要在后续的项目。这些例子大部分是建立在彼此的基础上的；最后，您将利用目前所学的知识建立更复杂的项目。这些项目将基于最常见的 ADK 兼容板，Arduino ADK 板。

现在你已经准备好了，让我们开始你的第一个项目。

二、Android 和 Arduino：相互了解

既然你已经了解了 Android 和 Arduino 平台的基础知识，是时候让他们互相了解了。本章将指导你完成你的第一个 Android 开放附件开发包(ADK)项目。您将了解开放附件协议的细节以及它在双方是如何实现的。您将编写您将在本书中用于所有后续示例的代码基础。为了了解代码示例的生命周期和结构，您将从为这两个平台编写有史以来最受欢迎的“Hello World”开始。

您将从为 Arduino 和 Android 创建两个非常基本的项目开始，学习如何在这两个平台上设置项目。一步一步，你将实现必要的功能，让 Android 设备和 ADK 板相互识别时，他们连接。最后，您将实现实际的通信，从 Android 设备向 ADK 板发送文本消息，反之亦然。

你好 Arduino

首先，打开你安装的 Arduino IDE。如果您以前没有使用过 Arduino IDE，请不要害怕。它有一个非常清晰和基本的结构，它提供了足够的功能让你为 Arduino 平台进行适当的开发。

你会看到一个很大的文本可编辑区域，在这里你可以编写你的代码(图 2-1 )。代码编辑器提供了语法突出显示，但不幸的是，没有代码补全，这可能会使针对外部库的开发更加困难，因为您必须直接在库代码中查找函数定义。

图 2-1。 Arduino IDE 代码编辑器

编辑器的顶部是操作栏。操作栏可让您快速访问编译等功能，以及New、Open、Save和Upload等文件操作，并启动串行监视器进行调试或直接向连接的电路板发送命令。在顶部的系统栏中(如图图 2-2 所示)，你可以选择更细粒度的操作，比如选择合适的板卡、通信端口、导入外部库等等。

图 2-2。 Arduino IDE 系统栏和操作栏

编辑器底部的状态栏显示你的编译和上传进度以及警告或编译错误(见图 2-3 )。关于 Arduino IDE 更详细的解释，你可以参考 Arduino 网站上的原始文档。

图 2-3。 Arduino IDE 状态字段

Arduino 草图有两个重要的方法。第一个是setup方法，它只在代码执行开始时运行一次。这是你初始化程序的地方。第二种是loop法。该方法无限循环运行，直到板复位。这是实现程序逻辑的地方。正如你在图 2-4 中看到的，Arduino 草图的生命周期相当简单。

图 2-4。草图生命周期

您也可以在同一个草图中定义自己的方法，或者链接其他源文件或库。要链接一段代码，可以使用 C 开发中已知的#include指令。包括放置在草图的最顶部。全局变量也必须在你的 include 指令下面的草图的顶部定义。由于 Arduino ADK 和大多数其他 ADK 板有 256 千字节的内存限制，你必须记住写干净的代码，这意味着没有代码重复，你必须坚持尽可能最小的数据类型，以便不耗尽内存。幸运的是，编译器总是向您显示编译后代码的确切大小，并在超出限制时发出警告。

现在是时候为 Arduino 编写你的“Hello World”程序了。在 Arduino IDE 中，选择操作栏中的New。在新打开的编辑器窗口中，输入如清单 2-1 所示的代码。

清单 2-1。 Arduino Hello World 草图

`//includes would be placed here

//constant definition

define ARRAY_SIZE 12

//global variable definition
char hello[ARRAY_SIZE] = {'h','e','l','l','o',' ','w','o','r','l','d','!'};

void setup() {
//set baud rate for serial communication
Serial.begin(115200);
}

void loop() {
//print characters from array to serial monitor
for(int x = 0; x < ARRAY_SIZE; x++) {
Serial.print(hello[x]);
delay(250);
}
Serial.println();
delay(250);
}`

我们来谈谈代码是做什么的。首先，您为数组的大小定义了一个常数。然后定义了一个 char 数组，其大小为 12。因为您的 char 数组中有 12 个字符的空间，所以您可以将“hello world！”投入其中。

在设置方法中，为串行通信准备电路板。串行对象提供了简化串行通信的方法。要开始通信，您可以使用参数 115200 调用 begin 方法。这就是所谓的波特率，定义了每秒可以传输多少位。串行通信中的接收方必须配置相同的波特率，以正确读取传输数据。

如前所述，循环方法会无休止地运行，直到电路板复位。在 loop 方法中，在 for 循环的帮助下打印 char 数组的每个字符，for 循环遍历所有元素。使用 Serial 类的 print 方法将元素打印到串行监视器上。您还会看到在每个字符打印输出之间调用了一个 delay 方法来降低输出速度，以获得更好的可读性。延迟参数以毫秒为单位。

当您输入所有内容后，单击操作栏中的 Verify，查看您的代码是否可以编译而不出现错误。如果一切正常，你可以连接你的 ADK 板到你的电脑。您需要告诉 IDE 您将 ADK 板连接到了哪个端口，以及它实际上是哪种类型的板，这样 IDE 才能以正确的方式将程序代码传输到板上。

点击工具板，选择 Arduino Mega 2560(参见图 2-5 )。

图 2-5。 Arduino IDE 板选择

现在转到工具串行端口并选择你的板连接的端口(图 2-6 )。

图 2-6。 Arduino IDE 串口选择

完成所有配置后，点击操作栏中的上传。你的代码将被编译并转移到 ADK 董事会。完成后，状态字段将显示“上传完成”。代码现在由您的 ADK 板处理并开始执行。单击 IDE 操作栏中的串行监视器，打开串行监视器并查看打印输出。要正确查看传输的数据，请确保将波特率正确设置为代码中的 115200。这是在串行监视器的右下角完成的。你现在应该看到“你好，世界！”在串行监视器窗口中反复打印，如图图 2-7 所示。

图 2-7。 Arduino IDE 串行监视器

恭喜你！你已经写好了你的第一张 Arduino 草图，并且已经做好了一切准备来开始真正的 ADK 部分。

注意在撰写本文时，Arduino IDE 的新版本正在发布。1.0 版在内部库和 IDE 用户界面中引入了许多变化。一些与 ADK 相关的库可能还不完全兼容。如果您在编译示例时遇到任何问题，您可能希望确保使用 IDE 的旧版本。本书中的示例是用 Arduino IDE 修订版 0022 编写和编译的。

你好安卓

如果你以前没有使用过 Android，那么最好先熟悉一下这个平台的基础知识，了解一下它的关键组件。由于这本身就可以写满另一本书，我强烈建议你看看 Android 开发者页面，通读基础知识和基本原理，这样当我提到活动或广播接收者时，你就知道我在说什么了。下面简单介绍一下我刚才提到的基本组件。更多详情请参考 Android 开发指南。

Activity:Activity 是处理用户交互的组件。它的主要目的是以内容视图元素的形式提供一个用户界面，例如，用于文本显示或文本输入。活动用于可视化程序流。它们可以彼此交互，系统以堆栈结构维护它们。这种堆栈结构在系统需要从一个到另一个导航时特别有用。
服务:服务是长时间运行的过程，不需要用户交互。它们不会被误认为是线程，因为它们被绑定到同一个应用进程。服务还可以用于向其他应用公开功能。
broadcast receiver:broadcast receiver 是一个接收和处理系统或其他应用发送的广播的组件。当实现时，它可以在某些情况下做出反应，例如电池电量低，或者甚至可以用来启动应用。
content provider:content provider 用于在多个应用之间共享数据。例如，它提供了访问数据库中数据的方法。Android 系统中一个流行的 ContentProvider 是 ContentProvider for your contacts，它可以被很多应用使用。

你可以在[developer.android.com/guide/index.html](http://developer.android.com/guide/index.html)找到 Android 开发指南和其他几篇文章。

要编写 Android 的“Hello World”等价物，您必须打开 Eclipse IDE。一旦启动，选择File New Other(见图 2-8 )。

图 2-8。 Eclipse IDE 新项目创建

一个新的对话框将会弹出，里面有很多项目类型可供选择。您需要选择Android Project，点击Next，如图图 2-9 所示。

图 2-9。 Eclipse IDE 项目类型选择

在下一个对话框中，您可以配置项目设置。输入项目的名称，如HelloWorld。然后选择一个构建目标。目标取决于您使用的设备。如果您使用 Android 版本 2.3.4 或更高版本的设备，则选择Google APIs platform 2.3.3 API level 10。如果您使用的是 Android 或更高版本的设备，请选择Google APIs platform 3.1 API level 12。(参见图 2-10 。)

图 2-10。 Eclipse IDE Android 项目向导(上半部分)

接下来，定义您的应用名称。也可以输入HelloWorld。现在选择你的包名。包名将是 Android Market 中的唯一标识符，通常反映您的公司或组织的域名。对于这个例子，你可以输入helloworld.adk。检查显示Create Activity的复选标记，并键入HelloWorldActivity。最小 SDK 版本字段描述了应用兼容的 API 级别。因为您将需要 USB API 特性，如果您使用 2.3.4 设备，您应该为 API 级别 10 选择10,否则为 API 级别 12 选择12。其余的设置可以保持不变。(参见图 2-11 。)

图 2-11。 Eclipse IDE Android 项目向导(下部分)

点击Finish，等待 Eclipse 建立您的第一个 Android ADK 项目。你新创建的项目应该看起来像图 2-12 。

图 2-12。hello world 项目的 Eclipse IDE 包浏览器视图

如果您看一下左边的 Package Explorer 区域，您会看到 Eclipse 用几个文件夹和文件创建了一个新项目。让我们看看他们都是什么意思。

首先你会看到的是src文件夹，它包含了你将要编写的所有 Java 源代码。您已经可以看到 Eclipse 已经构建了您配置的包结构，并将给定的HelloWorldActivity.java文件放入其中。在查看那个项目之前，您将进一步探索生成的项目。

除了src文件夹，还有一个文件夹叫gen。如果项目中的资源发生了变化，则每次构建项目时都会自动生成该文件夹及其内容。在那个文件夹里有一个叫做R.java的文件。这是一个文件，其中所有的资源都被索引并映射到整数。这些静态数字用于在代码中以一种简单的方式访问您的资源。你不应该接触gen文件夹，因为 Android 构建过程直接管理R.java文件，你手动做的每一个改变都会在下一次构建中被覆盖。

接下来你看到的是将在你的构建路径中使用的引用库。您应该看到Google APIs，旁边是您配置的目标版本。如果您展开节点，您会看到项目引用了一个android.jar，它包含您选择的 Android 版本的系统类文件；一个usb.jar，它包含您与 ADK 设备进行 USB 通信所需的 USB 特定类；以及一个maps.jar，它用于 Google Maps 集成。

下一个文件夹叫做assets，它通常包含你必须自己管理的额外资源。您必须通过它们在应用中的相对路径来引用它们，因为构建系统不会将引用放入R.java文件中。

第二个资源文件夹是一个名为res的托管文件夹。放入该文件夹的每个资源都会在R.java文件中获得一个自动生成的 id，以便于访问。你已经可以在res文件夹中看到几个子文件夹。drawable文件夹有一个带有屏幕密度标识符的后缀。如果在这些文件夹中为不同的屏幕密度提供不同的图像，系统将在执行应用时选择正确的文件。还有一个文件夹叫做layout。该文件夹包含定义应用 UI 的 xml 布局文件。一个布局文件可以有多个视图元素，这些元素构成了您的用户界面。您看到的最后一个文件夹是values文件夹。在values文件夹中，你可以为静态资源定义 xml 文件，比如字符串、维度、数组等等。

除了所有这些文件夹，你还会看到一些独立的文件:AndroidManifest.xml、default.properties和proguard.cfg。您唯一感兴趣的文件是AndroidManifest.xml，它是您的应用的中央注册表。关于活动、服务、权限、强制设备特性和许多其他特性的细节必须在这个文件中定义。

生成的项目不仅仅是一个骨架。它已经是一个成熟的应用，尽管非常初级。它只显示“Hello World，HelloWorldActivity”。让我们来看看这个应用的结构和生命周期。每个 Android 应用的起点是AndroidManifest.xml。打开它，看看它的结构(清单 2-2 )。

清单 2-2。 AndroidManifest.xml

您可以看到一个application标签，它的属性定义了应用的icon和label。这两个资源都用 xml 资源语法@resource-type/id引用。用@string/app_name引用的应用名称将取自res/values文件夹中strings.xml文件中定义的字符串。相同的资源查找语法适用于 drawables 和您将在任何 xml 文件中看到的所有其他资源。

在应用节点中，您定义了所有的活动、服务、内容提供者和广播接收者。到目前为止，清单中只声明了一项活动。看看那个。name属性必须是活动的类名。因为该类在应用默认包中，所以它前面有一个点。如果您将类移动到另一个包中，请确保使用正确的包结构更新名称，否则系统将无法再找到它。

活动节点中重要的是intent-filter。intent-filter定义了系统如何启动活动以及如何触发活动。

在action标签中，您可以看到该活动被标记为应用的主活动，并且将在用户启动应用时首先启动。

category标签指定了启动器类别，这意味着应用链接将放入设备上的应用概览菜单中，将启动您的活动。

在与application标签相同的层次级别上，您可以看到uses-sdk标签，它定义了 Android API 级别版本，并且是必需的。在该层级中，您还可以定义用户在安装过程中必须授予的权限，例如访问附件。

您已经知道应用的起点在哪里。现在让我们看看你的主要活动实际上是做什么的。打开HelloWorldActivity.java文件并查看其内容(清单 2-3 )。

清单 2-3。HelloWorldActivity.java

`package helloworld.adk;

import android.app.Activity;
import android.os.Bundle;

public class HelloWorldActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}`

如你所见，这个文件很小。该类必须扩展Activity类，它是 Android 系统的一部分。因为活动负责提供用户界面，所以您必须提供一些视图来显示给用户。视图通常在活动创建时加载。Android 平台提供了活动生命周期的挂钩，这样您就可以创建资源、运行应用逻辑，并在活动的相应阶段进行清理。一个 Android 活动的生命周期比一个简单的 Arduino 草图要复杂一些，如图 2-13 所示。

图 2-13。安卓活动生命周期(谷歌公司图片财产来源:[developer.android.com/guide/topics/fundamentals/activities.html](http://developer.android.com/guide/topics/fundamentals/activities.html) )

你可以看到setContentView方法是以布局资源为参数调用的。该方法采用layout/main.xml中的布局定义，并将其所有视图呈现在设备屏幕上。如果你打开这个main.xml文件，你可以看到它只定义了两个视图元素(见清单 2-4 )。

清单 2-4。布局文件 main.xml

`
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"

LinearLayout是一个可以容纳其他视图或容器的容器视图。layout_width和layout_height属性被设置为在设备的整个屏幕上延伸。orientation属性指定所包含的元素应该垂直对齐。目前包含在LinearLayout中的唯一元素是TextView元素。从它的属性可以看出，它应该填充屏幕的宽度，但应该只与它自己的内容一样高。TextView的文本由来自strings.xml文件的@string/hello引用解析。如果您在 Eclipse 中从 xml 编辑器切换到图形布局编辑器，您应该已经在虚拟设备屏幕上看到文本“Hello World, HelloWorldActivity!”。现在够了。让我们在真实设备上看看这个应用。

将您的 Android 设备连接到您的计算机，右键单击该项目，选择Run As，然后选择Android Application。您的应用应该被打包成一个apk文件，并被推送到设备上进行安装。如果一切正常，您应该看到应用在您的设备上启动。例如，如果系统由于缺少驱动程序而无法识别你的设备，它将使用默认的 Android 虚拟设备(AVD)启动一个模拟器。当应用启动后，你应该会看到类似图 2-14 的内容。

图 2-14。运行在安卓设备上的 HelloWorld 应用

相识

恭喜你！您已经编写了您的第一个 Arduino 应用和第一个 Android 应用。现在，您对设置项目和为两个平台编写代码已经稍微熟悉了一些，让我们看看这两个设备如何在开放附件协议的帮助下相互识别。

为 Arduino 扩展 Hello World

您先前下载的 ADK 参考包包含两个库，您将需要它们来建立 USB 通信。一个是USB_Host_Shield库的修改版本，最初是由 Oleg Mazurov 为 Circuits@Home 创建的。该库最初设计用于 Arduino USB 主机保护。由于 ADK 兼容板上的 USB 芯片相当于 USB host shield，因此只对库进行了一些小的修改。第二个库是AndroidAccessory库，负责实现开放附件协议。将在ADK_release_xxxx\firmware\arduino_libs\找到的两个库文件夹复制到arduino-xxxx\libraries的 Arduino IDE 安装的库文件夹中。修改你的 Arduino HelloWorld草图，如清单 2-5 所示。

清单 2-5。 Hello World Sketch 扩展识别安卓设备

`#include <Max3421e.h>

include <Usb.h>

#include <AndroidAccessory.h>

define ARRAY_SIZE 12

AndroidAccessory acc("Manufacturer", "Model", "Description",
"Version", "URI", "Serial");

char hello[ARRAY_SIZE] = {'h','e','l','l','o',' ',
'w','o','r','l','d','!'};

void setup() {
Serial.begin(115200);
acc.powerOn();
}

void loop() {
if (acc.isConnected()) {
for(int x = 0; x < ARRAY_SIZE; x++) {
Serial.print(hello[x]);
delay(250);
}
Serial.println();
delay(250);
}
}`

如您所见，准备开放式配件沟通的草图只需三处改动。这里你要做的第一件事是初始化一个AndroidAccessory对象，这个实现了开放附件协议，这样你就不用担心了。你用一些描述性的字符串来初始化它，这些字符串定义了你创建的附件。这些字段是不言自明的。最重要的参数是Manufacturer、Model和Version。它们将在 Android 应用中用于验证您是否与正确的 ADK 板通信。此外，如果没有安装安卓应用，安卓系统使用 URI 参数来寻找合适的安卓应用。这可以是一个链接到 Android 市场或产品页面。

在setup例程中，您用powerOn方法将对象设置为活动状态。loop例程在每个循环中检查是否有东西连接到附件，然后才执行其中的代码。在这个方便的方法中，实现了实际的连接协议。

只用了三行代码，ADK 板就能识别支持附件模式的连接的 Android 设备。就这么简单。如果你把代码上传到你的 ADK 板上，你会看到“你好，世界！”只有当您将 Android 设备连接到 ADK 板时，才会打印到串行监视器。您将在串行监视器上看到如下内容:

`Device addressed... Requesting device descriptor.
found possible device. switching to serial mode
device supports protcol 1

Device addressed... Requesting device descriptor.
found android accessory device
config desc
interface desc
interface desc
5
7`

第一段告诉你，一般来说，一个设备已经被识别，并且这个设备支持开放的 Android 附件协议。在第二段中，再次读取设备描述符，以查看 Android 设备是否将自己标识为处于附件模式的设备。每个 USB 设备都有这样一个描述符，用于向连接系统标识自己。您可以看到，该设备被正确识别为配件模式兼容。现在正在读取配置和接口描述符，您将看到的最后两个数字是要使用的通信的输入和输出端点。如果一切顺利，你会看到“你好，世界！”是一个字符一个字符打印出来的。如果你想了解更多关于AndroidAccessory库的内部，以及它是如何实现开放附件协议的，可以看看[developer.android.com/guide/topics/usb/adk.html](http://developer.android.com/guide/topics/usb/adk.html)的“实现 Android 附件协议”一节。

为 Android 扩展 Hello World

要为开放附件协议准备 Android 应用，您还不需要编写任何代码。你要做的第一件事是在AndroidManifest.xml中做一些改变。你必须声明你正在使用 USB 功能。由于您希望通过 USB 进行通信，因此需要在 Android 版本低于 3.1 的设备的清单中声明 USB 库的使用。将下列行添加到AndroidManifest.xml:

…

这个 USB 库被反向移植到 Android 版本 2.3.4，并被命名为 com.android.future.usb。Android 版本 3.1 的类被放在名为 android.hardware.usb 的包中。如果你想支持广泛的设备，你应该使用 com . Android . future . USB 包，因为它对两个版本都兼容。在蜂窝设备上，com.android.future.usb 包中的类只是包装类，它们委托给 android.hardware.usb 包中的类。

接下来需要声明的是另一个意图过滤器，当 Android 设备连接到附件时，它会启动应用。在 HelloWorldActivity 的 activity 节点中添加以下代码行:

如您所见，这里添加了第二个意图过滤器，它对 USB_ACCESSORY_ATTACHED 动作做出反应。当您将 Android 设备连接到 ADK 兼容板时，这将触发 HelloWorldActivity。还添加了一个新元素。元数据标签引用额外的资源，这些资源可被提供给意图过滤器以进一步细化过滤机制。这里引用的 accessory_filter.xml 定义了一个更细粒度的过滤标准，只匹配您的附件，不匹配其他附件。在/res 文件夹中创建一个名为 xml 的文件夹。在创建的文件夹中添加一个名为 accessory_filter.xml 的新文件。现在将清单 2-6 中的内容添加到 xml 文件中。

清单 2-6。定义附件过滤的元文件

<?xml version="1.0" encoding="utf-8"?> <resources> <usb-accessory manufacturer="Manufacturer" model="Model" version="Version" /> </resources>

请注意，您在这里指定的值必须与初始化AndroidAccessory对象时 Arduino 草图中的值相同。如果这些值与板传输的值匹配，过滤器将触发活动开始。将您的 Android 设备连接到您的 PC，并上传更改后的应用。现在把你的设备连接到 ADK 板上。您可能会看到弹出一个对话框，询问您是否希望总是将您的应用与已识别的意图相关联。您可以确认这一点，然后，您将看到应用已经启动。如果您发现连接设备后没有任何反应，请检查您的过滤器是否与 Arduino 草图中定义的值相匹配。另一个错误来源是，您的主板无法提供足够的功率来为 Android 设备正常供电。由于这是开放附件标准的要求，如有必要，请确保使用外部电源为电路板供电。

我们谈谈吧

现在，您已经确保了两台设备能够相互识别，但您希望它们能够真正相互通话。通信是在一个相当简单的自定义协议中完成的。消息通过字节流发送和接收。在 Android 应用中，这是通过读写一个特殊文件的输入输出流来完成的。在 Arduino 端，AndroidAccessory类提供了读写消息的方法。对于通信协议应该是什么样子没有限制。在示例demokit应用中，Google 将消息定义为 3 字节长的字节数组。(参见图 2-15 )。第一个字节是命令类型。它定义了传输哪种类型的消息。在demokit应用中使用的命令是伺服系统、发光二极管、温度传感器和许多其他设备的命令类型。第二个字节是该命令的实际目标。谷歌演示盾有多个发光二极管和伺服连接器，并解决适当的，目标字节使用。第三个字节是应该发送到该目标或从该目标接收的值。一般来说，当您自己实现这些消息时，您可以选择您想要的任何消息结构，但是我建议您坚持使用示例，因为您可能会在整个 Web 上找到基于相同消息结构的教程和示例。请记住，您只能传输字节，因此您必须相应地转换更大的数据类型。在大多数例子中，你也会遵循这个惯例。

图 2-15。Google 在 demokit 应用中定义的默认消息协议

然而，对于第一个例子，你必须稍微改变一下规则，定义一个自定义协议来传输文本信息(见图 2-16 )。传输的数据也是字节数组，但形式略有不同。第一个字节将定义命令类型，第二个字节将定义目标，第三个字节定义文本消息的长度(不超过 252 个字节)，最后剩余的字节定义实际的文本消息。

图 2-16。发送和接收短信的自定义短信协议

处理 Arduino 命令

Arduino 草图中的通信实现非常简单。如清单 2-7 中的所示扩展草图。

清单 2-7。hello world Sketch 中的通信实现

`#include <Max3421e.h>

include <Usb.h>

include <AndroidAccessory.h>

**#define ARRAY_SIZE 25

define COMMAND_TEXT 0xF

define TARGET_DEFAULT 0xF**

AndroidAccessory acc("Manufacturer", "Model", "Description",
"Version", "URI", "Serial");

char hello[ARRAY_SIZE] = {'H','e','l','l','o',' ',
'W','o','r','l','d',' ', 'f', 'r', 'o', 'm', ' ',
'A', 'r', 'd', 'u', 'i', 'n', 'o', '!'};

byte rcvmsg[255];
byte sntmsg[3 + ARRAY_SIZE];

void setup() {
Serial.begin(115200);
acc.powerOn();
}

**void loop() {
if (acc.isConnected()) {
//read the sent text message into the byte array
int len = acc.read(rcvmsg, sizeof(rcvmsg), 1);
if (len > 0) {
if (rcvmsg[0] == COMMAND_TEXT) {
if (rcvmsg[1] == TARGET_DEFAULT){
//get the textLength from the checksum byte
byte textLength = rcvmsg[2];
int textEndIndex = 3 + textLength;
//print each character to the serial output
for(int x = 3; x < textEndIndex; x++) {
Serial.print((char)rcvmsg[x]);
delay(250);
}
Serial.println();
delay(250);
}
}
}

sntmsg[0] = COMMAND_TEXT;
sntmsg[1] = TARGET_DEFAULT;
sntmsg[2] = ARRAY_SIZE;
for(int x = 0; x < ARRAY_SIZE; x++) {
sntmsg[3 + x] = hello[x]; }
acc.write(sntmsg, 3 + ARRAY_SIZE);
delay(250);
}
}**`

让我们看看这里有什么新内容。因为您想要向 Android 设备发送更具体的文本，所以您需要更改文本消息及其大小常量。

#define ARRAY_SIZE 25 char hello[ARRAY_SIZE] = {'H','e','l','l','o',' ', 'W','o','r','l','d',' ', 'f', 'r', 'o', 'm', ' ', 'A', 'r', 'd', 'u', 'i', 'n', 'o', '!'};

接下来您需要做的是为接收的消息声明一个字节数组，为要发送的消息声明一个字节数组。

byte rcvmsg[255]; byte sntmsg[3 + ARRAY_SIZE];

请注意，要发送的字节数组的大小等于消息本身加上命令类型、目标和校验和的附加字节。命令类型字节和目标字节也可以定义为常量。

`#define COMMAND_TEXT 0xF

define TARGET_DEFAULT 0xF`

在循环方法中，您将处理消息的接收和发送。首先看一下信息是如何被接收的:

if (acc.isConnected()) { //read the sent text message into the byte array int len = acc.read(rcvmsg, sizeof(rcvmsg), 1); if (len > 0) { if (rcvmsg[0] == COMMAND_TEXT) { if (rcvmsg[1] == TARGET_DEFAULT){ //get the textLength from the checksum byte byte textLength = rcvmsg[2]; int textEndIndex = 3 + textLength; //print each character to the serial output for(int x = 3; x < textEndIndex; x++) { Serial.print((char)rcvmsg[x]); delay(250); } Serial.println(); delay(250); } } } … }

AndroidAccessory 对象的 read 方法读取 inputstream 并将其内容复制到提供的字节数组中。作为参数，read 方法采用应该填充的字节数组、该字节数组的长度以及一个阈值，以防传输未被确认。之后，执行检查以查看是否传输了正确的命令和目标类型；只有这样，才能确定传输消息的长度。从 for 循环中的字节数组读取实际的文本消息，并逐字符打印到串行输出。收到一条消息后，另一条消息被发送到 Android 设备，如下所示:

if (acc.isConnected()) { … sntmsg[0] = COMMAND_TEXT; sntmsg[1] = TARGET_DEFAULT; sntmsg[2] = ARRAY_SIZE; for(int x = 0; x < ARRAY_SIZE; x++) { sntmsg[3 + x] = hello[x]; } acc.write(sntmsg, 3 + ARRAY_SIZE); delay(250); }

同样，要发送的字节数组是根据自定义协议构建的。第一个字节设置为命令类型常量，第二个字节设置为目标常量，第三个字节设置为作为校验和的实际文本消息的大小。现在，程序遍历 hello char 数组，用文本消息填充字节数组。当字节数组设置完毕后，调用 AndroidAccessory 对象的 write 方法，通过 outputstream 将数据传输到 Android 设备。write 方法有两个参数:要传输的字节数组和传输的字节大小。

正如你所看到的，Arduino 草图非常简单，AndroidAccessory 对象为你做了所有的脏工作。现在让我们来看看 Android 通信部分。

处理 Android 命令

在 Android 中实现通信部分比在 Arduino 端需要更多的工作。扩展HelloWorldActivity类，如清单 2-8 中的所示。此后，您将了解每个代码片段的作用。

清单 2-8。【HelloWorldActivity.java ??(进口和变量)】

`package helloworld.adk;

import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import com.android.future.usb.UsbAccessory;
import com.android.future.usb.UsbManager;

public class HelloWorldActivity extends Activity {

private static final String TAG = HelloWorldActivity.class.getSimpleName();

private PendingIntent mPermissionIntent;
private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
private boolean mPermissionRequestPending;

private UsbManager mUsbManager;
private UsbAccessory mAccessory;
private ParcelFileDescriptor mFileDescriptor;
private FileInputStream mInputStream;
private FileOutputStream mOutputStream;

private static final byte COMMAND_TEXT = 0xF;
private static final byte TARGET_DEFAULT = 0xF;

private TextView textView;

…`

首先让我们来看看你需要做的变量声明。

private static final String TAG = HelloWorldActivity.class.getSimpleName();

constant 标签是当前类的标识符，在 Android 中仅用于记录目的。如果您在设备或模拟器运行时查看 Eclipse 中的 logcat 视图，您会看到记录的消息与一个标记相关联，这简化了读取日志输出。(参见图 2-17 。)您可以为此定义任何字符串，但是出于调试目的使用应用名甚至类名是个好主意。

图 2-17。月食日志视图

private static final byte COMMAND_TEXT = 0xF; private static final byte TARGET_DEFAULT = 0xF;

COMMAND_TEXT 和 TARGET_DEFAULT 与 Arduino 草图中使用的常量相同。它们构成了数据协议的前两个字节。

private PendingIntent mPermissionIntent; private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"; private boolean mPermissionRequestPending;

与外部设备建立连接必须得到用户的许可。当用户授予连接到您的 ADK 板的权限时，PendingIntent 将广播 ACTION_USB_PERMISSION，并带有一个反映用户是确认还是拒绝访问的标志。布尔变量 mPermissionRequestPending 仅用于在用户交互仍未完成时不再显示权限对话框。

private UsbManager mUsbManager; private UsbAccessory mAccessory; private ParcelFileDescriptor mFileDescriptor; private FileInputStream mInputStream; private FileOutputStream mOutputStream;

UsbManager 是一项系统服务，用于管理与设备 USB 端口的所有交互。它用于列举连接的设备，并请求和检查连接到附件的许可。UsbManager 还负责打开与外部设备的连接。USB 存储器是连接附件的参考。ParcelFileDescriptor 是在与附件建立连接时获得的。它用于访问附件的输入和输出流。

private TextView textView;

唯一用户可见的 UI 元素是 textView，它应该显示从 ADK 板传输的消息。

这就是你需要声明的所有变量。现在我们将看看活动的生命周期方法(清单 2-9 )。

清单 2-9。【HelloWorldActivity.java ??(生命周期方法)】

`/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

mUsbManager = UsbManager.getInstance(this);
mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent( ACTION_USB_PERMISSION), 0);
IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
registerReceiver(mUsbReceiver, filter);

setContentView(R.layout.main);
textView = (TextView) findViewById(R.id.textView);
}

/** Called when the activity is resumed from its paused state and immediately after onCreate(). */
@Override
public void onResume() {
super.onResume();

if (mInputStream != null && mOutputStream != null) {
return;
}

UsbAccessory[] accessories = mUsbManager.getAccessoryList();
UsbAccessory accessory = (accessories == null ? null : accessories[0]);
if (accessory != null) {
if (mUsbManager.hasPermission(accessory)) {
openAccessory(accessory);
} else {
synchronized (mUsbReceiver) {
if (!mPermissionRequestPending) {
mUsbManager.requestPermission(accessory, mPermissionIntent);
mPermissionRequestPending = true;
}
}
}
} else {
Log.d(TAG, "mAccessory is null");
}
}

/** Called when the activity is paused by the system. */
@Override
public void onPause() { super.onPause();
closeAccessory();
}

/** Called when the activity is no longer needed prior to being
removed from the activity stack. */
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mUsbReceiver);
}`

每个活动类的第一个生命周期回调方法是 onCreate 方法。这个方法通常是你进行基本初始化的地方。不过，要小心。onCreate 方法只在系统创建活动时调用一次。该活动将继续存在，直到系统需要释放内存并终止它，或者如果您显式调用该活动的 finish 方法来告诉系统不再需要该活动。

`/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

mUsbManager = UsbManager.getInstance(this);
mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(
ACTION_USB_PERMISSION), 0);
IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
registerReceiver(mUsbReceiver, filter);

setContentView(R.layout.main);
textView = (TextView) findViewById(R.id.textView);
}`

在生命周期回调方法中需要做的最重要的事情是将调用委托给被扩展的父类；否则，将发生异常。委托调用 super . oncreate(savedInstanceState)允许父 activity 类完成它的所有初始化逻辑，然后 HelloWorldActivity 可以继续它自己的初始化。接下来，获取一个对 USB 系统服务的引用，以便您稍后可以调用它的方法。现在定义了一个带有 ACTION_USB_PERMISSION 参数的 PendingIntent。当您请求用户允许连接到 USB 设备时，您将需要它。您在这里看到的意图过滤器与广播接收器一起使用，以确保应用只侦听特定的广播。过滤器定义它对您在开始时定义为常量的 ACTION_USB_PERMISSION 动作和 ACTION_USB_ACCESSORY_DETACHED 动作起作用，用于 ADK 附件断开时。registerReceiver 方法在系统中向所描述的意图过滤器注册广播接收器。因此，当系统发送广播时，广播接收器将得到通知，并可以采取相关措施。

在 onCreate 方法中，您需要做的最后一件事是设置您的 UI 元素，以便用户可以实际看到正在发生的事情。您已经了解到 Android 中的 UI 布局大部分是在 xml 文件中定义的。再次使用 setContentView 方法加载布局。代码中的最后一行用于从布局中获取对视图元素的引用，以便可以在代码中对其进行管理。findViewById 方法获取一个视图标识符，并返回该引用的通用视图元素。这就是为什么需要对视图元素的正确实现进行强制转换的原因。为了能够从布局 xml 文件中引用视图，这些视图需要定义一个标识符。在 res/layout/打开 main.xml 文件，并将 id 属性添加到 TextView。

<TextView android:id="@+id/textView" android:layout_width="fill_parent" android:layout_height="wrap_content" android:text="@string/hello" />

这里可以看到动态资源生成的新语法。语法@+id/textView 意味着该视图元素应该分配有 id textView。id 前面的加号意味着，如果这个 id 在 R.java 文件中不存在，那么应该在那里创建一个新的引用。

您已经完成了活动的创建阶段。现在你进入下一个重要的生命周期阶段，onResume 生命周期钩子。每次活动从暂停状态返回时，都会调用 onResume 方法。当您离开活动开始新的活动或返回设备的主屏幕时，您的活动将被设置为暂停状态，而不是被终止。系统这样做是为了节省时间和内存分配，以防稍后再次显示该活动。在暂停状态下，活动对用户不再可见。如果应该再次显示该活动，则该活动仅从其暂停状态返回，并设置为恢复状态，而不是再次完全初始化。当这种情况发生时，onResume 生命周期方法被调用。onResume 方法不应该负责进行主要的初始化。在这种情况下，它应该检查您是否仍然能够与附件通信。这正是你在这里做的。

`@Override
public void onResume() {
super.onResume();

if (mInputStream != null && mOutputStream != null) {
return;
}

如果输入和输出流仍然是活动的，那么你可以进行通信，并且可以从 onResume 方法中提前返回。否则，您必须从 UsbManager 获取附件的参考。如果您已经拥有与设备通信的用户权限，您可以打开并重新分配输入和输出流。这部分是在一个名为 openAccessory 的方法中实现的，稍后会详细介绍。这里我要讲的最后两个生命周期方法是 onPause 方法和 onDestroy 方法。

`@Override
public void onPause() {
super.onPause();
closeAccessory();
}

@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mUsbReceiver);
}`

onResume 方法的反面是 onPause 方法。您已经了解了活动的暂停状态，因为您在 onResume 方法中打开了到附件的连接，所以您应该注意在 onPause 方法中关闭连接以释放内存。

如果调用生命周期方法 onDestroy，您的活动将被终止，并且不再出现在应用活动堆栈中。这个生命周期阶段可以描述为 onCreate 方法的对立面。尽管您在 onCreate 阶段完成了所有的初始化工作，但是您将在 onDestroy 阶段完成反初始化和清理工作。因为应用只有这一个活动，所以当 onDestroy 在活动上被调用时，应用也会被系统杀死。您在创建时注册了一个广播接收器，以收听特定于配件的事件。由于应用不再存在，你应该在这里注销这个广播接收器。为此，使用广播接收器作为参数调用 unregisterReceiver 方法。

生命周期方法到此结束。到目前为止，这相当容易。通信部分的实现一开始看起来有点棘手，但是不要担心。我会引导你完成它(见清单 2-10 )。

清单 2-10。【HelloWorldActivity.java (建立附件连接)

private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); if (ACTION_USB_PERMISSION.equals(action)) { synchronized (this) { UsbAccessory accessory = UsbManager.getAccessory(intent); if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) { openAccessory(accessory); } else { Log.d(TAG, "permission denied for accessory " + accessory); } mPermissionRequestPending = false; } } else if (UsbManager.ACTION_USB_ACCESSORY_DETACHED.equals(action)) { UsbAccessory accessory = UsbManager.getAccessory(intent); if (accessory != null && accessory.equals(mAccessory)) { `closeAccessory();
}
}
}
};

private void openAccessory(UsbAccessory accessory) {
mFileDescriptor = mUsbManager.openAccessory(accessory);
if (mFileDescriptor != null) {
mAccessory = accessory;
FileDescriptor fd = mFileDescriptor.getFileDescriptor();
mInputStream = new FileInputStream(fd);
mOutputStream = new FileOutputStream(fd);
Thread thread = new Thread(null, commRunnable, TAG);
thread.start();
Log.d(TAG, "accessory opened");
} else {
Log.d(TAG, "accessory open fail");
}
}

private void closeAccessory() {
try {
if (mFileDescriptor != null) {
mFileDescriptor.close();
}
} catch (IOException e) {
} finally {
mFileDescriptor = null;
mAccessory = null;
}
}`

这里首先看到的是 BroadcastReceiver 的实现。现在您知道您需要在各自的生命周期方法中注册和注销广播接收器，但是现在让我们看看应该如何实现广播接收器。

`private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {

@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (ACTION_USB_PERMISSION.equals(action)) {
synchronized (this) {
UsbAccessory accessory = UsbManager.getAccessory(intent);
if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
openAccessory(accessory);
} else {
Log.d(TAG, "permission denied for accessory " + accessory);
}
mPermissionRequestPending = false;
}
} else if (UsbManager.ACTION_USB_ACCESSORY_DETACHED.equals(action)) { UsbAccessory accessory = UsbManager.getAccessory(intent);
if (accessory != null && accessory.equals(mAccessory)) {
closeAccessory();
}
}
}
};`

广播接收器是作为 broadcast receiver 类型的匿名内部类实现的。您必须覆盖的唯一方法是 onReceive 方法，如果该广播接收器已注册并与提供的 intent-filter 匹配，则系统会调用该方法。记住，在意图过滤器中定义了两个动作。您必须检查在调用广播接收器时发生了什么操作。如果您收到描述许可请求已被回应的操作，您必须检查用户是否被授予与您的配件通信的许可。如果是这样，您可以打开附件的通信通道。可能已经触发广播接收器的第二个动作是附件已经从 Android 设备分离的通知。在这种情况下，你需要清理并关闭你的沟通渠道。如您所见，BroadcastReceiver 调用 openAccessory 方法和 closeAccessory 方法来打开和关闭附件的通信通道。接下来我们来看看那些方法。

private void openAccessory(UsbAccessory accessory) { mFileDescriptor = mUsbManager.openAccessory(accessory); if (mFileDescriptor != null) { mAccessory = accessory; FileDescriptor fd = mFileDescriptor.getFileDescriptor(); mInputStream = new FileInputStream(fd); mOutputStream = new FileOutputStream(fd); Thread thread = new Thread(null, commRunnable, TAG); thread.start(); Log.d(TAG, "accessory opened"); } else { Log.d(TAG, "accessory open fail"); } }

在 openAccessory 方法中，您委托 USB 服务方法(也称为 openAccessory)来获取附件的 FileDescriptor。FileDescriptor 管理您将用来与设备通信的输入和输出流。一旦流被分配，你也将启动一个单独的线程，该线程将实际接收和发送消息，但稍后会详细介绍。

如果您还没有权限连接到您的附件，并且您没有处于用户权限的挂起状态，您必须通过调用 USB 服务上的 request permission 方法来请求您的附件的权限。requestPermission 方法有两个参数，您请求权限的附件和待定意向。这个挂起的意图是您在 onCreate 方法中定义的 mPermissionIntent，它负责在用户授予或拒绝与附件通信的权限时发送带有 ACTION_USB_PERMISSION 的广播。您可能还记得，您还在 onCreate 方法中注册了一个广播接收器，该方法为完全相同的操作提供了一个 intent-filter。一旦广播被发送，广播接收器将对其做出反应。

closeAccessory 方法负责关闭附件的所有剩余的打开连接。

private void closeAccessory() { try { if (mFileDescriptor != null) { mFileDescriptor.close(); } } catch (IOException e) { } finally { mFileDescriptor = null; mAccessory = null; } }

它所做的只是关闭附件的文件描述符。系统将处理与其流相关联的所有底层 OS 资源。

当您最终打开与附件的连接时，您可以来回发送和接收数据。清单 2-11 显示了实际的通信实现。

清单 2-11。【HelloWorldActivity.java (通信实施)

`Runnable commRunnable = new Runnable() {

@Override
public void run() {
int ret = 0;
byte[] buffer = new byte[255];

while (ret >= 0) {
try {
ret = mInputStream.read(buffer);
} catch (IOException e) {
break;
}

switch (buffer[0]) {
case COMMAND_TEXT:

final StringBuilder textBuilder = new StringBuilder();
int textLength = buffer[2];
int textEndIndex = 3 + textLength;
for (int x = 3; x < textEndIndex; x++) {
textBuilder.append((char) buffer[x]);
}

runOnUiThread(new Runnable() {

@Override
public void run() {
textView.setText(textBuilder.toString());
}
}); sendText(COMMAND_TEXT, TARGET_DEFAULT, "Hello World from Android!");
break;

default:
Log.d(TAG, "unknown msg: " + buffer[0]);
break;
}

}
}
};
public void sendText(byte command, byte target, String text) {
int textLength = text.length();
byte[] buffer = new byte[3 + textLength];
if (textLength <= 252) {
buffer[0] = command;
buffer[1] = target;
buffer[2] = (byte) textLength;
byte[] textInBytes = text.getBytes();
for (int x = 0; x < textLength; x++) {
buffer[3 + x] = textInBytes[x];
}
if (mOutputStream != null) {
try {
mOutputStream.write(buffer);
} catch (IOException e) {
Log.e(TAG, "write failed", e);
}
}
}
}`

一旦建立了与附件的连接，就可以开始实际发送和接收消息了。您可能还记得，openAccessory 方法中启动了一个单独的线程，负责消息处理。

Thread thread = new Thread(null, commRunnable, TAG); thread.start();

传递给线程的 Runnable 对象也是您必须实现的匿名内部类。只要您拥有来自附件的活动 inputstream，就会执行它的 run 方法。

`Runnable commRunnable = new Runnable() {

@Override
public void run() {
int ret = 0;
byte[] buffer = new byte[255];

while (ret >= 0) {
try { ret = mInputStream.read(buffer);
} catch (IOException e) {
break;
}

switch (buffer[0]) {
case COMMAND_TEXT:
final StringBuilder textBuilder = new StringBuilder();
int textLength = buffer[2];
int textEndIndex = 3 + textLength;
for (int x = 3; x < textEndIndex; x++) {
textBuilder.append((char) buffer[x]);
}
runOnUiThread(new Runnable() {

@Override
public void run() {
textView.setText(textBuilder.toString());
}
});
sendText(COMMAND_TEXT, TARGET_DEFAULT, "Hello World from Android!");
break;

default:
Log.d(TAG, "unknown msg: " + buffer[0]);
break;
}
}
}
};`

在每个迭代步骤中，inputstream 的内容被读入一个字节数组。如果第一个字节表示您收到了 COMMAND_TEXT 类型的消息，那么将使用 StringBuilder 从发送的剩余字节中构建消息。

既然您已经完成了消息，那么您需要向用户显示它。记住你仍然在一个单独的线程中。系统只允许 UI 更新发生在 UI 线程上。要更新 TextView UI 元素的文本，可以使用方便的方法 runOnUiThread，该方法在系统 UI 线程上执行给定的 Runnable 对象。

这就是消息处理的接收部分。收到一条消息后，另一条消息会立即发送回公告板。为此，您将编写自己的名为 sendText 的方法，该方法采用前两个标识符字节和实际消息来构建您的消息数据结构，您可以通过 outputstream 将其发送到附件。

public void sendText(byte command, byte target, String text) { int textLength = text.length(); byte[] buffer = new byte[3 + textLength]; if (textLength <= 252) { buffer[0] = command; buffer[1] = target; buffer[2] = (byte) textLength; byte[] textInBytes = text.getBytes(); for (int x = 0; x < textLength; x++) { buffer[3 + x] = textInBytes[x]; } if (mOutputStream != null) { try { mOutputStream.write(buffer); } catch (IOException e) { Log.e(TAG, "write failed", e); } } } }

恭喜你！您已经完成了通信双方的实现。现在，将 Arduino 草图上传到您的 ADK 板上，并将 Android 应用部署到您的设备上。如果你把你的 Android 设备连接到你的 ADK 板，你应该看到你的 Android 应用自动启动，它将打印 ADK 板发送的信息。如果您在开发板连接到 PC 时打开串行监视器，您可以看到来自 Android 设备的信息。每个设备显示对方的信息，如图图 2-18 和图 2-19 所示。

图 2-18。Android 设备上的 HelloWorld 应用接收消息

图 2-19。接收消息的 Arduino 应用的串行监视器输出

总结

您已经了解了 Android 设备和 Arduino 配件在连接时如何相互识别。您了解了在 Arduino 端和通信的 Android 端实现开放附件协议的必要条件。Arduino 端的实现相当简单，因为大部分工作已经在 AndroidAccessory Arduino 库的帮助下完成了。你已经看到，软件的挑战在于 Android 设备的编码，因为有更多的工作要做。本章向您展示了如何使用自定义的数据结构跨两个平台传输文本消息。接下来的章节将基于你已经学到的知识，使你能够用 ADK 板读取传感器值或控制执行器。您在此完成的项目将是本书中后续示例的基础。

三、输出

源自原始 Arduino 设计的 ADK 板有几个引脚和连接器。这些引脚大多数是数字引脚。这种 ADK 板上的数字引脚可以配置为输入或输出。本章描述了如何将数字引脚配置为输出引脚。

在这种特殊情况下，输出意味着什么？这意味着当设置为输出模式时，引脚将发射功率。源自 Arduino 的 ADK 板上的数字引脚可以发射高达 5V 的电压。它们可以用在数字环境中，可以有两种状态，HIGH和LOW。将输出引脚设置为HIGH意味着它将发出 5V。如果设置为LOW，则发出 0V，因此没有电压。一些输出引脚也可用于模拟环境。这意味着它们能够发出从 0V 到 5V 的输出值范围。

以下两个项目将在实际应用中解释这两种用例。

项目 1:切换 LED

这是您将使用附加硬件部件的许多项目中的第一个。您将利用 ADK 板的数字引脚作为输出端口来为发光二极管(LED)供电，并编写一个 Android 应用来打开和关闭 LED。

零件

您将在本项目中使用以下硬件(如图 3-1 所示):

ADK 董事会
试验板
工作电压为 5V 的 LED
S7-1200 可编程控制器
一些电线

图 3-1。项目 1 零件(ADK 板、试验板、电阻器、LED、电线)

LED

一个发光二极管 (LED)是一个充当光源的小半导体(见图 3-2 )。你家里几乎所有的电子设备上都可以找到 led。大多数情况下，它们被用作状态指示器。led 被设计成非常节能和可靠。这就是为什么他们也找到了进入艺术装置、汽车前灯和普通家庭照明解决方案的方法，这里仅举几个例子。

图 3-2。5 毫米红色 LED

有许多类型的发光二极管。它们在尺寸、色谱和工作电压上有所不同。led 具有方向性，这意味着如何在电路中连接它们至关重要。普通 led 有一个阳极(正极连接器)和一个阴极(负极连接器)。你必须将能量源的正极连接到阳极，负极连接到阴极。如果你把它反过来连接，你会永久损坏它。在普通 LED 上，您可以通过几种方式区分连接器。您可能会注意到，LED 的引脚长度不同。长腿是阳极(正极连接器)，短腿是阴极(负极连接器)。如果您有一个透明的 LED 透镜，您可能会看到两个 LED 连接器在其嵌入端具有不同的形式。看起来像半个箭头的小一点的就是所谓的帖。接线柱是阳极连接器的嵌入端。阴极预埋件称为砧。一些发光二极管在其透镜的一侧也有一个扁平点。这一面标志着阴极。你可以看到，我们已经做了很多工作来区分两种连接器，这样你就不会因为连接错误而意外损坏 LED。

在这个项目中，您将使用 ADK 板的一个数字输出端口，当它被设置为HIGH时在 5V 下工作，当它被设置为LOW时在 0V 下工作。你应该使用同样在 5V 电压下工作的 LED，这样它的寿命会更长。您也可以使用 3.3V 的较低额定 LED，但较高的电压水平会更快地磨损 LED。LED 通常在 20mA 到 30mA 的电流下工作，您应该限制流动的电流，以便 LED 不会被更高的电流损坏。为了限制电流，你使用一个电阻。如果没有这样的限流电阻，就不应该使用 led。

电阻器

电阻器是用来限制电路中电流的电子元件。电阻是施加在电阻上的电压与流过电阻的电流成正比的比值。这个比例是由欧姆定律定义的。欧姆定律是电气工程中最重要的公式之一。你经常需要它来决定在电路中使用哪个电阻来限制电流，这样你就不会烧坏你的元件。该公式的定义如下:

V = R × I

如你所见，电压是电阻和电流的乘积。电压用伏特测量，单位符号为 v。电流用安培测量，单位符号为 a。电阻用欧姆测量，单位符号为希腊字母ω。在一个简单的例子中，公式可以这样应用:

5V = 250Ω × 0.02A

标准的 3 毫米和 5 毫米 led 在 20mA 至 30mA 的电流限制下工作。当数字输出端口设置为HIGH时，您希望将电流限制在 30mA 左右，并提供 5V 电压。如果你应用欧姆定律并重新排列，你就可以计算出所需电阻的电阻值。

电阻有标准化的范围，你找不到像 166ω这样的特定值。您应该始终使用下一个可用的较高电阻值，而不要使用较低值，因为您不想因过载而永久损坏您的组件。下一个更高的电阻值是 220ω电阻。

你已经学会了如何确定在这个项目中你需要的电阻值。现在，我们来看看常见的电阻种类，以及如何通过观察来识别它们的值。

电阻有多种形式和尺寸，但除了小型表面贴装器件(SMD)，最常用的电阻是碳化合物电阻和薄膜电阻，如图图 3-3 所示。

图 3-3。碳化合物电阻器(下)，薄膜电阻器(上)

碳化合物电阻器由碳和其他化合物组成，因此得名。电阻值取决于混合物中的碳含量。碳化合物电阻器通常比其他电阻器更耐用，因为它们可以更好地处理高脉冲，而不会对其电阻值产生长期影响。缺点是它们不是最精确的电阻。

薄膜电阻器具有由金属薄膜覆盖的绝缘陶瓷棒或基底。金属涂层的厚度决定了电阻器的电阻特性。薄膜电阻器不如碳化合物电阻器坚固，因为它们容易受到高脉冲和过载的影响，这会损害它们的电阻能力。这些电阻的优点是比碳化合物电阻更精确。

上述标准应在生产电路设计中考虑，但不适用于我们的简单项目。

两种类型的电阻器表面都涂有彩色条纹。这些条带有助于识别电阻器的电阻值。碳化合物电阻器具有 4 段颜色编码，而薄膜电阻器具有 5 段颜色编码。

表 3-1 给你一个颜色编码的概述。

您可能想知道应该从电阻的哪一端读取色带。如果你仔细观察，你会发现一个波段与其他波段的距离稍大。这是公差带。图 3-4 显示了一个 4 频段碳化合物 220ω电阻，公差为+- 5%。第一个频段为红色(2)，第二个频段为红色(2)，乘法器频段为棕色(10)，即 22×10ω= 220ω。公差带为金色(+- 5%)。

图 3-4。220ω+-5%碳化合物电阻器

试验板

一个试验板，也称为原型板，是一种不需要焊接的原型板。它通常是一块有穿孔的塑料。这些孔的标准间距通常为 0.1 英寸(2.54 毫米)。

图 3-5。试验板/原型板

嵌入电路板的是以特殊布局排列的导电触点。这些板允许即插即用机制，以便您可以专注于电路设置，而不是将所有东西焊接在一起。这样，如果你在设置中犯了错误，你可以快速调整电路。电路板有多种形式和尺寸，但基本布局基本相同。顶部和底部导轨上的触点主要用于连接电源的正极和负极端口。电路板中间的区域是实际的原型制作区域。嵌入试验板的连接布局如图图 3-6 所示。

图 3-6。试验板触点布局

ADK 董事会

在第一章中，您了解了 ADK 板的规格。Arduino 衍生的 ADK 板有几个数字输入和输出引脚。您将使用其中一个引脚作为输出端口来开关 LED。输出端口可以提供高达 5V 的电压。您将使用在图 3-7 中看到的数字输出引脚 2，并且您将在数字环境(HIGH / LOW)中设置输出值。

图 3-7。数字输出引脚 2

电线

你需要一些电线将试验板上的电阻和 LED 连接到 ADK 板上。对于原型制作和试验板工作，有特殊的试验板或跳线。使用这些电线的好处是你不必自己剥开它们，它们有不同的长度，并且有公母接头。

图 3-8。左起:电子线、跳线(公对公)、跳线(母对公)

如果你不想买现成的电线，你也可以使用电子或贝尔线。您必须剥去这些电线上的电线末端，露出大约 3/16 英寸至 5/16 英寸(5 毫米至 8 毫米)的电线，以便与嵌入试验板的触点良好接触。你可以用小刀小心地切开电线绝缘体，然后把它剥掉，但我强烈推荐使用电缆剥线钳，这是一种更安全、更容易操作的工具。你只需抓住电线，施加一些软压力，将隔离器从电线上剥离。(参见图 3-9 。)

图 3-9。剥线器

设置

你需要把电阻串联到发光二极管上。ADK 板的数字输出引脚 2 将连接到您的电阻器，电阻器连接到 LED 的阳极，ADK 板的地(GND)将连接到 LED 的阴极(负极引线)。如图 3-10 所示连接所有部件。

图 3-10。项目 1 设置

软件

硬件设置已经完成，是时候编写控制 LED 的代码了。您将编写一个 Arduino 草图，它接收切换命令，并根据 Android 应用发送的命令切换 LED。Android 应用将由一个控制开关状态的切换按钮组成。

Arduino 草图

以第二章中写的 Arduino 草图作为这个草图的基础。您已经在其中实现了特定于 ADK 的部分，您只需通过为 LED 切换场景定义另一个数据协议来更改通信部分。创建一个新的草图，并输入清单 3-1 中所示的代码。之后，我会解释发生了什么变化。

清单 3-1。项目一:Arduino 草图

`#include <Max3421e.h>

include <Usb.h>

include <AndroidAccessory.h>

#define COMMAND_LED 0x2
#define TARGET_PIN_2 0x2
#define VALUE_ON 0x1
#define VALUE_OFF 0x0

#define PIN 2

AndroidAccessory acc("Manufacturer",
"Model",
"Description",
"Version",
"URI",
"Serial");

byte rcvmsg[3];

void setup() {
Serial.begin(19200);
acc.powerOn();
pinMode(PIN, OUTPUT);
}

void loop() {
if (acc.isConnected()) {
//read the received data into the byte array
int len = acc.read(rcvmsg, sizeof(rcvmsg), 1);
if (len > 0) {
if (rcvmsg[0] == COMMAND_LED) {
if (rcvmsg[1] == TARGET_PIN_2){
//get the switch state
byte value = rcvmsg[2];
//set output pin to according state
if(value == VALUE_ON) {
digitalWrite(PIN, HIGH); } else if(value == VALUE_OFF) {
digitalWrite(PIN, LOW);
}
}
}
}
}
}`

你可能注意到的第一件事是来自第二章的短信专用代码被删除了。在这个项目中你不需要发送文本，所以代码已经被修改以支持 3 字节数据协议，这在第二章中也提到过。为了评估从 Android 设备接收的数据，您必须定义一个命令字节、一个目标字节和一个值字节常量。定义的数据协议字节常量COMMAND_LED、TARGET_PIN_2、VALUE_ON,和VALUE_OFF的含义应该是不言自明的。您还定义了一个PIN常量，它反映了应该被控制的管脚。

除了已知的必须在setup方法中进行的附件初始化之外，您还需要配置想要使用的数字引脚的模式。因为您希望引脚作为输出工作，所以需要用pinMode(PIN, OUTPUT)设置引脚模式。

在loop方法中，您检查已建立的连接并读取传入的数据。然后计算第三个字节的值。如果您接收到一个0x1字节，您将引脚设置为HIGH以输出 5V，如果您接收到一个0x0字节，您将引脚设置为LOW以使其输出为 0V。为此，您将使用digitalWrite方法。它的参数是要设置的引脚和它应该切换到的状态，HIGH或LOW。

Arduino 部分到此为止。让我们继续 Android 软件部分。

Android 应用

对于 Android 部分，你也将建立在你在第二章中从你的 Android 应用中学到的原则之上。您还必须调整数据协议并引入一个新的 UI 元素，一个 ToggleButton，它允许用户打开和关闭 LED。让我们看看清单 3-2 中的类，以及您必须做出的更改。

清单 3-2。项目一:ProjectOneActivity.java

`package project.one.adk;

import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import android.app.Activity;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.ParcelFileDescriptor; import android.util.Log;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.ToggleButton;

import com.android.future.usb.UsbAccessory;
import com.android.future.usb.UsbManager;

public class ProjectOneActivity extends Activity {

private static final String TAG = ProjectOneActivity.class.getSimpleName();

private PendingIntent mPermissionIntent;
private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
private boolean mPermissionRequestPending;

private UsbManager mUsbManager;
private UsbAccessory mAccessory;
private ParcelFileDescriptor mFileDescriptor;
private FileInputStream mInputStream;
private FileOutputStream mOutputStream;

private static final byte COMMAND_LED = 0x2;
private static final byte TARGET_PIN_2 = 0x2;
private static final byte VALUE_ON = 0x1;
private static final byte VALUE_OFF = 0x0;

private ToggleButton ledToggleButton;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

mUsbManager = UsbManager.getInstance(this);
mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent(
ACTION_USB_PERMISSION), 0);
IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
filter.addAction(UsbManager.ACTION_USB_ACCESSORY_DETACHED);
registerReceiver(mUsbReceiver, filter);

setContentView(R.layout.main);
ledToggleButton = (ToggleButton) findViewById(R.id.led_toggle_button);
ledToggleButton.setOnCheckedChangeListener(toggleButtonCheckedListener);
}

/**

Called when the activity is resumed from its paused state and immediately
after onCreate().
*/
@Override public void onResume() {
super.onResume();

if (mInputStream != null && mOutputStream != null) {
return;
}

/** Called when the activity is paused by the system. */
@Override
public void onPause() {
super.onPause();
closeAccessory();
}

/**

Called when the activity is no longer needed prior to being removed from
the activity stack.
*/
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mUsbReceiver);
}

OnCheckedChangeListener toggleButtonCheckedListener = new OnCheckedChangeListener() {

@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (buttonView.getId() == R.id.led_toggle_button) {

new AsyncTask<Boolean, Void, Void>() {

@Override
protected Void doInBackground(Boolean... params) { sendLedSwitchCommand(TARGET_PIN_2, params[0]);
return null;
}
}.execute(isChecked);
}
}
};

private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (ACTION_USB_PERMISSION.equals(action)) {
synchronized (this) {
UsbAccessory accessory = UsbManager.getAccessory(intent);
if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
openAccessory(accessory);
} else {
Log.d(TAG, "permission denied for accessory " + accessory);
}
mPermissionRequestPending = false;
}
} else if (UsbManager.ACTION_USB_ACCESSORY_DETACHED.equals(action)) {
UsbAccessory accessory = UsbManager.getAccessory(intent);
if (accessory != null && accessory.equals(mAccessory)) {
closeAccessory();
}
}
}
};

private void openAccessory(UsbAccessory accessory) {
mFileDescriptor = mUsbManager.openAccessory(accessory);
if (mFileDescriptor != null) {
mAccessory = accessory;
FileDescriptor fd = mFileDescriptor.getFileDescriptor();
mInputStream = new FileInputStream(fd);
mOutputStream = new FileOutputStream(fd);
Log.d(TAG, "accessory opened");
} else {
Log.d(TAG, "accessory open fail");
}
}

private void closeAccessory() {
try {
if (mFileDescriptor != null) {
mFileDescriptor.close();
}
} catch (IOException e) {
} finally {
mFileDescriptor = null; mAccessory = null;
}
}

public void sendLedSwitchCommand(byte target, boolean isSwitchedOn) {
byte[] buffer = new byte[3];
buffer[0] = COMMAND_LED;
buffer[1] = target;
if (isSwitchedOn) {
buffer[2] = VALUE_ON;
} else {
buffer[2] = VALUE_OFF;
}
if (mOutputStream != null) {
try {
mOutputStream.write(buffer);
} catch (IOException e) {
Log.e(TAG, "write failed", e);
}
}
}
}`

如果您像这里一样更改了活动名和包名，请确保您也更改了 AndroidManifest.xml 条目以反映这种重命名。

清单 3-3。项目 1: AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android" **package="project.one.adk"** android:versionCode="1" android:versionName="1.0"> … <activity **android:name=".ProjectOneActivity"** android:label="@string/app_name" android:screenOrientation="portrait"> … </manifest>

数据协议常量已从 4 字节协议更改为 3 字节协议。正如您在 Arduino 草图中所做的那样，您还为 LED 切换数据消息定义了常数。

private static final byte COMMAND_LED = 0x2; private static final byte TARGET_PIN_2 = 0x2; private static final byte VALUE_ON = 0x1; private static final byte VALUE_OFF = 0x0;

这个项目的范围是开关 LED，所以你不需要显示任何文本。因此，TextView UI 元素已被 ToggleButton 替换。

`private ToggleButton ledToggleButton;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
…
setContentView(R.layout.main);
ledToggleButton = (ToggleButton) findViewById(R.id.led_toggle_button);
ledToggleButton.setOnCheckedChangeListener(toggleButtonCheckedListener);
}`

您可以看到一个OnCheckedChangeListener被分配给了ledToggleButton，它实现了一个回调方法，每次按钮被按下时都会触发这个回调方法。ToggleButton是Button的一个特殊的有状态实现，这意味着它知道自己是否被选中。OnCheckedChangeListener的实现是在匿名内部类中完成的。唯一需要实现的方法是onCheckedChange方法，它有两个参数:触发事件的按钮和指示按钮新状态的布尔标志。

`OnCheckedChangeListener toggleButtonCheckedListener = new OnCheckedChangeListener() {

@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (buttonView.getId() == R.id.led_toggle_button) {
new AsyncTask<Boolean, Void, Void>() {

@Override
protected Void doInBackground(Boolean... params) {
sendLedSwitchCommand(TARGET_PIN_2, params[0]);
return null;
}
}.execute(isChecked);
}
}
};`

如果您有多个按钮使用同一个监听器，您应该总是验证是否按下了正确的按钮。这里就是这么做的。在这个特定的项目中，您不需要检查这一点，因为您只使用了一个按钮，但是如果您计划将侦听器用于更多的组件，这是一个很好的实践。在确认正确的按钮触发了事件后，您可以开始向 ADK 板发送命令来切换 LED。sendText方法已经被移除，因为在这个项目中不需要它。实现了一种新方法，将 3 字节数据消息发送到名为sendLedSwitchCommand的板。它有两个参数，LED 连接的 ADK 板的目标引脚和它应该切换到的状态。

你可能想知道这个AsyncTask是怎么回事。事件回调方法在 UI 线程上执行。如果您只是将消息发送到那里，您也可以在 UI 线程中执行 outputstream 操作。这通常是可行的，但这是一种不好的做法。较长的操作可能会阻塞用户界面，这对用户来说是非常令人沮丧的。为了避免这些情况，你可以做几件事:打开另一个Thread，利用 Android 的Handler机制，或者像在这种情况下一样，使用一个AsyncTask来实现并发。解释每种方法的优缺点超出了本书的范围，但是你可以在http://developer.android.com/guide/topics/fundamentals/processes-and-threads.html的 Android 开发指南中读到很多。AsyncTask基本上做的是在后台打开另一个线程来处理你的操作，同时你的 UI 线程运行来服务用户。这里只实现了doInBackground方法，因为这是您所需要的。此外，AsyncTask具有运行在 UI 线程上的回调方法，以可视化后台操作的进度或在操作完成时更新 UI 元素。

sendLedSwitchCommand方法看起来类似于您已经知道的sendText方法，但是它实现了 3 字节数据协议。

public void sendLedSwitchCommand(byte target, boolean isSwitchedOn) { byte[] buffer = new byte[3]; buffer[0] = COMMAND_LED; buffer[1] = target; if (isSwitchedOn) { buffer[2] = VALUE_ON; } else { buffer[2] = VALUE_OFF; } if (mOutputStream != null) { try { mOutputStream.write(buffer); } catch (IOException e) { Log.e(TAG, "write failed", e); } } }

代码改动到此为止。您记得应该向用户显示一个ToggleButton，所以您也需要在布局文件main.xml中做一些更改(清单 3-4 )。

清单 3-4。项目一:main.xml

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent" android:gravity="center"> **<ToggleButton android:id="@+id/led_toggle_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:textOn="@string/led_on" android:textOff="@string/led_off" />** </LinearLayout>

如您所见，TextView元素被ToggleButton元素所取代。它被定义为只和它自己的内容一样宽一样高；勾选或取消勾选时显示的文本在strings.xml文件中被引用。如果你在 Eclipse 中切换到图形布局编辑器，你已经可以在你的布局中间看到这个按钮了(图 3-11 )。

图 3-11。项目 1:main . XML 的 Eclipse 图形化布局

这就是这个项目的 Android 部分要做的全部工作。项目 1 现在已经完成，可以测试了。上传两个设备的应用，将它们连接在一起，你应该会得到类似于你在图 3-12 中看到的东西。

图 3-12。项目 1:最终结果