", {
4 | "id": "disqus_thread"
5 | });
6 | $(".book-body .page-inner").append($disqusDiv);
7 |
8 | if (typeof DISQUS !== "undefined") {
9 | DISQUS.reset({
10 | reload: true,
11 | config: function () {
12 | this.language = "en";
13 | this.page.url = window.location.href;
14 | }
15 | });
16 | }
17 | }
18 |
19 | gitbook.events.bind("start", function(e, config) {
20 | config.disqus = config.disqus || {};
21 | var disqus_shortname = config.disqus.shortName;
22 |
23 | /* * * DON'T EDIT BELOW THIS LINE * * */
24 | (function() {
25 | var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
26 | dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
27 | (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
28 | })();
29 |
30 | resetDisqus();
31 | });
32 |
33 | gitbook.events.bind("page.change", resetDisqus);
34 | });
--------------------------------------------------------------------------------
/basics/activity-lifecycle/index.md:
--------------------------------------------------------------------------------
1 | # 管理Activity的生命周期
2 |
3 | > 原文:
4 |
5 | 当用户导航、退出和返回您的应用时，应用中的 [Activity](http://developer.android.com/reference/android/app/Activity.html) 实例将在其生命周期中转换不同状态。 例如，当您的Activity初次开始时，它将出现在系统前台并接收用户焦点。 在这个过程中，Android 系统会对Activity调用一系列生命周期方法，通过这些方法，您可以设置用户界面和其他组件。 如果用户执行开始另一Activity或切换至另一应用的操作，当其进入后台（在其中Activity不再可见，但实例及其状态完整保留），系统会对您的Activity调用另外一系列生命周期方法。
6 |
7 | 在生命周期回调方法内，您可以声明用户离开和再次进入Activity时的Activity行为。比如，如果您正构建流视频播放器，当用户切换至另一应用时，您可能要暂停视频或终止网络连接。当用户返回时，您可以重新连接网络并允许用户从同一位置继续播放视频。
8 |
9 | 本课讲述每个 [Activity](http://developer.android.com/reference/android/app/Activity.html) 实例接收的重要生命周期回调方法以及您如何使用这些方法以使您的Activity按照用户预期进行并且当您的Activity不需要它们时不会消耗系统资源。
10 |
11 | **完整的Demo示例**：[ActivityLifecycle.zip](http://developer.android.com/shareables/training/ActivityLifecycle.zip)
12 |
13 |
14 |
15 | ## Lessons
16 |
17 | * [**启动与销毁Activity**](starting.html)
18 |
19 | 学习有关Activity生命周期、用户如何启动您的应用以及如何执行基本Activity创建操作的基础知识。
20 |
21 |
22 | * [**暂停与恢复Activity**](pausing.html)
23 |
24 | 学习Activity暂停时（部分隐藏）和继续时的情况以及您应在这些状态变化期间执行的操作。
25 |
26 |
27 | * [**停止与重启Activity**](stopping.html)
28 |
29 | 学习用户完全离开您的Activity并返回到该Activity时发生的情况。
30 |
31 |
32 | * [**重新创建Activity**](recreating.html)
33 |
34 | 学习您的Activity被销毁时的情况以及您如何能够根据需要重新构建Activity。
35 |
--------------------------------------------------------------------------------
/manifest.appcache:
--------------------------------------------------------------------------------
1 | CACHE MANIFEST
2 | # Revision 1407253957629
3 |
4 | CACHE:
5 | gitbook/app.js
6 | gitbook/fonts/fontawesome/FontAwesome.otf
7 | gitbook/fonts/fontawesome/fontawesome-webfont.eot
8 | gitbook/fonts/fontawesome/fontawesome-webfont.svg
9 | gitbook/fonts/fontawesome/fontawesome-webfont.ttf
10 | gitbook/fonts/fontawesome/fontawesome-webfont.woff
11 | gitbook/fonts/merriweather/250.woff
12 | gitbook/fonts/merriweather/250i.woff
13 | gitbook/fonts/merriweather/400.woff
14 | gitbook/fonts/merriweather/400i.woff
15 | gitbook/fonts/merriweather/700.woff
16 | gitbook/fonts/merriweather/700i.woff
17 | gitbook/fonts/merriweather/900.woff
18 | gitbook/fonts/merriweather/900i.woff
19 | gitbook/fonts/opensans/300.woff
20 | gitbook/fonts/opensans/300i.woff
21 | gitbook/fonts/opensans/400.woff
22 | gitbook/fonts/opensans/400i.woff
23 | gitbook/fonts/opensans/600.woff
24 | gitbook/fonts/opensans/600i.woff
25 | gitbook/fonts/opensans/700.woff
26 | gitbook/fonts/opensans/700i.woff
27 | gitbook/images/favicon.ico
28 | gitbook/jsrepl/engines/javascript-default.js
29 | gitbook/jsrepl/jsrepl.js
30 | gitbook/jsrepl/langs/javascript/jsrepl_js.js
31 | gitbook/jsrepl/sandbox.html
32 | gitbook/jsrepl/sandbox.js
33 | gitbook/print.css
34 | gitbook/style.css
35 | gitbook/plugins/gitbook-plugin-disqus/plugin.js
36 | gitbook/plugins/gitbook-plugin-mathjax/plugin.js
37 |
38 | NETWORK:
39 | *
--------------------------------------------------------------------------------
/ux/implement-nav/index.md:
--------------------------------------------------------------------------------
1 | # 实现高效的导航
2 |
3 | > 编写:[Lin-H](https://github.com/Lin-H) - 原文:
4 |
5 | 这节课将会演示如何实现在[Designing Effective Navigation](http://developer.android.com/training/design-navigation/index.html)中所详述的关键导航设计模式。
6 |
7 | 在阅读这节课程内容之后，你会对如何使用tabs, swipe views, 和navigation drawer实现导航模式有一个深刻的理解。也会明白如何提供合适的向前向后导航(Up and Back navigation)。
8 |
9 | > **Note**:本节课中的几个元素需要使用[Support Library](http://developer.android.com/tools/support-library/index.html) API。如果你之前没有使用过Support Library，可以按照[Support Library Setup](http://developer.android.com/tools/support-library/setup.html)文档说明来使用。
10 |
11 | ## Sample Code
12 |
13 | [EffectiveNavigation.zip](http://developer.android.com/shareables/training/EffectiveNavigation.zip)
14 |
15 | ## Lessons
16 |
17 | * [使用Tabs创建Swipe View](lateral.md)
18 |
19 | 学习如何在action bar中实现tab，并提供横向分页(swipe views)在tab之间导航切换。
20 |
21 |
22 | * [创建抽屉导航(Navigation Drawer)](nav-drawer.md)
23 |
24 | 学习如何建立隐藏于屏幕边上的界面，通过划屏(swipe)或点击action bar中的app图标来显示这个界面。
25 |
26 |
27 | * [提供向上导航](ancestral.md)
28 |
29 | 学习如何使用action bar中的app图标实现向上导航
30 |
31 |
32 | * [提供适当的向后导航](temporal.md)
33 |
34 | 学习如何正确处理特殊情况下的向后按钮(Back button)，包括在通知或app widget中的深度链接，如何将activity插入后退栈(back stack)中。
35 |
36 |
37 | * [实现Descendant Navigation](descendant.md)
38 |
39 | 学习更精细地导航进入你的应用信息层。
40 |
41 |
--------------------------------------------------------------------------------
/ui/system-ui/visibility.md:
--------------------------------------------------------------------------------
1 | # 响应UI可见性的变化
2 |
3 | > 编写:[K0ST](https://github.com/K0ST) - 原文:
4 |
5 | 本节课将教你如果注册监听器来监听系统UI可见性的变化。这个方法在将系统栏与你自己的UI控件进行同步操作时很有用。
6 |
7 | ## 注册监听器
8 |
9 | 为了获取系统UI可见性变化的通知，我们需要对View注册`View.OnSystemUiVisibilityChangeListener`监听器。通常上来说，这个View是用来控制导航的可见性的。
10 |
11 | 例如你可以添加如下代码在onCreate中
12 |
13 | ```java
14 | View decorView = getWindow().getDecorView();
15 | decorView.setOnSystemUiVisibilityChangeListener
16 | (new View.OnSystemUiVisibilityChangeListener() {
17 | @Override
18 | public void onSystemUiVisibilityChange(int visibility) {
19 | // Note that system bars will only be "visible" if none of the
20 | // LOW_PROFILE, HIDE_NAVIGATION, or FULLSCREEN flags are set.
21 | if ((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0) {
22 | // TODO: The system bars are visible. Make any desired
23 | // adjustments to your UI, such as showing the action bar or
24 | // other navigational controls.
25 | } else {
26 | // TODO: The system bars are NOT visible. Make any desired
27 | // adjustments to your UI, such as hiding the action bar or
28 | // other navigational controls.
29 | }
30 | }
31 | });
32 | ```
33 |
34 | 保持系统栏和UI同步是一种很好的实践方式，比如当状态栏显示或隐藏的时候进行ActionBar的显示和隐藏等等。
35 |
--------------------------------------------------------------------------------
/background-jobs/run-background-service/send-request.md:
--------------------------------------------------------------------------------
1 | # 向后台服务发送任务请求
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 前一篇文章演示了如何创建一个IntentService类。这次会演示如何通过发送一个Intent来触发IntentService执行任务。这个Intent可以传递一些数据给IntentService。我们可以在Activity或者Fragment的任何时间点发送这个Intent。
6 |
7 | ## 创建任务请求并发送到IntentService
8 |
9 | 为了创建一个任务请求并发送到IntentService。需要先创建一个显式Intent，并将请求数据添加到intent中，然后通过调用
10 | `startService()` 方法把任务请求数据发送到IntentService。
11 |
12 | 下面的是代码示例：
13 |
14 | * 创建一个新的显式Intent用来启动IntentService。
15 |
16 | ```java
17 | /*
18 | * Creates a new Intent to start the RSSPullService
19 | * IntentService. Passes a URI in the
20 | * Intent's "data" field.
21 | */
22 | mServiceIntent = new Intent(getActivity(), RSSPullService.class);
23 | mServiceIntent.setData(Uri.parse(dataUrl));
24 | ```
25 |
26 |
27 |
28 | * 执行`startService()`
29 |
30 | ```java
31 | // Starts the IntentService
32 | getActivity().startService(mServiceIntent);
33 | ```
34 |
35 | 注意可以在Activity或者Fragment的任何位置发送任务请求。例如，如果你先获取用户输入，您可以从响应按钮单击或类似手势的回调方法里面发送任务请求。
36 |
37 | 一旦执行了startService()，IntentService在自己本身的`onHandleIntent()`方法里面开始执行这个任务，任务结束之后，会自动停止这个Service。
38 |
39 | 下一步是如何把工作任务的执行结果返回给发送任务的Activity或者Fragment。下节课会演示如何使用[BroadcastReceiver](http://developer.android.com/reference/android/content/BroadcastReceiver.html)来完成这个任务。
40 |
--------------------------------------------------------------------------------
/input/gestures/index.md:
--------------------------------------------------------------------------------
1 | # 使用触摸手势
2 |
3 | > 编写:[Andrwyw](https://github.com/Andrwyw) - 原文:
4 |
5 | 本章节讲述，如何编写一个允许用户通过触摸手势进行交互的app。Android提供了各种各样的API，来帮助我们创建和检测手势。
6 |
7 | 尽管对于一些基本的操作来说，我们的app不应该依赖于触摸手势（因为某些情况下手势是不用的）。但为我们的app添加基于触摸的交互，将会大大地提高app的可用性和吸引力。
8 |
9 | 为了给用户提供一致的、符合直觉的使用体验，我们的app应该遵守Android触摸手势的惯常做法。[手势设计指南](http://developer.android.com/design/patterns/gestures.html)介绍了在Android app中，如何使用常用的手势。同样，设计指南也提供了[触摸反馈](http://developer.android.com/design/style/touch-feedback.html)的相关内容。
10 |
11 | ## Lessons
12 |
13 | [**检测常用的手势**](detector.html)
14 |
15 | 学习如何通过使用[GestureDetector](http://developer.android.com/reference/android/view/GestureDetector.html)来检测基本的触摸手势，如滑动、惯性滑动以及双击。
16 |
17 |
18 | [**追踪手势移动**](movement.html)
19 |
20 | 学习如何追踪手势移动。
21 |
22 |
23 | [**Scroll手势动画**](scroll.html)
24 |
25 | 学习如何使用scrollers（[Scrollers](http://developer.android.com/reference/android/widget/Scroller.html)以及[OverScroll](http://developer.android.com/reference/android/widget/OverScroller.html)）来产生滚动动画，以响应触摸事件。
26 |
27 |
28 | [**处理多触摸手势**](multi.html)
29 |
30 | 学习如何检测多点(手指)触摸手势。
31 |
32 |
33 | [**拖拽与缩放**](scale.html)
34 |
35 | 学习如何实现基于触摸的拖拽与缩放。
36 |
37 |
38 | [**管理ViewGroup中的触摸事件**](viewgroup.html)
39 |
40 | 学习如何在[ViewGroup](http://developer.android.com/reference/android/view/ViewGroup.html)中管理触摸事件，以确保事件能被正确地分发到目标views上。
41 |
--------------------------------------------------------------------------------
/wearables/apps/bt-debugging.md:
--------------------------------------------------------------------------------
1 | # 通过蓝牙进行调试
2 |
3 | > 编写: [kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 我们可以通过蓝牙来调试我们的可穿戴应用。即通过蓝牙把调试数据输出到已经连接了开发电脑的手持设备上。
6 |
7 | ## 搭建好设备用来调试
8 |
9 | 1. 开启手持设备的USB调试：
10 | * 打开设置应用并滑动到底部。
11 | * 如果在设置里面没有开发者选项，点击**关于手机**（或者**关于平板**），滑动到底部，点击build number 7次。
12 | * 返回并点击**开发者选项**。
13 | * 开启**USB调试**。
14 | 2. 开启可穿戴设备的蓝牙调试：
15 | * 点击主界面2次，来到Wear菜单界面。
16 | * 滑动到底部，点击**设置**。
17 | * 滑动到底部，如果没有**开发者选项**，点击**关于**，然后点击Build Number 7次。
18 | * 点击**开发者选项**。
19 | * 开启**蓝牙调试**。
20 |
21 | ## 建立调试会话
22 |
23 | 1. 在手持设备上，打开`Android Wear`配套应用。
24 | 2. 点击右上角的菜单，选择**设置**。
25 | 3. 开启**蓝牙调试**。我们将会在选项下面看到一个小的状态信息：
26 | ```xml
27 | Host: disconnected
28 | Target: connected
29 | ```
30 | 4. 通过USB连接手持设备到电脑上，并执行下面的命令：
31 | ```xml
32 | adb forward tcp:4444 localabstract:/adb-hub
33 | adb connect localhost:4444
34 | ```
35 | > **Note:** 我们可以使用任何可用的端口。
36 |
37 | 在`Android Wear`配套应用上，我们将会看到状态变为：
38 | ```xml
39 | Host: connected
40 | Target: connected
41 | ```
42 |
43 | ## 调试应用
44 |
45 | 当运行`abd devices`的命令时，我们的可穿戴设备应该表示为localhost:4444。执行任何的`adb`命令，需要使用下面的格式：
46 |
47 | ```xml
48 | adb -s localhost:4444
49 | ```
50 |
51 | 如果没有任何其他的设备通过TCP/IP连接到手持设备（即模拟器），我们可以使用下面的简短命令：
52 |
53 | ```xml
54 | adb -e
55 | ```
56 |
57 | 例如：
58 |
59 | ```xml
60 | adb -e logcat
61 | adb -e shell
62 | adb -e bugreport
63 | ```
64 |
--------------------------------------------------------------------------------
/connectivity/network-ops/index.md:
--------------------------------------------------------------------------------
1 | # 执行网络操作
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 这一章会介绍一些基本的网络操作，涉及到网络连接、监视网络连接（包括网络改变）和让用户控制 app 的网络用途。还会介绍如何解析与使用 XML 数据。
6 |
7 | 这节课包括一个示例应用，展示如何执行常见的网络操作。我们可以下载下面的的范例，并把它作为可重用代码在自己的应用中使用。
8 |
9 | [NetworkUsage.zip](http://developer.android.com/shareables/training/NetworkUsage.zip)
10 |
11 | 通过学习这章节的课程，我们将会学习到一些有关于如何创建一个使用最少的网络流量下载并解析数据的高效 app 的基础知识。
12 |
13 | 你还可以参考下面文章进阶学习:
14 |
15 | * [Optimizing Battery Life](performance/monitoring-device-state/index.html)
16 | * [Transferring Data Without Draining the Battery](connectivity/efficient-downloads/index.html)
17 | * [Web Apps Overview](http://developer.android.com/guide/webapps/index.html)
18 | * [Transmitting Network Data Using Volley](connectivity/volley/index.md)
19 |
20 | > **Node:** 查看[使用 Volley 传输网络数据](connectivity/volley/index.md)课程获取 Volley 的相关信息，它是一个能帮助 Android apps 更方便快捷地执行网络操作的 HTTP 库。Volly 可以在开源 [AOSP](https://android.googlesource.com/platform/frameworks/volley) 库中找到。Volly 可能会帮助我们简化网络操作，提高我们 app 的网络操作性能。
21 |
22 | ## Lessons
23 |
24 | [连接到网络 - Connecting to the Network](connecting.html)
25 |
26 | 学习如何连接到网络，选择一个 HTTP client，以及在 UI 线程外执行网络操作。
27 |
28 |
29 | [管理网络的使用情况 - Managing Network Usage](managing.html)
30 |
31 | 学习如何检查设备的网络连接情况，创建偏好界面来控制网络使用，以及响应连接变化。
32 |
33 |
34 | [解析 XML 数据 - Parsing XML Data](xml.html)
35 |
36 | 学习如何解析和使用 XML 数据。
37 |
--------------------------------------------------------------------------------
/best-ux.md:
--------------------------------------------------------------------------------
1 | # Android交互设计
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | These classes focus on the best Android user experience for your app. In some cases, the success of your app on Android is heavily affected by whether your app conforms to the user's expectations for UI and navigation on an Android device. Follow these recommendations to ensure that your app looks and behaves in a way that satisfies Android users.
6 |
7 | #### [Designing Effective Navigation](ux/design-nav/index.html)
8 |
9 | How to plan your app's screen hierarchy and forms of navigation so users can effectively and intuitively traverse your app content using various navigation patterns.
10 |
11 | #### [Implementing Effective Navigation](ux/implement-nav/index.html)
12 |
13 | How to implement various navigation patterns such as swipe views, a navigation drawer, and up navigation.
14 |
15 | #### [Notifying the User](ux/notify-user/index.html)
16 |
17 | How to display messages called notifications outside of your application's UI.
18 |
19 | #### [Adding Search Functionality](ux/search/index.html)
20 |
21 | How to properly add a search interface to your app and create a searchable database.
22 |
23 | ### [Making Your App Content Searchable by Google](ux/app-indexing/index.html)
24 |
25 | How to enable deep linking and indexing of your application content so that users can open this content directly from their mobile search results.
26 |
--------------------------------------------------------------------------------
/location/index.md:
--------------------------------------------------------------------------------
1 | # Android位置信息
2 |
3 | > 编写:[penkzhou](https://github.com/penkzhou) - 原文:
4 |
5 | 位置感知是移动应用一个独特的功能。用户去到哪里都会带着他们的移动设备，而将位置感知功能添加到我们的应用里，可以让用户有更加真实的情境体验。位置服务API集成在Google Play服务里面，这便于我们将自动位置跟踪、地理围栏和用户活动识别等位置感知功能添加到我们的应用当中。
6 |
7 | 我们喜欢用[Google Play services location APIs](http://developer.android.com/reference/com/google/android/gms/location/package-summary.html)胜过Android framework location APIs ([android.location](http://developer.android.com/reference/android/location/package-summary.html)) 来给我们的应用添加位置感知功能。如果你现在正在使用Android framework location APIs，我们强烈建议你尽可能切换到Google Play services location APIs。
8 |
9 | 这个课程介绍如何使用Google Play services location APIs来获取当前位置、周期性地更新位置以及查找地址。创建并监视地理围栏以及探测用户的活动。这个课程包括示例应用和代码片段，你可以利用这些资源作为添加位置感知到你的应用的基础。
10 |
11 | > **Note：**因为这个课程基于Google Play services client library，所以在使用这些示例应用和代码段之前确保你安装了最新版本的Google Play services client library。要想学习如何安装最新版的client library，请参考[安装Google Play services向导](http://developer.android.com/google/play-services/setup.html)。
12 |
13 | ## Lessons
14 |
15 | * [**获取最后可知位置**](retrieve-current.html)
16 |
17 | 学习如何获取Android设备的最后可知位置。通常Android设备的最后可知位置相当于用户的当前位置。
18 |
19 |
20 | * [**接收位置更新**](receive-location-updates.html)
21 |
22 | 学习如何请求和接收周期性的位置更新。
23 |
24 |
25 | * [**显示位置地址**](display-address.html)
26 |
27 | 学习如何将一个位置的经纬度转化成一个地址（反向地理编码）。
28 |
29 |
30 | * [**创建和监视地理围栏**](geofencing.html)
31 |
32 | 学习如何将一个或多个地理区域定义成一个兴趣位置集合，称为地理围栏。学习如何探测用户靠近或者进入地理围栏事件。
33 |
--------------------------------------------------------------------------------
/best-ui.md:
--------------------------------------------------------------------------------
1 | # Android界面设计
2 |
3 | These classes teach you how to build a user interface using Android layouts for all types of devices. Android provides a flexible framework for UI design that allows your app to display different layouts for different devices, create custom UI widgets, and even control aspects of the system UI outside your app's window.
4 |
5 | #### [Designing for Multiple Screens](ui/multiscreen/index.html)
6 |
7 | How to build a user interface that's flexible enough to fit perfectly on any screen and how to create different interaction patterns that are optimized for different screen sizes.
8 |
9 | #### [Creating Custom Views](ui/custom-view/index.html)
10 |
11 | How to build custom UI widgets that are interactive and smooth.
12 |
13 | #### [Creating Backward-Compatible UIs](ui/backward-compatible-ui/index.html)
14 |
15 | How to use UI components and other APIs from the more recent versions of Android while remaining compatible with older versions of the platform.
16 |
17 | #### [Implementing Accessibility](ui/accessibility/index.html)
18 |
19 | How to make your app accessible to users with vision impairment or other physical disabilities.
20 |
21 | #### [Managing the System UI](ui/system-ui/index.html)
22 |
23 | How to hide and show status and navigation bars across different versions of Android, while managing the display of other screen components.
24 |
25 | ### [Creating Apps with Material Design](../material/index.html)
26 |
27 | How to implement material design on Android.
28 |
--------------------------------------------------------------------------------
/ui/custom-view/index.md:
--------------------------------------------------------------------------------
1 | # 创建自定义View
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | Android的framework有大量的Views用来与用户进行交互并显示不同种类的数据。但是有时候你的程序有个特殊的需求，而Android内置的views组件并不能实现。这一章节会演示如何创建你自己的views，并使得它们是robust与reusable的。
6 |
7 | **依赖和要求**
8 |
9 | Android 2.1 (API level 7) 或更高
10 |
11 | **你也可以看**
12 |
13 | * [Custom Components](http://developer.android.com/guide/topics/ui/custom-components.html)
14 | * [Input Events](http://developer.android.com/guide/topics/ui/ui-events.html)
15 | * [Property Animation](http://developer.android.com/guide/topics/graphics/prop-animation.html)
16 | * [Hardware Acceleration](http://developer.android.com/guide/topics/graphics/hardware-accel.html)
17 | * [Accessibility](http://developer.android.com/guide/topics/ui/accessibility/index.html) developer guide
18 |
19 | ## Sample
20 |
21 | [CustomView.zip](http://developer.android.com/shareables/training/CustomView.zip)
22 |
23 |
24 |
25 | ##Lesson
26 |
27 | * [**创建一个View类**](create-view.md)
28 |
29 | 创建一个像内置的view，有自定义属性并支持[ADT](http://developer.android.com/sdk/eclipse-adt.html) layout编辑器。
30 |
31 | * [**自定义Drawing**](custom-draw.md)
32 |
33 | 使用Android graphics系统使你的view拥有独特的视觉效果。
34 |
35 | * [**使得View是可交互的**](make-interactive.md)
36 |
37 | 用户期望view对操作反应流畅自然。这节课会讨论如何使用gesture detection, physics, 和 animation使你的用户界面有专业的水准。
38 |
39 | * [**优化View**](optimize-view.md)
40 |
41 | 不管你的UI如何的漂亮，如果不能以高帧率流畅运行，用户也不会喜欢。学习如何避免一般的性能问题，和如何使用硬件加速来使你的自定义图像运行更流畅。
42 |
43 |
--------------------------------------------------------------------------------
/gitbook/print.css:
--------------------------------------------------------------------------------
1 | .link-inherit{color:inherit}.link-inherit:hover,.link-inherit:focus{color:inherit}.hljs-comment,.hljs-title{color:#8e908c}.hljs-variable,.hljs-attribute,.hljs-tag,.hljs-regexp,.ruby .hljs-constant,.xml .hljs-tag .hljs-title,.xml .hljs-pi,.xml .hljs-doctype,.html .hljs-doctype,.css .hljs-id,.css .hljs-class,.css .hljs-pseudo{color:#c82829}.hljs-number,.hljs-preprocessor,.hljs-pragma,.hljs-built_in,.hljs-literal,.hljs-params,.hljs-constant{color:#f5871f}.ruby .hljs-class .hljs-title,.css .hljs-rules .hljs-attribute{color:#eab700}.hljs-string,.hljs-value,.hljs-inheritance,.hljs-header,.ruby .hljs-symbol,.xml .hljs-cdata{color:#718c00}.css .hljs-hexcolor{color:#3e999f}.hljs-function,.python .hljs-decorator,.python .hljs-title,.ruby .hljs-function .hljs-title,.ruby .hljs-title .hljs-keyword,.perl .hljs-sub,.javascript .hljs-title,.coffeescript .hljs-title{color:#4271ae}.hljs-keyword,.javascript .hljs-function{color:#8959a8}.hljs{display:block;background:white;color:#4d4d4c;padding:.5em}.coffeescript .javascript,.javascript .xml,.tex .hljs-formula,.xml .javascript,.xml .vbscript,.xml .css,.xml .hljs-cdata{opacity:.5}.book-chapter{display:none}pre,blockquote{border:1px solid #999;page-break-inside:avoid;background:#f1f1f1;padding:8px}img{max-width:100%!important;page-break-inside:avoid;margin:0 auto}.exercise,.quiz{margin:1cm 0;padding:.4cm;page-break-inside:avoid;border:3px solid #ddd}.exercise .exercise-header,.quiz .exercise-header{margin-bottom:.4cm;padding-bottom:.2cm;border-bottom:1px solid #ddd}.exercise .question,.quiz .question{margin-top:.4cm}
--------------------------------------------------------------------------------
/performance/improving-layouts/loading-ondemand.md:
--------------------------------------------------------------------------------
1 | # 按需加载视图
2 |
3 | > 编写:[allenlsy](https://github.com/allenlsy) - 原文:
4 |
5 | 有时你的 Layout 会用到不怎么重用的复杂视图。不管它是列表项 细节，进度显示器，或是撤销时的提示信息，你可以仅在需要的时候载入它们，提高 UI 渲染速度。
6 |
7 | ## 定义 ViewStub
8 |
9 | [ViewStub](http://developer.android.com/reference/android/view/ViewStub.html) 是一个轻量的视图，不需要大小信息，也不会在被加入的 Layout 中绘制任何东西。每个 ViewStub 只需要设置 `android:layout` 属性来指定需要被 inflate 的 Layout 类型。
10 |
11 | 以下 ViewStub 是一个半透明的进度条覆盖层。功能上讲，它应该只在新的数据项被导入到应用程序时可见。
12 |
13 | ```xml
14 |
21 | ```
22 |
23 | ## 载入 ViewStub Layout
24 |
25 | 当你要载入用 ViewStub 声明的 Layout 时，要么用 `setVisibility(View.VISIBLE)` 设置它的可见性，要么调用其 `inflate()` 方法。
26 |
27 | ```java
28 | ((ViewStub) findViewById(R.id.stub_import)).setVisibility(View.VISIBLE);
29 | // or
30 | View importPanel = ((ViewStub) findViewById(R.id.stub_import)).inflate();
31 | ```
32 |
33 | > **Notes**：`inflate()` 方法会在渲染完成后返回被 inflate 的视图，所以如果你需要和这个 Layout 交互的话， 你不需要再调用 `findViewById()` 去查找这个元素，。
34 |
35 | 一旦 ViewStub 可见或是被 inflate 了，ViewStub 就不再继续存在View的层级机构中了。取而代之的是被 inflate 的 Layout，其 id 是 ViewStub 上的 `android:inflatedId` 属性。（ViewStub 的 `android:id` 属性仅在 ViewStub 可见以前可用）
36 |
37 | > **Notes**：ViewStub 的一个缺陷是，它目前不支持使用 `` 标签的 Layout 。
38 |
--------------------------------------------------------------------------------
/graphics/opengl/index.md:
--------------------------------------------------------------------------------
1 | # 使用OpenGL ES显示图像
2 |
3 | > 编写:[jdneo](https://github.com/jdneo) - 原文:
4 |
5 | Android framework 提供了大量的标准视图工具，用来创建吸引人的，功能丰富的图形界面。然而，如果我们希望应用能够对屏幕上所绘制的内容进行更多的控制，或者是希望绘制3D图像，那么我们就需要一个不同的工具了。由 Android framework 提供的 OpenGL ES 接口给予我们一组可以显示高级动画和图形的工具集，它能够完成超越我们想象力的复杂多变的图形绘制。同时，这些绘制操作在绝大多数的 Android 设备上，都能够利用设备自身装载的图形处理单元（GPU）为其提供更好的性能。
6 |
7 | 这系列课程将展示如何使用 OpenGL 构建应用的基础知识，包括配置启动，绘制对象，移动图形元素以及响应点击事件。
8 |
9 | 这系列课程所涉及的样例代码使用的是 OpenGL ES 2.0 接口，这是当前Android设备所推荐的接口版本。关于更多OpenGL ES的版本信息，可以阅读：[OpenGL开发手册](http://developer.android.com/guide/topics/graphics/opengl.html#choosing-version)。
10 |
11 | > **Note：**注意不要把OpenGL ES 1.x版本的接口和OpenGL ES 2.0的接口混合调用。这两种版本的接口不是通用的。如果尝试混用它们可能会让你感到无奈和沮丧。
12 |
13 | ## Sample Code
14 |
15 | [OpenGLES.zip](http://developer.android.com/shareables/training/OpenGLES.zip)
16 |
17 | ## Lessons
18 |
19 | * [**配置OpenGL ES的环境(Building an OpenGL ES Environment)**](environment.html)
20 |
21 | 学习如何配置一个可以绘制 OpenGL 图形的 Android 应用。
22 |
23 |
24 | * [**定义形状(Defining Shapes)**](shapes.html)
25 |
26 | 学习如何定义形状，以及为何需要了解面（Faces）和卷绕（Winding）这两个概念的原因。
27 |
28 |
29 | * [**绘制形状(Drawing Shapes)**](draw.html)
30 |
31 | 学习如何在应用中利用OpenGL绘制形状。
32 |
33 |
34 | * [**运用投影与相机视角(Applying Projection and Camera Views)**](projection.html)
35 |
36 | 学习如何通过投影和相机视角，获取图形对象的一个新的透视效果。
37 |
38 |
39 | * [**添加移动(Adding Motion)**](motion.html)
40 |
41 | 学习如何对一个OpenGL图形对象添加基本的运动效果。
42 |
43 |
44 | * [**响应触摸事件(Responding to Touch Events)**](touch.html)
45 |
46 | 学习如何与OpenGL图形进行基本的交互。
47 |
--------------------------------------------------------------------------------
/content-sharing/secure-file-sharing/index.md:
--------------------------------------------------------------------------------
1 | # 分享文件
2 |
3 | > 编写:[jdneo](https://github.com/jdneo) - 原文:
4 |
5 | 一个程序经常需要向其他程序提供一个甚至多个文件。例如，当我们用图片编辑器编辑图片时，被编辑的图片往往由图库应用程序所提供；再比如，文件管理器会允许用户在外部存储的不同区域之间复制粘贴文件。这里，我们提出一种让应用程序可以分享文件的方法：即令发送文件的应用程序对索取文件的应用程序所发出的文件请求进行响应。
6 |
7 | 在任何情况下，将文件从我们的应用程序发送至其它应用程序的唯一的安全方法是向接收文件的应用程序发送这个文件的content URI，并对该URI授予临时访问权限。具有URI临时访问权限的content URI是安全的，因为他们仅应用于接收这个URI的应用程序，并且会自动过期。Android的[FileProvider](http://developer.android.com/reference/android/support/v4/content/FileProvider.html)组件提供了getUriForFile()方法创建一个文件的content URI。
8 |
9 | 如果希望在应用之间共享少量的文本或者数字等类型的数据，应使用包含该数据的Intent。要学习如何通过Intent发送简单数据，可以阅读：[Sharing Simple Data](../sharing/index.html)。
10 |
11 | 本课主要介绍了如何使用Android的[FileProvider](http://developer.android.com/reference/android/support/v4/content/FileProvider.html)组件所创建的content URI在应用之间安全的共享文件。当然，要做到这一点，还需要给接收文件的应用程序访问的这些content URI授予临时访问权限。
12 |
13 | ## Lessons
14 |
15 | * [**建立文件分享**](setup-sharing.html)
16 |
17 | 学习如何配置应用程序使得它们可以分享文件。
18 |
19 |
20 | * [**分享文件**](sharing-file.html)
21 |
22 | 学习分享文件的三个步骤：
23 | - 生成文件的content URI；
24 | - 授予URI的临时访问权限；
25 | - 将URI发送给接收文件的应用程序。
26 |
27 |
28 | * [**请求分享一个文件**](request-file.html)
29 |
30 | 学习如何向其他应用程序请求文件，如何接收该文件的content URI，以及如何使用content URI打开该文件。
31 |
32 |
33 | * [**获取文件信息**](retrieve-info.html)
34 |
35 | 学习应用程序如何通过FileProvider提供的content URI获取文件的信息：例如MIME类型，文件大小等。
36 |
--------------------------------------------------------------------------------
/ui/system-ui/dim.md:
--------------------------------------------------------------------------------
1 | # 淡化系统Bar
2 |
3 | > 编写:[K0ST](https://github.com/K0ST) - 原文:
4 |
5 | 本课程将向你讲解如何在Android 4.0(*API level 14*)与更高的的系统版本上淡化系统栏(System bar,状态栏与导航栏)。早期版本的Android没有提供一个自带的方法来淡化系统栏。
6 |
7 | 当你使用这个方法的时候，内容区域并不会发生大小的变化，只是系统栏的图标会收起来。一旦用户触摸状态栏或者是导航栏的时候，这两个系统栏就又都会完全显示（无透明度）。这种方法的优势是系统栏仍然可见，但是它们的细节被隐藏掉了，因此可以在不牺牲快捷访问系统栏的情况下创建一个沉浸式的体验。
8 |
9 | **这节课将教您**
10 |
11 | 1. 淡化状态栏和导航栏
12 | 2. 显示状态栏和导航栏
13 |
14 | **同时您应该阅读**
15 |
16 | * [Action Bar API 指南](http://developer.android.com/guide/topics/ui/actionbar.html)
17 | * [Android Design Guide](http://developer.android.com/design/index.html)
18 |
19 | ## 淡化状态栏和系统栏
20 |
21 | 如果要淡化状态和通知栏，在版本为4.0以上的Android系统上，你可以像如下使用`SYSTEM_UI_FLAG_LOW_PROFILE`这个标签。
22 |
23 | ```java
24 | // This example uses decor view, but you can use any visible view.
25 | View decorView = getActivity().getWindow().getDecorView();
26 | int uiOptions = View.SYSTEM_UI_FLAG_LOW_PROFILE;
27 | decorView.setSystemUiVisibility(uiOptions);
28 | ```
29 |
30 | 一旦用户触摸到了状态栏或者是系统栏，这个标签就会被清除，使系统栏重新显现（无透明度）。在标签被清除的情况下，如果你想重新淡化系统栏就必须重新设定这个标签。
31 |
32 | 图1展示了一个图库中的图片，界面的系统栏都已被淡化（需要注意的是图库应用完全隐藏状态栏，而不是淡化它）；注意导航栏（图片的右侧）上变暗的白色的小点，他们代表了被隐藏的导航操作。
33 |
34 | 
35 |
36 | **图1.**淡化的系统栏
37 |
38 | 图2展示的是同一张图片，系统栏处于显示的状态。
39 |
40 | 
41 |
42 | **图2.**显示的系统栏
43 |
44 | ## 显示状态栏与导航栏
45 |
46 | 如果你想动态的清除显示标签，你可以使用`setSystemUiVisibility()`方法：
47 |
48 | ```java
49 | View decorView = getActivity().getWindow().getDecorView();
50 | // Calling setSystemUiVisibility() with a value of 0 clears
51 | // all flags.
52 | decorView.setSystemUiVisibility(0);
53 | ```
54 |
--------------------------------------------------------------------------------
/wearables/ui/index.md:
--------------------------------------------------------------------------------
1 | # 为可穿戴设备创建自定义UI
2 |
3 | > 编写: [roya](https://github.com/RoyaAoki) 原文:
4 |
5 | 可穿戴apps的用户界面明显的不同于手持设备。可穿戴设备应用应该参考Android Wear[设计规范](https://developer.android.com/design/wear/index.html)和实现推荐的[UI模式](https://developer.android.com/design/wear/patterns.html)，
6 | 这些保证在为可穿戴设备优化过的应用中保持统一的用户体验。
7 |
8 | 这个课程将教我们如何为[可穿戴应用](http://hukai.me/android-training-course-in-chinese/wearables/apps/creating.html)创建在所有Android可穿戴设备上看上去都不错的自定义UI和[自定义的notifications](http://hukai.me/android-training-course-in-chinese/wearables/apps/layouts.html#CustomNotifications)。为了达到上述目的，需要实现这些UI模式：
9 |
10 | * Card
11 | * 倒计时和确认
12 | * 长按退出
13 | * 2D Picker
14 | * 多选List
15 |
16 | 可穿戴UI库是Android SDK的Google Repository中的一部分，其中提供的类可以帮助我们实现这些模式和创建工作在圆形和方形Android可穿戴设备的layout。
17 |
18 | >**Note:** 我们推荐使用Android Studio做Android Wear开发,它提供工程初始配置,库包含和方便的打包,这些在ADT中是没有的。这系列教程假定你正在使用Android Studio。
19 |
20 | ## Lessons
21 |
22 | [定义Layouts](https://developer.android.com/training/wearables/ui/layouts.html)
23 |
24 | 学习如何创建在圆形和方形Android Wear设备上看起来不错的layout。
25 |
26 | [创建Card](https://developer.android.com/training/wearables/ui/cards.html)
27 |
28 | 学习如何创建自定义layout的Card
29 |
30 | [创建List](https://developer.android.com/training/wearables/ui/lists.html)
31 |
32 | 学习如何创建为可穿戴设备优化的List
33 |
34 | [创建2D Picker](https://developer.android.com/training/wearables/ui/2d-picker.html)
35 |
36 | 学习如何实现2D Picker UI模式以导航各页数据
37 |
38 | [显示确认界面](https://developer.android.com/training/wearables/ui/confirm.html)
39 |
40 | 学习如何在用户完成操作时显示确认动画
41 |
42 | [退出全屏的Activity](https://developer.android.com/training/wearables/ui/exit.html)
43 |
44 | 学习如何实现长按退出UI模式以退出全屏activities
--------------------------------------------------------------------------------
/ux/design-nav/screen-planning.md:
--------------------------------------------------------------------------------
1 | # 规划界面和他们之间的关系
2 |
3 | > 编写:[XizhiXu](https://github.com/XizhiXu) - 原文:
4 |
5 | 多数 App 都有一种内在的信息模型，它能被表示成一个用对象类型构成的树或图。更浅显的说，你可以画一个有不同类型信息的图，这些信息代表用户在你 App 里用户与之互动的各种东西。软件工程师和数据架构师经常使用实例-关系图（Entity-Relationship Diagram，ERD）描述一个应用的信息模型。
6 |
7 | 让我们考虑一个让用户浏览一群已分类好的新闻事件和图片的应用例子。这种 App 一个可能的模型如下 ERD 图。
8 |
9 | 
10 |
11 | **Figure 1.** 新闻应用例子的实例关系图
12 |
13 | ## 创建一个界面列表
14 |
15 | 一旦你定义了信息模型，你就可以开始定义那些能使用户在你的 App 中有效地发掘，查看和操作数据的上下文环境了。实际上，其中一种方法就是确定供用户导航和交互数据所需的 *界面完备集*（归纳了所有界面的集合）。但我们实际发现的界面集合应该根据目标设备变化。在设计过程中早点考虑到这点很重要，这样可以保证程序可以适应运行环境。
16 |
17 | 在我们的例子中，我们想让用户**查看**，**保存**和**分享**分类好了的**新闻**和**图片**。下面是涵盖了这些用例的界面完备列表。
18 |
19 | * 用来访问新闻和图片的 Home 或者 "Launchpad" 画面
20 | * 类别列表
21 | * 某个分类下的新闻列表
22 | * 新闻详情 View （在这里我们可以保存和分享）
23 | * 图片列表，不分类
24 | * 图片详情 View （在这里我们可以保存和分享）
25 | * 所有保存项列表
26 | * 图片保存列表
27 | * 新闻保存列表
28 |
29 | ## 图示界面关系
30 |
31 | 现在我们可以定义界面间的有向关系了。一个从界面 *A* 指向另一个界面 *B* 的箭头表示通过用户在画面 *A* 的某个交互动作可直达画面 *B* 。一旦我们定义了界面集和他们之间的关系，我们可以将他们一起全部表示在一张界面图中了：
32 |
33 | 
34 |
35 | **Figure 2.** 新闻应用例子的界面完备Map
36 |
37 | 如果之后我们想允许用户提交新闻事件或者上传图片，我们可以在图中加额外的界面。
38 |
39 | ## 脱离简陋设计
40 |
41 | 这时，我们可以据这张完备的界面图设计一个功能完备应用了。可以由列表和导向子界面的按钮构成一个简单的UI：
42 |
43 | * 导向不同页面的按钮（例如，新闻，图片，保存的项目）
44 | * 纵向列表表示集合（例如，新闻列表，图片列表，等等）
45 | * 详细信息（例如，新闻 View ，图片 View ，等等）
46 |
47 | 但是，你可以利用屏幕组合技术和更高深导航元素以一种更直观，设备更理解的方式呈现内容。下节课，我们探索屏幕组合技术，比如为平板而生的多视窗（Multi-pane）布局。之后，我将深入讲解更多不同的 Android 常见导航模式。
48 |
49 | [下节课：规划多种触屏大小](multi-sizes.html)
50 |
--------------------------------------------------------------------------------
/enterprise/index.md:
--------------------------------------------------------------------------------
1 | # 创建企业级应用
2 |
3 | > 编写:[craftsmanBai](https://github.com/craftsmanBai) - - 原文:
4 |
5 | 
6 |
7 | Android框架提供安全支持、数据分离、企业环境管理的功能。作为应用开发者，通过适当地处理企业安全和功能限制，你可以让你的应用程序吸引更多的企业客户。也可以修改你的应用使技术管理员可远程配置使用企业资源。
8 |
9 | 为了帮助企业将安卓设备和应用程序进入工作场所，Google通过Android for Work为设备的分配和管理提供了一套API和服务。通过这项计划，企业可以连接到企业移动性管理（EMM）供应商，将Android整合到工作中。
10 |
11 | 通过下面的链接获取，可以了解更多关于如何更新您的Android应用程序来支持企业环境或建立企业解决方案的信息。
12 |
13 |
14 | ## 企业级应用开发
15 |
16 | 了解在企业环境中如何使您的应用程序运行顺畅，限制设备的功能和数据访问。通过加入限制进一步支持企业使用你的app，让管理员可以远程配置使用你的应用程序：
17 |
18 | 确保与管理兼容：
19 |
20 | [http://developer.android.com/training/enterprise/app-compatibility.html](http://developer.android.com/training/enterprise/app-compatibility.html
21 | )
22 |
23 | 加入应用限制：
24 |
25 | [http://developer.android.com/training/enterprise/app-restrictions.html](http://developer.android.com/training/enterprise/app-restrictions.html)
26 |
27 | 应用限制计划：
28 |
29 | [http://developer.android.com/samples/AppRestrictionSchema/index.html](http://developer.android.com/samples/AppRestrictionSchema/index.html)
30 |
31 |
32 | 应用限制执行者：
33 |
34 |
35 | [http://developer.android.com/samples/AppRestrictionEnforcer/index.html](http://developer.android.com/samples/AppRestrictionEnforcer/index.html)
36 |
37 | ## 设备与应用管理
38 |
39 | 学习如何为应用程序建立策略控制器，使企业的技术管理人员来管理设备，管理企业应用程序，并提供访问公司资源的权限：
40 |
41 | 建立工作策略控制：
42 |
43 | [http://developer.android.com/training/enterprise/work-policy-ctrl.html](http://developer.android.com/training/enterprise/work-policy-ctrl.html)
44 |
45 | 基本管理模型：
46 |
47 | [http://developer.android.com/samples/BasicManagedProfile/index.html](http://developer.android.com/samples/BasicManagedProfile/index.html)
48 |
--------------------------------------------------------------------------------
/testing/activity-testing/prepare-activity-testing.md:
--------------------------------------------------------------------------------
1 | # 建立测试环境
2 |
3 | > 编写:[huanglizhuo](https://github.com/huanglizhuo) - 原文:
4 |
5 | 在开始编写并运行我们的测试之前，我们应该建立测试开发环境。本小节将会讲解如何建立Eclipse IDE来构建和运行我们的测试，以及怎样用Gradle构建工具在命令行下构建和运行我们的测试。
6 |
7 | > 注意: 本小节基于的是Eclipse及ADT插件。然而，你在自己测试开发时可以自由选用IDE或命令行。
8 |
9 | ## 用Eclipse建立测试
10 |
11 | 安装了Android Developer Tools (ADT) 插件的Eclipse将为我们创建，构建，以及运行Android程序提供一个基于图形界面的集成开发环境。Eclipse可以自动为我们的Android应用项目创建一个对应的测试项目。
12 |
13 | 开始在Eclipse中创建测试环境:
14 |
15 | 1. 如果还没安装Eclipse [ADT](http://developer.android.com/sdk/installing/bundle.html)插件，请先下载安装。
16 | 2. 导入或创建我们想要测试的Android应用项目。
17 | 3. 生成一个对应于应用程序项目测试的测试项目。为导入项目生成一个测试项目:
18 | a.在项目浏览器里，右击我们的应用项目，然后选择**Android Tools > New Test Project**
19 | b.在新建Android测试项目面板，为我们的测试项目设置合适的参数，然后点击**Finish**
20 |
21 | 现在应该可以在Eclipse环境中创建，构建和运行测试项目了。想要继续学习如何在Eclipse中进行这些任务，可以阅读[创建与执行测试用例](activity-basic-testing.html)
22 |
23 | ## 用命令行建立测试
24 |
25 | 如果正在使用Gradle version 1.6或者更高的版本作为构建工具，可以用Gradle Wrapper创建。构建和运行Android应用测试。确保在`gradle.build`文件中，`defaultConfig`部分中的[minSdkVersion](http://developer.android.com/guide/topics/manifest/uses-sdk-element.html)属性是8或更高。可以参考包含在下载包中的示例文件gradle.build
26 |
27 | ## 用Gradle Wrapper运行测试:
28 |
29 | 1. 连接Android真机或开启Android模拟器。
30 | 2. 在项目目录运行如下命令:
31 |
32 | >./gradlew build connectedCheck
33 |
34 | 进一步学习Gradle关于Android测试的内容，参看[Gradle Plugin User Guide](http://www.gradle.org/docs/current/userguide/userguide_single.html)。
35 |
36 | 进一步学习使用Gradle及其它命令行工具，参看[Testing from Other IDEs.](http://developer.android.com/tools/testing/testing_otheride.html)。
37 |
38 | 本节示例代码[AndroidTestingFun.zip](http://developer.android.com/shareables/training/AndroidTestingFun.zip)
39 |
--------------------------------------------------------------------------------
/animations/layout.md:
--------------------------------------------------------------------------------
1 | # 布局变更动画
2 |
3 | > 编写:[XizhiXu](https://github.com/XizhiXu) - 原文:
4 |
5 | 布局动画是一种预加载动画，系统在每次改变布局配置时运行它。我们需要做的仅是在布局文件里设置属性告诉Android系统为这些布局的变更应用动画，然后系统的默认动画便会执行。
6 |
7 | > **小贴士:** 如果你想补充自定义布局动画，创建 [`LayoutTransition`](http://developer.android.com/reference/android/animation/LayoutTransition.html) 对象，然后用 `setLayoutTransition()` 方法把它加到布局中。
8 |
9 | 下面的例子在一个list中添加一项的默认布局动画：
10 |
11 |
14 |
15 |
20 |
21 |
22 |
23 | 如果你想直接查看整个例子，[下载](http://developer.android.com/shareables/training/Animations.zip) App 样例并运行然后选择布局渐变的例子。查看下列文件中的代码实现：
24 |
25 | * `src/LayoutChangesActivity.java`
26 | * `layout/activity_layout_changes.xml`
27 | * `menu/activity_layout_changes.xml`
28 |
29 | ## 创建布局
30 |
31 | 在Activity的XML布局文件中，为想开启动画的布局设置`android:animateLayoutChanges`属性为`true`。例如：
32 |
33 | ```xml
34 |
38 | ```
39 |
40 | ## 从布局中添加，更新或删除项目
41 |
42 | 现在，我们需要做的就是添加，删除或更新布局里的项目，然后这些项目就会自动显示动画：
43 |
44 | ```java
45 | private ViewGroup mContainerView;
46 | ...
47 | private void addItem() {
48 | View newView;
49 | ...
50 | mContainerView.addView(newView, 0);
51 | }
52 | ```
53 |
--------------------------------------------------------------------------------
/ui/multiscreen/screen-desities.md:
--------------------------------------------------------------------------------
1 | # 兼容不同的屏幕密度
2 |
3 | > 编写:[riverfeng](https://github.com/riverfeng) - 原文:
4 |
5 | 这节课将教你如何通过提供不同的资源和使用独立分辨率（dp）来支持不同的屏幕密度。
6 |
7 | ## 使用密度独立像素（dp）
8 |
9 | 设计布局时，要避免使用绝对像素（absolutepixels）定义距离和尺寸。使用像素单位来定义布局大小是有问题的。因为，不同的屏幕有不同的像素密度，所以，同样单位的像素在不同的设备上会有不同的物理尺寸。因此，在指定单位的时候，通常使用dp或者sp。一个dp代表一个密度独立像素，也就相当于在160 dpi的一个像素的物理尺寸，sp也是一个基本的单位，不过它主要是用在文本尺寸上（它也是一种尺寸规格独立的像素），所以，你在定义文本尺寸的时候应该使用这种规格单位（不要使用在布尺寸上）。
10 |
11 | 例如，当你是定义两个view之间的空间时，应该使用dp而不是px：
12 | ```xml
13 |
17 | ```
18 | 当指定文本尺寸时，始终应该使用sp：
19 | ```xml
20 |
23 | ```
24 |
25 | ## 提供可供选择的图片
26 |
27 | 因为Android能运行在很多不同屏幕密度的设备上，所以，你应该针对不同的设备密度提供不同的bitmap资源：小屏幕（low），medium（中），high（高）以及超高（extra-high）密度。这将能帮助你在所有的屏幕密度中得到非常好的图形质量和性能。
28 |
29 | 为了提供更好的用户体验，你应该使用以下几种规格来缩放图片大小，为不同的屏幕密度提供相应的位图资源：
30 | ```xml
31 | xhdpi:2.0
32 | hdpi:1.5
33 | mdpi:1.0(标准线)
34 | ldpi:0.75
35 | ```
36 |
37 | 这也就意味着如果在xhdpi设备上你需要一个200x200的图片，那么你则需要一张150x150的图片用于hdpi，100x100的用于mdpi以及75x75的用户ldpi设备。
38 |
39 | 然后将这些图片资源放到res/对应的目录下面，系统会自动根据当前设备屏幕密度自动去选择合适的资源进行加载：
40 | ```xml
41 | MyProject/
42 | res/
43 | drawable-xhdpi/
44 | awesomeimage.png
45 | drawable-hdpi/
46 | awesomeimage.png
47 | drawable-mdpi/
48 | awesomeimage.png
49 | drawable-ldpi/
50 | awesomeimage.png
51 | ```
52 | 这样放置图片资源后，不论你什么时候使用@drawable/awesomeimage，系统都会给予屏幕的dp来选择合适的图片。
53 |
54 | 如果你想知道更多关于如何为你的应用程序创建icon资源，你可以看看Icon设计指南[Icon Design Guidelines](http://developer.android.com/guide/practices/ui_guidelines/icon_design.html).
55 |
--------------------------------------------------------------------------------
/tv/discovery/index.md:
--------------------------------------------------------------------------------
1 |
2 | # 帮助用户在TV上找到内容
3 |
4 | > 编写:[awong1900](https://github.com/awong1900) - 原文:http://developer.android.com/training/tv/discovery/index.html
5 |
6 |
7 |
8 | TV设备为用户提供了许多的休闲娱乐选择。它们提供上千个应用和相关的内容服务。同时，大部分用户操作TV时，喜欢比较少的输入操作。面对用户可能的选择，重要的一点是应用开发者为用户提供快速容易的路径，发现和享受我们的内容。
9 |
10 |
11 |
12 | Android framework层帮助我们为用户提供若干路径，去找到内容，包括主屏幕的推荐和应用的内容目录的搜索。
13 |
14 |
15 | 这节课展示如何帮助用户找到应用内容，通过推荐和应用内搜索。
16 |
17 |
18 | ## 主题
19 |
20 |
30 |
31 | - [推荐TV内容](recommendations.html)
32 | 学习如何推荐内容给用户，使它出现在TV设备的主屏幕推荐栏。
33 |
34 | - [使TV应用是可被搜索的](searchable.html)
35 | 学习如何使内容在Android TV主屏幕中被搜索到。
36 |
37 | - [TV应用内搜索](in-app-search.html)
38 | 学习如何在应用内使用内置的TV搜索界面。
39 |
40 | -------------
41 | [推荐TV内容 >](recommendations.html)
42 |
--------------------------------------------------------------------------------
/ui/system-ui/hide-nav.md:
--------------------------------------------------------------------------------
1 | # 隐藏导航栏
2 |
3 | > 编写:[K0ST](https://github.com/K0ST) - 原文:
4 |
5 | **这节课将教您**
6 |
7 | 1. 在4.0及以上版本中隐藏导航栏
8 | 2. 让内容显示在导航栏之后
9 |
10 | 本节课程将教您如何对导航栏进行隐藏，这个特性是Android 4.0（）版本中引入的。
11 |
12 | 即便本小节仅关注如何隐藏导航栏，但是在实际的开发中，你最好让状态栏与导航栏同时消失。在保证导航栏易于再次访问的情况下，隐藏导航栏与状态栏使内容区域占据了整个显示空间，因此可以提供一个更加沉浸式的用户体验。
13 |
14 | 
15 |
16 | **图1**. 导航栏.
17 |
18 | ## 在4.0及以上版本中隐藏导航栏
19 |
20 | 你可以在Android 4.0以及以上版本，使用`SYSTEM_UI_FLAG_HIDE_NAVIGATION`标志来隐藏导航栏。这段代码同时隐藏了导航栏和系统栏：
21 |
22 |
23 | ```java
24 | View decorView = getWindow().getDecorView();
25 | // Hide both the navigation bar and the status bar.
26 | // SYSTEM_UI_FLAG_FULLSCREEN is only available on Android 4.1 and higher, but as
27 | // a general rule, you should design your app to hide the status bar whenever you
28 | // hide the navigation bar.
29 | int uiOptions = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
30 | | View.SYSTEM_UI_FLAG_FULLSCREEN;
31 | decorView.setSystemUiVisibility(uiOptions);
32 | ```
33 |
34 | 注意以下几点
35 | * 使用这个方法时，触摸屏幕的任何一个区域都会使导航栏（与状态栏）重新显示。用户的交互会使这个标签`SYSTEM_UI_FLAG_HIDE_NAVIGATION`被清除。
36 | * 一旦这个标签被清除了，如果你想再次隐藏导航栏，你就需要重新对这个标签进行设定。在下一节[响应UI可见性的变化](visibility.html)中，将详细讲解应用监听系统UI变化来做出相应的调整操作。
37 | * 在不同的地方设置UI标签是有所区别的。如果你在Activity的onCreate()方法中隐藏系统栏，当用户按下home键系统栏就会重新显示。当用户再重新打开activity的时候，onCreate()不会被调用，所以系统栏还会保持可见。如果你想让在不同Activity之间切换时，系统UI保持不变，你需要在onReasume()与onWindowFocusChaned()里设定UI标签。
38 | * setSystemUiVisibility()仅仅在被调用的View显示的时候才会生效。
39 | * 当从View导航到别的地方时，用setSystemUiVisibility()设置的标签会被清除。
40 |
41 |
42 | ## 2)让内容显示在导航栏之后
43 |
44 | 在Android 4.1与更高的版本中，你可以让应用的内容显示在导航栏的后面，这样当导航栏展示或隐藏的时候内容区域就不会发生布局大小的变化。可以使用`SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION`标签来做到这个效果。同时，你也有可能需要`SYSTEM_UI_FLAG_LAYOUT_STABLE`这个标签来帮助你的应用维持一个稳定的布局。
45 |
46 | 当你使用这种方法的时候，就需要你来确保应用中特定区域不会被系统栏掩盖。更详细的信息可以浏览[隐藏状态栏](hide-ui.html)一节。
47 |
48 |
49 |
--------------------------------------------------------------------------------
/wearables/watch-faces/designing.md:
--------------------------------------------------------------------------------
1 | # 设计表盘
2 |
3 | > 编写:[heray1990](https://github.com/heray1990) - 原文:
4 |
5 | 类似于设计传统的表盘，创建 Android Wear 的表盘是一个清晰地显示时间的练习。Android Wear 设备为表盘提供了高级的功能，我们可以运用这些功能到我们的设计当中，例如鲜艳的色彩、动态的背景、动画和数据整合。然而，我们必须考虑到很多其它设计上的因素。
6 |
7 | 这节课总结了设计表盘需要考虑的因素和通用准则。更多关于这方面的内容，请见 [Watch Faces for Android Wear](http://developer.android.com/design/wear/watchfaces.html) 设计指引。
8 |
9 | ## 遵守设计准侧
10 |
11 | 当我们设计表盘的外观和表盘需要向用户表达哪些类型的信息的时候，请考虑一下这些设计准侧：
12 |
13 | *为方形和圆形的设备作出规划*
14 |
15 | 我们的设计应该可以运行在方形和圆形的 Android Wear 设备上，包括那些[使用感知形状的 Layout](http://hukai.me/android-training-course-in-chinese/wearables/ui/layouts.html#same-layout) 的设备。
16 |
17 | *支持所有的显示模式*
18 |
19 | 我们的表盘应该支持有限颜色的环境模式（ambient mode）和全彩色动画的交互模式（interactive mode）。
20 |
21 | *优化特殊屏幕的技术*
22 |
23 | 在环境模式下，表盘应该让大部分像素保持黑色。根据屏幕技术，我们需要避免使用大块的白像素，仅仅使用黑色和白色，并禁用反锯齿。
24 |
25 | *容纳系统 UI 组件*
26 |
27 | 我们的设计应该确保系统指示图标可见，当 notification cards 出现在屏幕上的时候用户还可以看到时间。
28 |
29 | *整合数据*
30 |
31 | 我们的表盘可以利用配套手机设备上的传感器和蜂窝数据连接，来显示相关的上下文数据，例如天气或者用户的下一个日程表事件。
32 |
33 | *提供设置选项*
34 |
35 | 我们可以让用户配置可穿戴应用或者 Android Wear 配套应用上某些设计特征（如颜色和尺寸）。
36 |
37 | 
38 |
39 | **Figure 1.** 表盘的例子.
40 |
41 | 更多关于 Android Wear 表盘的设计，请见 [Watch Faces for Android Wear](http://developer.android.com/design/wear/watchfaces.html) 设计指引。
42 |
43 |
44 |
45 | ## 创建实现策略
46 |
47 | 完成表盘的设计后，我们需要决定如何获得必要的数据和将表盘绘制到可穿戴设备上。大部分实现方案由如下部分组成：
48 |
49 | * 一幅或多幅背景图片
50 | * 接收需要数据的应用代码
51 | * 绘制背景图片上的文本和形状的应用代码
52 |
53 | 我们一般在交互模式和环境模式使用两幅不同的背景图片。环境模式下的背景一般是全黑的。Android Wear 设备的屏幕密度（hdpi）应该是 320 x 320 像素，这样可以同时兼容方形和圆形设备。背景图片的四角在圆形设备上是不可见的。在我们的代码中，我们可以检测到设备屏幕的尺寸。如果设备的分辨率比图片的低，那么按比例缩小背景图片。为了提高性能，我们应该只对背景图片缩放一次并保存缩放后的 bitmap。
54 |
55 | 我们应该在需要时运行代码来检索上下文数据和保存结果，使得在每次绘制表盘的时候重用数据。例如，我们不需要每隔一分钟去刷新一次天气。
56 |
57 | 为了增加电池使用时间，在环境模式绘制表盘的应用代码应该相对简单。在环境模式下，我们通常用一组有限的颜色来绘制形状的轮廓。在交互模式下，我们可以使用全色彩、复杂的形状、渐变和动画来绘制表盘。
58 |
59 | 后面的课程将会介绍如何详细地实现表盘。
--------------------------------------------------------------------------------
/performance/monitor-device-state/connectivity-monitor.md:
--------------------------------------------------------------------------------
1 | # 判断并监测网络连接状态
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 重复闹钟和后台服务最常见的功能之一，是用来从网络上获取应用更新，存储数据或者执行大文件的下载。但是如果没有获得网络连接，或者连接的速度太慢以至于下载无法完成，那么就没有必要唤醒设备并执行那些更新等操作了。
6 |
7 | 我们可以使用[ConnectivityManager](http://developer.android.com/reference/android/net/ConnectivityManager.html)来检查设备是否连接到网络，以及网络的类型（译注：通过网络的连接状况改变，相应的改变app的行为，减少无谓的操作，从而延长设备的续航能力）。
8 |
9 | ## 判断当前是否有网络连接
10 | 如果没有网络连接，那么就没有必要做那些需要联网的事情。下面的代码片段展示了如何通过[ConnectivityManager](http://developer.android.com/reference/android/net/ConnectivityManager.html)检查当前活动的网络类型，并确定它是否可以连接到互联网：
11 |
12 | ```java
13 | ConnectivityManager cm =
14 | (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
15 |
16 | NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
17 | boolean isConnected = activeNetwork != null &&
18 | activeNetwork.isConnectedOrConnecting();
19 | ```
20 |
21 | ## 判断连接网络的类型
22 |
23 | 我们还可以获取到当前的网络连接类型。
24 |
25 | 设备通常可以有移动网络，WiMax，Wi-Fi与以太网连接等类型。通过查询当前活动的网络类型，可以根据网络的带宽对更新频率进行调整：
26 |
27 | ```java
28 | boolean isWiFi = activeNetwork.getType() == ConnectivityManager.TYPE_WIFI;
29 | ```
30 |
31 | 移动网络的使用费会比Wi-Fi更高，所以多数情况下，如果设备正在使用移动网络，我们应该减少应用的更新频率；同样地，还应该临时地挂起一些文件下载任务直到有Wi-Fi连接时再继续下载。
32 |
33 | 如果已经关闭了更新操作，那么需要监听网络连接的变化，这样就可以在建立了互联网访问之后，重新恢复它们。
34 |
35 | ## 监听网络连接的变化
36 |
37 | 当网络连接发生改变时，[ConnectivityManager](http://developer.android.com/reference/android/net/ConnectivityManager.html)会广播[CONNECTIVITY_ACTION](http://developer.android.com/reference/android/net/ConnectivityManager.html#CONNECTIVITY_ACTION)（`android.net.conn.CONNECTIVITY_CHANGE`）的Action消息。
38 | 我们可以在Manifest文件里面注册一个BroadcastReceiver，来监听这些变化，并适当地恢复（或挂起）你的后台更新:
39 |
40 | ```xml
41 |
42 | ```
43 |
44 | 设备的网络变化可能会比较频繁，因此每当你在移动网络与Wi-Fi之间切换的时候，这一广播就会被触发。因此，我们可以仅在之前的更新或者下载任务被挂起的时候去监听这一广播（用来恢复那些任务）。通常我们可以在开始更新前检查一下网络连接，如果当前没有连接到互联网，那么就将更新任务挂起，直到连接恢复。
45 |
46 | 上述方法会涉及到Broadcast Receiver开启状态的切换，这一内容会在下一节课中展开。
47 |
--------------------------------------------------------------------------------
/background-jobs/run-background-service/create-service.md:
--------------------------------------------------------------------------------
1 | # 创建后台服务
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | IntentService为在单一后台线程中执行任务提供了一种直接的实现方式。它可以处理一个耗时的任务并确保不影响到UI的响应性。另外IntentService的执行还不受UI生命周期的影响，以此来确保AsyncTask能够顺利运行。
6 |
7 | 但是IntentService有下面几个局限性：
8 |
9 | * 不可以直接和UI做交互。为了把他执行的结果体现在UI上，需要把结果返回给Activity。
10 | * 工作任务队列是顺序执行的，如果一个任务正在IntentService中执行，此时你再发送一个新的任务请求，这个新的任务会一直等待直到前面一个任务执行完毕才开始执行。
11 | * 正在执行的任务无法打断。
12 |
13 | 虽然有上面那些限制，然而在在大多数情况下，IntentService都是执行简单后台任务操作的理想选择。
14 |
15 | 这节课会演示如何创建继承的IntentService。同样也会演示如何创建必须的回调方法`onHandleIntent()`。最后，还会解释如何在manifest文件中定义这个IntentService。
16 |
17 |
18 |
19 | ## 1)创建IntentService
20 |
21 | 为你的app创建一个IntentService组件，需要自定义一个新的类，它继承自IntentService，并重写onHandleIntent()方法，如下所示：
22 |
23 | ```java
24 | public class RSSPullService extends IntentService {
25 | @Override
26 | protected void onHandleIntent(Intent workIntent) {
27 | // Gets data from the incoming Intent
28 | String dataString = workIntent.getDataString();
29 | ...
30 | // Do work here, based on the contents of dataString
31 | ...
32 | }
33 | }
34 | ```
35 |
36 | 注意一个普通Service组件的其他回调，例如`onStartCommand()`会被IntentService自动调用。在IntentService中，要避免重写那些回调。
37 |
38 | ## 2)在Manifest文件中定义IntentService
39 |
40 | IntentService需要在manifest文件添加相应的条目，将此条目``作为``元素的子元素下进行定义，如下所示：
41 |
42 | ```xml
43 |
46 | ...
47 |
51 |
54 | ...
55 |
56 | ```
57 |
58 | `android:name`属性指明了IntentService的名字。
59 |
60 | 注意``标签并没有包含任何intent filter。因为发送任务给IntentService的Activity需要使用显式Intent，所以不需要filter。这也意味着只有在同一个app或者其他使用同一个UserID的组件才能够访问到这个Service。
61 |
62 | 至此，你已经有了一个基本的IntentService类，你可以通过构造Intent对象向它发送操作请求。构造这些对象以及发送它们到你的IntentService的方式，将在接下来的课程中描述。
63 |
--------------------------------------------------------------------------------
/wearables/apps/index.md:
--------------------------------------------------------------------------------
1 | # 创建可穿戴的应用
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 可穿戴应用直接运行在穿戴设备上，应用可以直接访问例如传感器与GPU这样的硬件。这些应用和一般的Android应用的基础部分是一致的，只是在设计与可用性还有一些特殊功能上有比较大差异。手持设备与可穿戴设备上的应用主要有下面的一些差异：
6 |
7 | * 系统会强制执行超时机制。如果我们显示了一个Activity，用户并没有进行操作，设备会进入睡眠状态。当设备唤醒时，穿戴设备会显示主界面而不是刚才的activity。如果我们想要持续的显示一些东西，请使用notification来替代。
8 | * 相比起手持设备的应用，可穿戴应用的界面相对更小，功能也相对更少。他仅仅包含了那些对于可穿戴有意义的功能，这些功能通常是手持设备的一个子集。通常来说，我们应该尽可能的把运行操作搬到手持设备上，然后发送操作结果到可穿戴设备。
9 | * 用户不会直接将应用下载到可穿戴设备上进行安装。相反，我们将可穿戴设备应用打包到手持设备应用里。当用户安装手持设备的应用时，系统会自动安装可穿戴应用。然而，为了开发便利，我们还是可以直接安装应用到可穿戴设备。
10 | * 可穿戴应用可以使用大多数的标准Android APIs，除了下面的以外：
11 | * [android.webkit](http://developer.android.com/reference/android/webkit/package-summary.html)
12 | * [android.print](http://developer.android.com/reference/android/print/package-summary.html)
13 | * [android.app.backup](http://developer.android.com/reference/android/app/backup/package-summary.html)
14 | * [android.appwidget](http://developer.android.com/reference/android/appwidget/package-summary.html)
15 | * [android.hardware.usb](http://developer.android.com/reference/android/hardware/usb/package-summary.html)
16 |
17 | 在使用某个API之前，我们可以通过执行[hasSystemFeature()](http://developer.android.com/reference/android/content/pm/PackageManager.html#hasSystemFeature(java.lang.String)) 来判断可穿戴应用是否支持某个功能。
18 |
19 | > **Note:** 我们推荐使用Android Studio来开发Android Wear的应用，因为它提供了建立工程，添加库依赖，打包程序等在ADT上没有的功能。下面的培训课程的前提是假设你已经在使用Android Studio了。
20 |
21 | ## Lessons
22 | * [创建并运行可穿戴应用(Creating and Running a Wearable App)](creating.html)
23 |
24 | 学习如何创建一个包含了可穿戴与手持应用的Android Studio工程。学习如何在设备或者模拟器上运行应用。
25 |
26 |
27 | * [创建自定义的布局(Creating Custom Layouts)](layouts.html)
28 |
29 | 学习如何为notification与activity创建并显示一个自定义的布局
30 |
31 |
32 | * [添加语音功能(Adding Voice Capabilities)](voice.html)
33 |
34 | 学习如何使用语音指令启动一个activity，学习如何启动系统语音识别应用来获取用户的语音输入。
35 |
36 |
37 | * [打包可穿戴应用(Packaging Wearable Apps)](packaging.html)
38 |
39 | 学习如何把可穿戴应用打包到手持应用上。这使得系统能够在安装Google Play商店上的手持应用时自动安装可穿戴应用。
40 |
41 |
42 | * [通过蓝牙进行调试(Debugging over Bluetooth)](bt-debugging.html)
43 |
44 | 学习如何通过蓝牙而不是USB来调试可穿戴应用。
45 |
46 |
--------------------------------------------------------------------------------
/connectivity/efficient-downloads/connectivity-patterns.md:
--------------------------------------------------------------------------------
1 | # 根据网络连接类型来调整下载模式
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 所有的网络类型（Wi-Fi、3G、2G等）对电量的消耗并不是一样的。不仅是 Wi-Fi 电波比无线电波的耗电量要少很多，而且不同的无线电波（3G、2G、LTE……）使用的电量也不同。
6 |
7 | ## 使用 Wi-Fi
8 |
9 | 在大多数情况下，Wi-Fi 电波会在使用相对较低电量的情况下提供一个相对较大的带宽。因此，我们需要争取尽量使用 Wi-Fi 来传递数据。
10 |
11 | 我们可以使用 Broadcast Receiver 来监听网络连接状态的变化。当切换为 Wi-Fi 时，我们可以进行大量的数据传递操作，例如下载，执行定时的更新操作，甚至是在这个时候暂时加大更新频率。这些内容都可以在前面的课程中找到。
12 |
13 |
14 |
15 | ## 使用更大的带宽来更不频繁地下载更多数据
16 |
17 | 当通过无线电进行连接的时候，更大的带宽通常伴随着更多的电量消耗。这意味着 LTE（一种4G网络制式）会比 3G 制式更耗电，当然比起 2G 更甚。
18 |
19 | 从 Lesson 1 我们知道了无线电状态机是怎么回事，通常来说相对更宽的带宽网络制式会有更长的状态切换时间（也就是从 full power 过渡到 standby 有更长一段时间的延迟）。
20 |
21 | 同时，更高的带宽意味着可以更大量的进行预取，下载更多的数据。也许这个说法不是很直观，因为过渡的时间比较长，而过渡时间的长短我们无法控制，也就是过渡时间的电量消耗差不多是固定了。既然这样，我们在每次传输会话中为了减少更新的频率而把无线电激活的时间拉长，这样显的更有效率。也就是尽量一次性把事情做完，而不是断断续续的请求。
22 |
23 | 例如：如果 LTE 无线电的带宽与电量消耗都是 3G 无线电的2倍，我们应该在每次会话的时候都下载4倍于 3G 的数据量，或者是差不多 10Mb（前面文章有说明 3G 一般每次下载 2Mb）。当然，下载到这么多数据的时候，我们需要好好考虑预取本地存储的效率并且需要经常刷新预取的缓存。
24 |
25 | 我们可以使用 connectivity manager 来判断当前激活的无线电波，并且根据不同结果来修改预取操作。
26 |
27 | ```java
28 | ConnectivityManager cm =
29 | (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
30 |
31 | TelephonyManager tm =
32 | (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
33 |
34 | NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
35 |
36 | int PrefetchCacheSize = DEFAULT_PREFETCH_CACHE;
37 |
38 | switch (activeNetwork.getType()) {
39 | case (ConnectivityManager.TYPE_WIFI):
40 | PrefetchCacheSize = MAX_PREFETCH_CACHE; break;
41 | case (ConnectivityManager.TYPE_MOBILE): {
42 | switch (tm.getNetworkType()) {
43 | case (TelephonyManager.NETWORK_TYPE_LTE |
44 | TelephonyManager.NETWORK_TYPE_HSPAP):
45 | PrefetchCacheSize *= 4;
46 | break;
47 | case (TelephonyManager.NETWORK_TYPE_EDGE |
48 | TelephonyManager.NETWORK_TYPE_GPRS):
49 | PrefetchCacheSize /= 2;
50 | break;
51 | default: break;
52 | }
53 | break;
54 | }
55 | default: break;
56 | }
57 | ```
58 |
59 | **Ps：想要最大化效率与最小化电量的消耗，需要考虑的东西太多了，通常来说，会根据 app 的功能需求来选择有所侧重，那么前提就是需要了解到底哪些对效率的影响比较大,这有利于我们做出最优选择。**
60 |
--------------------------------------------------------------------------------
/connectivity/sync-adapters/index.md:
--------------------------------------------------------------------------------
1 | # 使用Sync Adapter传输数据
2 |
3 | > 编写:[jdneo](https://github.com/jdneo) - 原文:
4 |
5 | 如果我们的应用允许 Android 设备和网络服务器之间进行数据同步，那么它无疑将变得更加实用，更加吸引用户的注意。例如，将数据传输到服务器可以实现数据的备份，另一方面，从服务器获取数据可以让用户随时随地都能使用我们的应用。有时候，用户可能会觉得在线编辑他们的数据并将其发送到设备上，会是一件很方便的事情；或者他们有时会希望将收集到的数据上传到一个统一的存储区域中。
6 |
7 | 尽管我们可以设计一套自己的系统来实现应用中的数据传输，但我们也可以考虑一下使用 Android 的同步适配器框架（Android's Sync Adapter Framework）。该框架可以用来帮助管理数据，自动传输数据，以及协调不同应用间的同步问题。当使用这个框架时，我们可以利用它的一些特性，而这些特性可能是我们自己设计的传输方案中所没有的：
8 |
9 | **插件架构（Plug-in Architecture）：**
10 |
11 | 允许我们以可调用组件的形式，将传输代码添加到系统中。
12 |
13 | **自动执行（Automated Execution）：**
14 |
15 | 允许我们基于不同的准则自动地执行数据传输，比如：当数据变更时，或者每隔固定一段时间，亦或者每天，来自动执行一次数据传输。另外，系统会自动把当前无法执行的传输添加到一个队列中，并且在合适的时候运行它们。
16 |
17 | **自动网络监测（Automated Network Checking）：**
18 |
19 | 系统只在有网络连接的时候才会运行数据传输。
20 |
21 | **提升电池使用效率：**
22 |
23 | 允许我们将所有的数据传输任务统一地进行一次性批量传输，这样的话多个数据传输任务会在同一段时间内运行。我们应用的数据传输任务也会和其它应用的传输任务相结合，并一起传输。这样做可以减少系统连接网络的次数，进而减少电量的使用。
24 |
25 | **账户管理和授权：**
26 |
27 | 如果我们的应用需要用户登录授权，那么我们可以将账户管理和授权的功能集成到数据传输组件中。
28 |
29 | 本系列课程将展示如何创建一个 Sync Adapter，如何创建一个绑定了 Sync Adapter 的服务（[Service](http://developer.android.com/reference/android/app/Service.html)），如何提供其它组件来帮助我们将 Sync Adapter 集成到框架中，以及如何通过不同的方法来运行 Sync Adapter。
30 |
31 | > **Note：**Sync Adapter 是异步执行的，它可以定期且有效地传输数据，但在实时性上一般难以满足要求。如果我们想要实时地传输数据，那么应该在 [AsyncTask](http://developer.android.com/reference/android/os/AsyncTask.html) 或 [IntentService](http://developer.android.com/reference/android/app/IntentService.html) 中完成这一任务。
32 |
33 | ## Sample Code
34 |
35 | [BasicSyncAdapter.zip](http://developer.android.com/shareables/training/BasicSyncAdapter.zip)
36 |
37 | ## Lessons
38 |
39 | [创建 Stub 授权器](create-authenticator.html)
40 |
41 | 学习如何在我们的应用中添加一个 Sync Adapter 框架需要的账户处理组件。这节课将展示如何简单地创建一个 Stub Authenticator 组件。
42 |
43 | [创建 Stub Content Provider](create-stub-provider.html)
44 |
45 | 学习如何在我们的应用中添加一个 Sync Adapter 框架需要的 Content Provider 组件。在这节课中，假设我们的应用实际上不需要使用 Content Provider，所以它将教我们如何添加一个 Stub 组件。如果我们的应用已经有了一个 Content Provider 组件，那么可以跳过这节课。
46 |
47 | [创建 Sync Adapter](create-sync-adapter.html)
48 |
49 | 学习如何将我们的数据传输代码封装到组件当中，并让其可以被 Sync Adapter 框架自动执行。
50 |
51 | [执行 Sync Adapter](running-sync-adapter.html)
52 |
53 | 学习如何使用 Sync Adapter 框架激活并调度数据传输。
54 |
--------------------------------------------------------------------------------
/performance/monitor-device-state/docking-monitor.md:
--------------------------------------------------------------------------------
1 | # 判断并监测设备的底座状态与类型
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | Android设备可以放置在许多不同的底座中，包括车载底座，家庭底座还有数字信号底座以及模拟信号底座等。由于许多底座会向设备充电，因此底座状态通常与充电状态密切相关。
6 |
7 | 你的应用类型决定了底座类型会对更新频率产生怎样的影响。对于一个体育类应用，可以让设备在笔记本底座状态下增加更新的频率，或者当设备在车载底座状态下停止更新。相反的，如果你的后台服务用来更新交通数据，你也可以选择在车载底座模式下最大化更新的频率。
8 |
9 | 底座状态也是以Sticky Intent方式来广播的，这样可以通过查询Intent里面的数据来判断目前设备是否放置在底座中，以及底座的类型。
10 |
11 | ## 判断当前底座状态
12 |
13 | 底座状态的具体信息会以Extra数据的形式，包含在具有[ACTION_DOCK_EVENT](http://developer.android.com/reference/android/content/Intent.html#ACTION_DOCK_EVENT)这一Action的某个Sticky广播中 ，因此，你不需要为其注册一个[BroadcastReceiver](http://developer.android.com/reference/android/content/BroadcastReceiver.html)。如下所示，仅需要将`null`作为参数传递给registerReceiver()方法就可以了：
14 |
15 | ```java
16 | IntentFilter ifilter = new IntentFilter(Intent.ACTION_DOCK_EVENT);
17 | Intent dockStatus = context.registerReceiver(null, ifilter);
18 | ```
19 |
20 | 你可以从`EXTRA_DOCK_STATE`这一Extra数据中，提取出当前的底座状态：
21 |
22 | ```java
23 | int dockState = battery.getIntExtra(EXTRA_DOCK_STATE, -1);
24 | boolean isDocked = dockState != Intent.EXTRA_DOCK_STATE_UNDOCKED;
25 | ```
26 |
27 | ## 判断当前底座类型
28 |
29 | 如果设备被放置在了底座中，那么它可以有下面四种底座类型：
30 |
31 | * Car
32 | * Desk
33 | * Low-End (Analog) Desk
34 | * High-End (Digital) Desk
35 |
36 | 注意最后两种底座类型仅在API Level 11及以后版本的Android系统中才被支持。如果你只在乎底座的类型而不管它是数字的还是模拟的，那么可以仅监测三种类型：
37 |
38 | ```java
39 | boolean isCar = dockState == EXTRA_DOCK_STATE_CAR;
40 | boolean isDesk = dockState == EXTRA_DOCK_STATE_DESK ||
41 | dockState == EXTRA_DOCK_STATE_LE_DESK ||
42 | dockState == EXTRA_DOCK_STATE_HE_DESK;
43 | ```
44 |
45 | ## 监测底座状态或者类型的改变
46 |
47 | 当设备被放置在或者拔出底座时，系统会发出一个具有[ACTION_DOCK_EVENT](http://developer.android.com/reference/android/content/Intent.html#ACTION_DOCK_EVENT)这一Action的广播。为了监听底座状态的变化，我们只需要在应用的Manifest文件中注册一个BroadcastReceiver，如下所示：
48 |
49 | ```xml
50 |
51 | ```
52 |
53 | 之于该BroadcastReceiver的具体实现，可以参考前面提到的那些方法，以此来提取出当前的底座类型和状态。
54 |
--------------------------------------------------------------------------------
/multimedia/audio/audio-output.md:
--------------------------------------------------------------------------------
1 | # 兼容音频输出设备
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 当用户想要通过Android设备欣赏音乐的时候，他可以有多种选择，大多数设备拥有内置的扬声器，有线耳机，也有其它很多设备支持蓝牙连接，有些甚至还支持A2DP蓝牙音频传输模型协定。（译注：A2DP全名是Advanced Audio Distribution Profile 蓝牙音频传输模型协定! A2DP是能够采用耳机内的芯片来堆栈数据，达到声音的高清晰度。有A2DP的耳机就是蓝牙立体声耳机。声音能达到44.1kHz，一般的耳机只能达到8kHz。如果手机支持蓝牙，只要装载A2DP协议，就能使用A2DP耳机了。还有消费者看到技术参数提到蓝牙V1.0 V1.1 V1.2 V2.0 - 这些是指蓝牙的技术版本，是指通过蓝牙传输的速度，他们是否支持A2DP具体要看蓝牙产品制造商是否使用这个技术。来自[百度百科](http://baike.baidu.com/view/551149.htm)）
6 |
7 |
8 |
9 | ## 检测目前正在使用的硬件设备(Check What Hardware is Being Used)
10 |
11 | 使用不同的硬件播放声音会影响到应用的行为。可以使用[AudioManager](http://developer.android.com/reference/android/media/AudioManager.html)来查询当前音频是输出到扬声器，有线耳机还是蓝牙上，如下所示：
12 |
13 | ```java
14 | if (isBluetoothA2dpOn()) {
15 | // Adjust output for Bluetooth.
16 | } else if (isSpeakerphoneOn()) {
17 | // Adjust output for Speakerphone.
18 | } else if (isWiredHeadsetOn()) {
19 | // Adjust output for headsets
20 | } else {
21 | // If audio plays and noone can hear it, is it still playing?
22 | }
23 | ```
24 |
25 | ## 处理音频输出设备的改变(Handle Changes in the Audio Output Hardware)
26 |
27 | 当有线耳机被拔出或者蓝牙设备断开连接的时候，音频流会自动输出到内置的扬声器上。假设播放声音很大，这个时候突然转到扬声器播放会显得非常嘈杂。
28 |
29 | 幸运的是，系统会在这种情况下广播带有[ACTION_AUDIO_BECOMING_NOISY](http://developer.android.com/reference/android/media/AudioManager.html#ACTION_AUDIO_BECOMING_NOISY)的Intent。无论何时播放音频，我们都应该注册一个[BroadcastReceiver](http://developer.android.com/reference/android/content/BroadcastReceiver.html)来监听这个Intent。在使用音乐播放器时，用户通常会希望此时能够暂停当前歌曲的播放。而在游戏当中，用户通常会希望可以减低音量。
30 |
31 | ```java
32 | private class NoisyAudioStreamReceiver extends BroadcastReceiver {
33 | @Override
34 | public void onReceive(Context context, Intent intent) {
35 | if (AudioManager.ACTION_AUDIO_BECOMING_NOISY.equals(intent.getAction())) {
36 | // Pause the playback
37 | }
38 | }
39 | }
40 |
41 | private IntentFilter intentFilter = new IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY);
42 |
43 | private void startPlayback() {
44 | registerReceiver(myNoisyAudioStreamReceiver(), intentFilter);
45 | }
46 |
47 | private void stopPlayback() {
48 | unregisterReceiver(myNoisyAudioStreamReceiver);
49 | }
50 | ```
51 |
--------------------------------------------------------------------------------
/permissions/DeclaringPermissions.md:
--------------------------------------------------------------------------------
1 | # 权限定义
2 | 编写:[Goerver](https://github.com/orangebook) - 原文: Declaring Permissions https://developer.android.com/training/permissions/declaring.html
3 |
4 | 本课程将教您：
5 |
6 | 1.确认您的APP需要的权限
7 |
8 |
9 | 2.向Mainifest添加权限
10 |
11 | 同时应该阅读:
12 | 1.[Using Permissions](https://developer.android.com/guide/topics/security/permissions.html#permissions)
13 | 2.[Normal and Dangerous Permissions](https://developer.android.com/guide/topics/security/permissions.html#normal-dangerous)
14 |
15 | 每个Android应用程序运行在一个限制访问的沙盒。如果一个APP需要使用沙盒外的资源或信息，APP必须请求适合的权限。你需要在App中定义一个APP需要的权限清单在 [App Mainifest](https://developer.android.com/guide/topics/manifest/manifest-intro.html)。
16 |
17 | 根据权限的敏感度，系统可能会自动授给权限,或者询问设备用户授予权限。例如，如果你的APP请求权限打开设备的闪光灯，该系统授将自动授给权限。但是如果APP需要用户的联系人，该系统询问用户名授予权限。根据系统版本，用户需要在安装APP时(Android 5.1及以下)或运行APP时(Android 6.0及以上)授予权限。
18 |
19 | ## 确定您的应用程序需要的权限
20 | 当你开发你的APP,你应该注意你的APP使用的功能所需要的权限。通常，无论是使用APP没有创建的信息、资源(resource),还是执行一个影响设备或其他APP的操作，APP都需要请求合适的权限。例如，如果APP需要访问Internet,使用设备的摄像头或开关WIFI，该APP均需要适当的权限。对于系统权限的列表，请参见[Normal and Dangerous Permissions](https://developer.android.com/guide/topics/security/permissions.html#normal-dangerous)。
21 |
22 | 您的应用程序只需要它直接执行的操作的权限。如果APP是要求另一个应用程序执行任务或提供信息,则不需要请求相应的权限。例如，如果你的应用程序需要读取用户的通讯录，应用程序需要 [READ_CONTACTS](https://developer.android.com/reference/android/Manifest.permission.html#READ_CONTACTS)。但如果你的应用程序使用了一个Intent来请求来自用户的联系人应用程序的信息，你的应用程序不需要任何权限，但联系人应用程序确实需要有该权限。对于更多的信息，请参见 [Consider Using an Intent](https://developer.android.com/training/permissions/best-practices.html#perms-vs-intents)。
23 |
24 | ## 添加权限到 Manifest
25 | 要声明您的应用程序需要一个权限，请在应用程序 **manifest** 中放置一个 **** 元素，作为顶层的 **** 元素的子元素。例如，一个应用程序，需要发送短信将需要下面行代码在 **manifest**：
26 |
27 | ```
28 |
30 |
31 |
32 |
33 |
34 |
35 | ...
36 |
37 |
38 |
39 | ```
40 |
41 | 当你声明一个权限后，系统的行为取决于权限是多么的敏感。如果权限不影响用户的隐私，系统将自动授予权限。如果权限可能授予对敏感用户信息的访问权限，则系统要求用户批准请求。有关不同类型的权限的更多信息，请参见“[Normal and Dangerous Permissions](Normal and Dangerous Permissions)”。
42 |
43 | 作者 [@Goerver][1]
44 | 2016 年 09月 4日
45 |
46 | [1]:http://www.flyfishonline.com
47 |
--------------------------------------------------------------------------------
/graphics/opengl/motion.md:
--------------------------------------------------------------------------------
1 | # 添加移动
2 |
3 | > 编写:[jdneo](https://github.com/jdneo) - 原文:
4 |
5 | 在屏幕上绘制图形是OpenGL的一个基本特性，当然我们也可以通过其它的Android图形框架类做这些事情，包括[Canvas](http://developer.android.com/reference/android/graphics/Canvas.html)和[Drawable](http://developer.android.com/reference/android/graphics/drawable/Drawable.html)对象。OpenGL ES的特别之处在于，它还提供了其它的一些功能，比如在三维空间中对绘制图形进行移动和变换操作，或者通过其它独有的方法创建出引人入胜的用户体验。
6 |
7 | 在这节课中，我们会更深入地学习OpenGL ES的知识：对一个图形添加旋转动画。
8 |
9 | ## 旋转一个形状
10 |
11 | 使用OpenGL ES 2.0 旋转一个绘制图形是比较简单的。在渲染器中，创建另一个变换矩阵（一个旋转矩阵），并且将它和我们的投影变换矩阵以及相机视角变换矩阵结合在一起：
12 |
13 | ```java
14 | private float[] mRotationMatrix = new float[16];
15 | public void onDrawFrame(GL10 gl) {
16 | float[] scratch = new float[16];
17 |
18 | ...
19 |
20 | // Create a rotation transformation for the triangle
21 | long time = SystemClock.uptimeMillis() % 4000L;
22 | float angle = 0.090f * ((int) time);
23 | Matrix.setRotateM(mRotationMatrix, 0, angle, 0, 0, -1.0f);
24 |
25 | // Combine the rotation matrix with the projection and camera view
26 | // Note that the mMVPMatrix factor *must be first* in order
27 | // for the matrix multiplication product to be correct.
28 | Matrix.multiplyMM(scratch, 0, mMVPMatrix, 0, mRotationMatrix, 0);
29 |
30 | // Draw triangle
31 | mTriangle.draw(scratch);
32 | }
33 | ```
34 |
35 | 如果完成了这些变更以后，你的三角形还是没有旋转的话，确认一下你是否将启用[GLSurfaceView.RENDERMODE_WHEN_DIRTY](http://developer.android.com/reference/android/opengl/GLSurfaceView.html#RENDERMODE_WHEN_DIRTY)的这一配置所对应的代码注释掉了，有关该方面的知识会在下一节中展开。
36 |
37 | ## 启用连续渲染
38 |
39 | 如果严格按照这节课的样例代码走到了现在这一步，那么请确认一下是否将设置渲染模式为`RENDERMODE_WHEN_DIRTY`的那行代码注释了，不然的话OpenGL只会对这个形状执行一次旋转，然后就等待[GLSurfaceView](http://developer.android.com/reference/android/opengl/GLSurfaceView.html)容器的[requestRender()](http://developer.android.com/reference/android/opengl/GLSurfaceView.html#requestRender())方法被调用后才会继续执行渲染操作。
40 |
41 | ```java
42 | public MyGLSurfaceView(Context context) {
43 | ...
44 | // Render the view only when there is a change in the drawing data.
45 | // To allow the triangle to rotate automatically, this line is commented out:
46 | //setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
47 | }
48 | ```
49 |
50 | 除非某个对象，它的变化和用户的交互无关，不然的话一般还是建议将这个配置打开。在下一节课中的内容将会把这个注释放开，再次设定这一配置选项。
51 |
--------------------------------------------------------------------------------
/material/theme.md:
--------------------------------------------------------------------------------
1 | # 使用Material的主题
2 |
3 | > 编写: [allenlsy](https://github.com/allenlsy) - 原文:
4 |
5 | 新的 Material 主题提供：
6 |
7 | * 系统组件，用于设定调色板
8 | * 系统组件的触摸反馈动画
9 | * Activity 切换动画
10 |
11 | 你可以根据你的品牌特征修改调色板，从而自定义 Material 主题。你可以通过主题属性调整 action bar 和状态栏的颜色，就像下图一样：
12 |
13 | 
14 |
15 | 系统组件拥有新的设计和触摸反馈动画。你可以自定义调色板，反馈动画和 Activity 切换动画。
16 |
17 | Material 主题被定义在：
18 |
19 | * `@android:style/Theme.Material` (暗色版本)
20 | * `@android:style/Theme.Material.Light` (亮色版本)
21 | * `@android:style/Theme.Material.Light.DarkActionBar`
22 |
23 | 
24 | 
25 |
26 | 想知道可用的 Material style 的列表，可以在 API 文档中参见 [R.style](http://developer.android.com/reference/android/R.style.html).
27 |
28 | > **Note:** Material 主题只支持 Android 5.0 (API level 21) 及以上版本。[v7 Support 库](https://developer.android.com/tools/support-library/features.html#v7)提供了一些组件的 Material Deisgn 样式，也支持自定义调色板。更多信息，请参见维护兼容性章节。
29 |
30 | ## 自定义调色板
31 |
32 | 在根据自己的品牌自定义调色板时，你需要在继承 material 主题时定义 theme 属性。
33 |
34 | ```xml
35 |
36 |
37 |
46 |
47 | ```
48 |
49 | ## 自定义状态栏
50 |
51 | Material 主题使得你很容易自定义状态栏，你可以设定适合自己品牌的颜色，并提供足够的对比度，以显示白色的状态图标。设置状态栏颜色时，要在继承 Material 主题时设定 `android:statsBarColor` 属性。默认情况下，`android:statusBarColor` 会继承 `android:colorPrimaryDark` 的值。
52 |
53 | 你也可以在状态栏的背景上绘画。比如，你想让位于照片之上的状态栏透明，并保留一点深色渐变以确保白色图标可见。这样的话，设定 `android:statusBarColor` 属性为 `@android:color/transparent` 并调整窗口的 Flag 标记。你也可以用 `Window.setStatusBarColor()` 来实现动画或淡入淡出。
54 |
55 | >**Note:** 状态栏必须随时保持和 primary toolbar (即顶部Actionbar，译者注) 的界线清晰。除了一种情况，即在状态栏后面显示图片或媒体内容时之外，你都要用渐变色来确保前台图标仍然可见。
56 |
57 | 当你自定义导航栏和状态栏时，要么两者都透明，要么只修改状态栏。其他情况下，导航栏应该保持黑色。
58 |
59 | ## 主题单独视图
60 |
61 | XML layout 中的元素可以定义 `android:theme` 属性， 用于引用主题资源。这个属性修改了自己和子元素的主题，对于要修改局部颜色主题的情况十分有用。
62 |
--------------------------------------------------------------------------------
/ux/search/back-compat.md:
--------------------------------------------------------------------------------
1 | # 保持向下兼容
2 |
3 | > 编写:[Lin-H](https://github.com/Lin-H) - 原文:
4 |
5 | [SearchView](http://developer.android.com/reference/android/widget/SearchView.html)和action bar只在Android 3.0以及以上版本可用。为了支持旧版本平台，你可以回到搜索对话框。搜索框是系统提供的UI，在调用时会覆盖在你的应用的最顶端。
6 |
7 | ##设置最小和目标API级别
8 |
9 | 要设置搜索对话框，首先在你的manifest中声明你要支持旧版本设备，并且目标平台为Android 3.0或更新版本。当你这么做之后，你的应用会自动地在Android 3.0或以上使用action bar，在旧版本的设备使用传统的目录系统:
10 |
11 | ```xml
12 |
13 |
14 |
15 | ...
16 | ```
17 |
18 | ##为旧版本设备提供搜索对话框
19 |
20 | 要在旧版本设备中调用搜索对话框，可以在任何时候，当用户从选项目录中选择搜索项时，调用[onSearchRequested()](reference/android/app/Activity.html#onSearchRequested())。因为Android 3.0或以上会在action bar中显示[SearchView](http://developer.android.com/reference/android/widget/SearchView.html)(就像在第一节课中演示的那样)，所以当用户选择目录的搜索项时，只有Android 3.0以下版本的会调用[onOptionsItemSelected()](http://developer.android.com/reference/android/app/Activity.html#onOptionsItemSelected(android.view.MenuItem))。
21 |
22 | ```java
23 | @Override
24 | public boolean onOptionsItemSelected(MenuItem item) {
25 | switch (item.getItemId()) {
26 | case R.id.search:
27 | onSearchRequested();
28 | return true;
29 | default:
30 | return false;
31 | }
32 | }
33 | ```
34 |
35 | ##在运行时检查Android的构建版本
36 |
37 | 在运行时，检查设备的版本可以保证在旧版本设备中，不使用不支持的[SearchView](http://developer.android.com/reference/android/widget/SearchView.html)。在我们这个例子中，这一操作在[onCreateOptionsMenu()](http://developer.android.com/reference/android/app/Activity.html#onCreateOptionsMenu(android.view.Menu))方法中:
38 |
39 | ```java
40 | @Override
41 | public boolean onCreateOptionsMenu(Menu menu) {
42 |
43 | MenuInflater inflater = getMenuInflater();
44 | inflater.inflate(R.menu.options_menu, menu);
45 |
46 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
47 | SearchManager searchManager =
48 | (SearchManager) getSystemService(Context.SEARCH_SERVICE);
49 | SearchView searchView =
50 | (SearchView) menu.findItem(R.id.search).getActionView();
51 | searchView.setSearchableInfo(
52 | searchManager.getSearchableInfo(getComponentName()));
53 | searchView.setIconifiedByDefault(false);
54 | }
55 | return true;
56 | }
57 | ```
58 |
--------------------------------------------------------------------------------
/content-sharing/sharing/shareaction.md:
--------------------------------------------------------------------------------
1 | # 添加一个简便的分享功能
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | Android4.0之后系统中ActionProvider的引入使在ActionBar中添加分享功能变得更为简单。它会handle出现share功能的appearance与behavior。在ShareActionProvider的例子里面，我们只需要提供一个share intent，剩下的就交给[ShareActionProvider](https://developer.android.com/reference/android/widget/ShareActionProvider.html)来做。
6 |
7 | 
8 |
9 |
10 |
11 | ## 更新菜单声明(Update Menu Declarations)
12 |
13 | 使用ShareActionProvider的第一步，在menu resources对应item中定义`android:actionProviderClass`属性。
14 |
15 | ```xml
16 |
23 | ```
24 |
25 | 这表明了该item的appearance与function需要与ShareActionProvider匹配。此外，你还需要告诉provider想分享的内容。
26 |
27 | ## Set the Share Intent(设置分享的intent)
28 |
29 | 为了实现ShareActionProvider的功能，我们必须为它提供一个intent。该share intent应该像第一课讲的那样，带有`ACTION_SEND`和附加数据(例如`EXTRA_TEXT`与 `EXTRA_STREAM`)的。使用ShareActionProvider的例子如下：
30 |
31 | ```java
32 | private ShareActionProvider mShareActionProvider;
33 | ...
34 |
35 | @Override
36 | public boolean onCreateOptionsMenu(Menu menu) {
37 | // Inflate menu resource file.
38 | getMenuInflater().inflate(R.menu.share_menu, menu);
39 |
40 | // Locate MenuItem with ShareActionProvider
41 | MenuItem item = menu.findItem(R.id.menu_item_share);
42 |
43 | // Fetch and store ShareActionProvider
44 | mShareActionProvider = (ShareActionProvider) item.getActionProvider();
45 |
46 | // Return true to display menu
47 | return true;
48 | }
49 |
50 | // Call to update the share intent
51 | private void setShareIntent(Intent shareIntent) {
52 | if (mShareActionProvider != null) {
53 | mShareActionProvider.setShareIntent(shareIntent);
54 | }
55 | }
56 | ```
57 |
58 | 也许在创建菜单的时候仅仅需要设置一次share intent就满足需求了，或者说我们可能想先设置share intent，然后根据UI的变化来对intent进行更新。例如，当在Gallery里面全图查看照片的时候，share intent会在切换图片时候进行改变。
59 | 更多关于ShareActionProvider的内容，请查看[Action Bar](https://developer.android.com/guide/topics/ui/actionbar.html#ActionProvider) 。
60 |
--------------------------------------------------------------------------------
/multimedia/printing/photos.md:
--------------------------------------------------------------------------------
1 | # 打印照片
2 |
3 | > 编写:[jdneo](https://github.com/jdneo) - 原文:
4 |
5 | 拍摄并分享照片是移动设备最流行的用法之一。如果我们的应用拍摄了照片，并期望可以展示他们，或者允许用户共享照片，那么我们就应该考虑让应用可以打印出这些照片来。[Android Support Library](http://developer.android.com/tools/support-library/index.html)提供了一个方便的函数，通过这一函数，仅仅使用很少量的代码和一些简单的打印布局配置集，就能够进行照片打印。
6 |
7 | 这堂课将展示如何使用v4 support library中的[PrintHelper](http://developer.android.com/reference/android/support/v4/print/PrintHelper.html)类打印一幅图片。
8 |
9 | ## 打印一幅图片
10 |
11 | Android Support Library中的[PrintHelper](http://developer.android.com/reference/android/support/v4/print/PrintHelper.html)类提供了一种打印图片的简单方法。该类有一个单一的布局选项：setScaleMode()，它允许我们使用下面的两个选项之一：
12 | * [SCALE_MODE_FIT](http://developer.android.com/reference/android/support/v4/print/PrintHelper.html#SCALE_MODE_FIT)：该选项会调整图像的大小，这样整个图像就会在打印有效区域内全部显示出来（等比例缩放至长和宽都包含在纸张页面内）。
13 | * [SCALE_MODE_FILL](http://developer.android.com/reference/android/support/v4/print/PrintHelper.html#SCALE_MODE_FILL)：该选项同样会等比例地调整图像的大小使图像充满整个打印有效区域，即让图像充满整个纸张页面。这就意味着如果选择这个选项，那么图片的一部分（顶部和底部，或者左侧和右侧）将无法打印出来。如果不设置图像的打印布局选项，该模式将是默认的图像拉伸方式。
14 |
15 | 这两个setScaleMode()的图像布局选项都会保持图像原有的长宽比。下面的代码展示了如何创建一个[PrintHelper](http://developer.android.com/reference/android/support/v4/print/PrintHelper.html)类的实例，设置布局选项，并开始打印进程：
16 |
17 | ```java
18 | private void doPhotoPrint() {
19 | PrintHelper photoPrinter = new PrintHelper(getActivity());
20 | photoPrinter.setScaleMode(PrintHelper.SCALE_MODE_FIT);
21 | Bitmap bitmap = BitmapFactory.decodeResource(getResources(),
22 | R.drawable.droids);
23 | photoPrinter.printBitmap("droids.jpg - test print", bitmap);
24 | }
25 | ```
26 |
27 | 该方法可以作为一个菜单项的Action来被调用。注意对于那些不一定被设备支持的菜单项（比如有些设备可能无法支持打印），应该放置在“更多菜单（overflow menu）”中。要获取有关这方面的更多知识，可以阅读：[Action Bar](http://developer.android.com/design/patterns/actionbar.html)。
28 |
29 | 在printBitmap()被调用之后，我们的应用就不再需要进行其他的操作了。之后Android打印界面就会出现，允许用户选择一个打印机和它的打印选项。用户可以打印图像或者取消这一次操作。如果用户选择了打印图像，那么一个打印任务将会被创建，同时在系统的通知栏中会显示一个打印提醒通知。
30 |
31 | 如果希望在打印输出中包含更多的内容，而不仅仅是一张图片，那么就必须构造一个打印文档。这方面知识将会在后面的两节课程中展开。
32 |
--------------------------------------------------------------------------------
/ux/notify-user/update-notification.md:
--------------------------------------------------------------------------------
1 | # 更新Notification
2 |
3 | > 编写:[fastcome1985](https://github.com/fastcome1985) - 原文:
4 |
5 | 当你需要对同一事件发布多次Notification时，你应该避免每次都生成一个全新的Notification。相反，你应该考虑去更新先前的Notification，或者改变它的值，或者增加一些值，或者两者同时进行。
6 |
7 | 下面的章节描述了如何更新Notifications，以及如何移除它们。
8 |
9 |
10 |
11 | ## 改变一个Notification
12 |
13 | 想要设置一个可以被更新的Notification，需要在发布它的时候调用[NotificationManager.notify(ID, notification)](developer.android.com/reference/android/app/NotificationManager.html#notify(int,%20android.app.Notification))方法为它指定一个notification ID。更新一个已经发布的Notification，需要更新或者创建一个[NotificationCompat.Builder](developer.android.com/reference/android/support/v4/app/NotificationCompat.Builder.html)对象，并从这个对象创建一个[Notification](developer.android.com/reference/android/app/Notification.html)对象，然后用与先前一样的ID去发布这个[Notification](developer.android.com/reference/android/app/Notification.html)。
14 |
15 | 下面的代码片段演示了更新一个notification来反映事件发生的次数，它把notification堆积起来，显示一个总数。
16 |
17 |
18 | ```java
19 |
20 | mNotificationManager =
21 | (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
22 | // Sets an ID for the notification, so it can be updated
23 | int notifyID = 1;
24 | mNotifyBuilder = new NotificationCompat.Builder(this)
25 | .setContentTitle("New Message")
26 | .setContentText("You've received new messages.")
27 | .setSmallIcon(R.drawable.ic_notify_status)
28 | numMessages = 0;
29 | // Start of a loop that processes data and then notifies the user
30 | ...
31 | mNotifyBuilder.setContentText(currentText)
32 | .setNumber(++numMessages);
33 | // Because the ID remains unchanged, the existing notification is
34 | // updated.
35 | mNotificationManager.notify(
36 | notifyID,
37 | mNotifyBuilder.build());
38 | ...
39 |
40 | ```
41 |
42 | ## 移除Notification
43 |
44 | Notifications 将持续可见，除非下面任何一种情况发生。
45 |
46 |
47 | * 用户清除Notification单独地或者使用“清除所有”（如果Notification能被清除）。
48 | * 你在创建notification时调用了 setAutoCancel(developer.android.com/reference/android/support/v4/app/NotificationCompat.Builder.html#setAutoCancel(boolean))方法，以及用户点击了这个notification，
49 | * 你为一个指定的 notification ID调用了[cancel()](developer.android.com/reference/android/app/NotificationManager.html#cancel(int))方法。这个方法也会删除正在进行的notifications。
50 | * 你调用了[cancelAll()](developer.android.com/reference/android/app/NotificationManager.html#cancelAll())方法，它将会移除你先前发布的所有Notification。
51 |
--------------------------------------------------------------------------------
/wearables/notifications/pages.md:
--------------------------------------------------------------------------------
1 | # 为 Notification 添加页面
2 |
3 | > 编写:[wangyachen](https://github.com/wangyacheng) - 原文:
4 |
5 | 当开发者想要在不需要用户在他们的手机上打开app的情况下，还可以允许表达更多的信息，那么开发者可以在可穿戴设备上的Notification中添加一个或多个的页面。添加的页面会马上出现在主 Notification 卡片的右边。
6 |
7 | 
8 | 
9 |
10 | 为了创建一个拥有多个页面的 Notification，开发者需要：
11 |
12 | 1. 通过[NotificationCompat.Builder](http://developer.android.com/reference/android/support/v4/app/NotificationCompat.Builder.html)创建主Notification（首页），以开发者想要的方式使其出现在手持设备上。
13 | 2. 通过[NotificationCompat.Builder](http://developer.android.com/reference/android/support/v4/app/NotificationCompat.Builder.html)为可穿戴设备添加更多的页面。
14 | 3. 通过[addPage()](http://developer.android.com/reference/android/support/v4/app/NotificationCompat.WearableExtender.html#addPage(android.app.Notification))方法将这些页面应用到主 Notification 中，或者通过[addPages()](http://developer.android.com/reference/android/support/v4/app/NotificationCompat.WearableExtender.html#addPage(android.app.Notification))将多个页面添加到一个[Collection](http://developer.android.com/reference/java/util/Collection.html)。
15 |
16 | 举个例子，以下代码为Notification添加了第二个页面：
17 |
18 | ```java
19 | // Create builder for the main notification
20 | NotificationCompat.Builder notificationBuilder =
21 | new NotificationCompat.Builder(this)
22 | .setSmallIcon(R.drawable.new_message)
23 | .setContentTitle("Page 1")
24 | .setContentText("Short message")
25 | .setContentIntent(viewPendingIntent);
26 |
27 | // Create a big text style for the second page
28 | BigTextStyle secondPageStyle = new NotificationCompat.BigTextStyle();
29 | secondPageStyle.setBigContentTitle("Page 2")
30 | .bigText("A lot of text...");
31 |
32 | // Create second page notification
33 | Notification secondPageNotification =
34 | new NotificationCompat.Builder(this)
35 | .setStyle(secondPageStyle)
36 | .build();
37 |
38 | // Add second page with wearable extender and extend the main notification
39 | Notification twoPageNotification =
40 | new WearableExtender()
41 | .addPage(secondPageNotification)
42 | .extend(notificationBuilder)
43 | .build();
44 |
45 | // Issue the notification
46 | notificationManager =
47 | NotificationManagerCompat.from(this);
48 | notificationManager.notify(notificationId, twoPageNotification);
49 | ```
50 |
51 | 下一课：[以Stack的方式显示Notifications](stacks.html)
52 |
--------------------------------------------------------------------------------
/connectivity/volley/index.md:
--------------------------------------------------------------------------------
1 | # 使用 Volley 传输网络数据
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | `Volley` 是一个 HTTP 库，它能够帮助 Android app 更方便地执行网络操作，最重要的是，它更快速高效。我们可以通过开源的 [AOSP](https://android.googlesource.com/platform/frameworks/volley) 仓库获取到 Volley 。
6 |
7 | **YOU SHOULD ALSO SEE**
8 |
9 | 使用 Volley 来编写一个 app，请参考[2013 Google I/O schedule app](https://github.com/google/iosched)。另外需要特别关注下面2个部分：
10 |
11 | * [ImageLoader](https://github.com/google/iosched/blob/master/android/src/main/java/com/google/android/apps/iosched/util/ImageLoader.java)
12 | * [BitmapCache](https://github.com/google/iosched/blob/master/android/src/main/java/com/google/android/apps/iosched/util/BitmapCache.java)
13 |
14 | [**VIDEO - Volley: Easy,Fast Networking for Android**](https://developers.google.com/events/io/sessions/325304728)
15 | ***
16 | Volley 有如下的优点：
17 |
18 | * 自动调度网络请求。
19 | * 高并发网络连接。
20 | * 通过标准的 HTTP [cache coherence](https://en.wikipedia.org/wiki/Cache_coherence)（高速缓存一致性）缓存磁盘和内存透明的响应。
21 | * 支持指定请求的优先级。
22 | * 撤销请求 API。我们可以取消单个请求，或者指定取消请求队列中的一个区域。
23 | * 框架容易被定制，例如，定制重试或者回退功能。
24 | * 强大的指令（Strong ordering）可以使得异步加载网络数据并正确地显示到 UI 的操作更加简单。
25 | * 包含了调试与追踪工具。
26 |
27 | Volley 擅长执行用来显示 UI 的 RPC 类型操作，例如获取搜索结果的数据。它轻松的整合了任何协议，并输出操作结果的数据，可以是原始的字符串，也可以是图片，或者是 JSON。通过提供内置的我们可能使用到的功能，Volley 可以使得我们免去重复编写样板代码，使我们可以把关注点放在 app 的功能逻辑上。
28 |
29 | Volley 不适合用来下载大的数据文件。因为 Volley 会保持在解析的过程中所有的响应。对于下载大量的数据操作，请考虑使用 [DownloadManager](http://developer.android.com/reference/android/app/DownloadManager.html)。
30 |
31 | Volley 框架的核心代码是托管在 AOSP 仓库的 `frameworks/volley` 中，相关的工具放在 `toolbox` 下。把 Volley 添加到项目中最简便的方法是 Clone 仓库，然后把它设置为一个 library project：
32 |
33 | 1. 通过下面的命令来Clone仓库：
34 |
35 | ```
36 | git clone https://android.googlesource.com/platform/frameworks/volley
37 | ```
38 |
39 | 2. 以一个 Android library project 的方式导入下载的源代码到你的项目中。(如果你使用 Eclipse，请参考 Managing Projects from Eclipse with ADT，或者编译成一个 `.jar` 文件。
40 |
41 | ## Lessons
42 |
43 | [**发送一个简单的网络请求(Sending a Simple Request)**](simple.html)
44 |
45 | 学习如何通过 Volley 默认的行为发送一个简单的请求，以及如何取消一个请求。
46 |
47 | [**建立一个请求队列(Setting Up a RequestQueue)**](request-queue.html)
48 |
49 | 学习如何建立一个请求队列（`RequestQueue`），以及如何实现一个单例模式来创建一个请求队列，使 `RequestQueue` 能够持续保持在我们 app 的生命周期中。
50 |
51 | [**生成一个标准的请求(Making a Standard Request)**](request.html)
52 |
53 | 学习如何使用 Volley 的 out-of-the-box（可直接使用、无需配置）请求类型（原始字符串、图片和 JSON）来发送一个请求。
54 |
55 | [**实现自定义的请求(Implementing a Custom Request)**](request-custom.html)
56 |
57 | 学习如何实现一个自定义的请求。
58 |
59 |
--------------------------------------------------------------------------------
/ux/design-nav/ancestral-temporal.md:
--------------------------------------------------------------------------------
1 | # 提供向上导航与历史导航
2 |
3 | > 编写:[XizhiXu](https://github.com/XizhiXu) - 原文:
4 |
5 | 既然现在我们能进入应用界面某个层级，我需要提供一个方法来在层级里向上导航到父亲或祖先界面中。此外，我们应该保证通过 *Back* 按钮来回退历史导航记录。
6 |
7 | > **回退/向上导航设计**
8 |
9 | > 设计指南请阅读 Android 设计文档的[Navigation](http://developer.android.com/design/patterns/navigation.html)模式指导
10 |
11 | ## 支持历史导航：***Back***
12 |
13 | 历史导航，或者说在历史的界面间导航，在 Android 系统中由来已久。不论其他状态如何，所有 Android 用户都期望 *Back* 按钮能带他们回到之前的界面。历史界面集全都以用户的 Launcher 应用为基础（电话的 “Home” 键）。也就是说，按下 *Back* 键足够多次数后你应该回到 Launcher，之后 *Back* 键不做任何事情。
14 |
15 | 
16 |
17 | **Figure 1.** 从 Contacts（联系人）app中进入电子邮件 app 然后按 *Back* 键的行为
18 |
19 | 应用自身通常不必考虑去管理 *Back* 按钮。系统自己自动处理 [*task* 和 *back
20 | H1H2H3H4
21 | stack*（回退栈）](http://developer.android.com/guide/components/tasks-and-back-stack.html)，或者叫历史界面列表。 *Back* 按钮默认反向访问界面列表，然后当按钮被按下时从列表中移除当前界面。
22 |
23 | 但是总是有一些你可能需要重写 *Back* 行为的例子。比如，你屏幕包含一个嵌入的网页浏览器，在这个浏览器中你的用户可和页面元件进行交互来在网页间导航。你可能希望当用户按下设备的 *Back* 键时触发嵌入浏览器的默认 *back* 操作。当到达了浏览器内部历史的起始点，你就应该遵从系统 *Back* 按钮的默认行为了。
24 |
25 | ## 提供向上导航：***Up*** 和 ***Home***
26 |
27 | Android 3.0 之前，最常见的向上导航的形式以 *Home* 表示。大体上是以在设备 *Menu* 按钮里提供一个 *Home* 的可选项这样的方法来实现，或者 *Home* 按钮出现在屏幕的左上角作为 Action Barbar（详见Android 设计的[模式](http://developer.android.com/design/patterns/actionbar.html)章节）的一个组件。当选中 *Home* 后，用户被带到界面层级的顶层，通常被叫做应用的主界面。
28 |
29 | 提供对程序主界面的直接访问能带给用户一种舒适感和安全感。无论位于应用程序何处，如果你在 App 中迷路了，你可以点选 *Home* 然后回到那熟悉的主界面。
30 |
31 | Android 3.0 引入了 *Up* 记号，它被展示在了 Action Bar 上代替了上述的 *Home* 按钮。点击 *Up*，用户将被带入到结构中的父界面。这个导航操作通常就是进入前一个界面（就像之前 *Back* 按钮讨论中描述的一样），但是并不是永远都这样。因此，开发者必须保证 *Up* 对于每个界面都会导航到某个既定的父亲界面。
32 |
33 | 
34 |
35 | **Figure 2.** 从联系人 App 中进入电子邮件 App 然后按 *Up* 导航的行为
36 |
37 | 某些情况下，*Up* 适合执行某个行为而非导航到一个父亲节点。以 Android 3.0 平板上的 Gmail 应用为例。当查看一封邮件的对话时把设备平放，对话列表和对话详情将并排显示。这是一种[之前课程](multiple-sizes.html)中的父、子界面组合。然而，当竖屏查看邮件对话时，只有对话详情被显示。*Up* 按钮被用来使父视窗滑入屏幕显示。当左侧视窗可见时再按一次 *Up* 按钮，单个对话便回到全屏的对话列表中。
38 |
39 | > **实现提醒：** 实现 *Home* 或 *Up* 导航的最佳做法就是保证清除back stack中的子界面。对于 *Home*，Home 界面是唯一留在back stack中的界面。对于 *Up* 导航，当前界面也应该从back stack中移除，除非 *Back* 在不同界面层级间导航。你可以将[ FLAG_ACTIVITY_CLEAR_TOP](http://developer.android.com/reference/android/content/Intent.html#FLAG_ACTIVITY_CLEAR_TOP)和[FLAG_ACTIVITY_NEW_TASK](http://developer.android.com/reference/android/content/Intent.html#FLAG_ACTIVITY_NEW_TASK)这两个 Intent 标记一起使用来实现它。
40 |
41 | 最后一节课中，我们应用现在为止所有课程中讨论的概念来为我们新闻应用例子创建交互设计 Wireframe（线框图）。
42 |
43 | [下节课：综合：设计我们的样例 App](wireframing.md)
44 |
--------------------------------------------------------------------------------
/graphics/displaying-bitmaps/index.md:
--------------------------------------------------------------------------------
1 | # 高效显示Bitmap
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 这一章节会介绍一些处理与加载[Bitmap](http://developer.android.com/reference/android/graphics/Bitmap.html)对象的常用方法，这些技术能够使得程序的UI不会被阻塞，并且可以避免程序超出内存限制。如果我们不注意这些，Bitmaps会迅速的消耗掉可用内存从而导致程序崩溃，出现下面的异常:`java.lang.OutofMemoryError: bitmap size exceeds VM budget.`
6 |
7 | 在Android应用中加载Bitmaps的操作是需要特别小心处理的，有下面几个方面的原因:
8 |
9 | * 移动设备的系统资源有限。Android设备对于单个程序至少需要16MB的内存。[Android Compatibility Definition Document (CDD)](http://source.android.com/compatibility/downloads.html), Section 3.7. Virtual Machine Compatibility 中给出了对于不同大小与密度的屏幕的最低内存需求。 应用应该在这个最低内存限制下去优化程序的效率。当然，大多数设备的都有更高的限制需求。
10 | * Bitmap会消耗很多内存，特别是对于类似照片等内容更加丰富的图片。 例如，[Galaxy Nexus](http://www.android.com/devices/detail/galaxy-nexus)的照相机能够拍摄2592x1936 pixels (5 MB)的图片。 如果bitmap的图像配置是使用[ARGB_8888](http://developer.android.com/reference/android/graphics/Bitmap.Config.html) (从Android 2.3开始的默认配置) ，那么加载这张照片到内存大约需要19MB(`2592*1936*4` bytes) 的空间，从而迅速消耗掉该应用的剩余内存空间。
11 | * Android应用的UI通常会在一次操作中立即加载许多张bitmaps。 例如在[ListView](http://developer.android.com/reference/android/widget/ListView.html), [GridView](http://developer.android.com/reference/android/widget/GridView.html) 与 [ViewPager](http://developer.android.com/reference/android/support/v4/view/ViewPager.html) 等控件中通常会需要一次加载许多张bitmaps，而且需要预先加载一些没有在屏幕上显示的内容，为用户滑动的显示做准备。
12 |
13 | ## 参考资料
14 |
15 | * [DEMO：DisplayingBitmaps.zip](http://developer.android.com/downloads/samples/DisplayingBitmaps.zip)
16 | * [VEDIO：Bitmap Allocation](http://www.youtube.com/watch?v=rsQet4nBVi8)
17 | * [VEDIO：Making App Beautiful - Part 4 - Performance Tuning](http://www.youtube.com/watch?v=pMRnGDR6Cu0)
18 |
19 |
20 | ## 章节课程
21 |
22 | * [**高效的加载大图(Loading Large Bitmaps Efficiently)**](load-bitmap.html)
23 |
24 | 这节课会带领你学习如何解析很大的Bitmaps并且避免超出程序的内存限制。
25 |
26 |
27 | * [**非UI线程处理Bitmap(Processing Bitmaps Off the UI Thread)**](process-bitmap.html)
28 |
29 | 处理Bitmap（裁剪，下载等操作）不能执行在主线程。这节课会带领你学习如何使用AsyncTask在后台线程对Bitmap进行处理，并解释如何处理并发带来的问题。
30 |
31 |
32 | * [**缓存Bitmaps(Caching Bitmaps)**](cache-bitmap.html)
33 |
34 | 这节课会带领你学习如何使用内存与磁盘缓存来提升加载多张Bitmaps时的响应速度与流畅度。
35 |
36 |
37 | * [**管理Bitmap的内存使用(Managing Bitmap Memory)**](manage-memory.html)
38 |
39 | 这节课会介绍如何管理Bitmap的内存占用，以此来提升程序的性能。
40 |
41 |
42 | * [**在UI上显示Bitmap(Displaying Bitmaps in Your UI)**](display-bitmap.html)
43 |
44 | 这节课会综合之前章节的内容，演示如何在诸如[ViewPager](http://developer.android.com/reference/android/support/v4/view/ViewPager.html)与[GridView](http://developer.android.com/reference/android/widget/GridView.html)等控件中使用后台线程与缓存加载多张Bitmaps。
45 |
--------------------------------------------------------------------------------
/wearables/watch-faces/issues.md:
--------------------------------------------------------------------------------
1 | # 定位常见的问题
2 |
3 | > 编写:[heray1990](https://github.com/heray1990) - 原文:
4 |
5 | 创建 Android Wear 的客制化表盘与创建 notification 和可穿戴特有的 activity 的方法不同。这几课介绍如何解决我们在实现第一个表盘时会遇到的一些问题。
6 |
7 | ## 检测屏幕的形状
8 |
9 | 一些 Android Wear 设备的屏幕是方形的，另一些是圆形的。圆形屏幕的设备可以在屏幕的底部包含一个插入部分（或者“下巴”）。我们的表盘应该适应和利用好屏幕特定的形状，如 [设计指南](http://developer.android.com/design/wear/watchfaces.html) 中的描述。
10 |
11 | Android Wear 让表盘在运行时决定屏幕的形状。为了检测屏幕是方形还是圆形，需要像下面的代码一样重写 `CanvasWatchFaceService.Engine` 类的 `onApplyWindowInsets()` 方法：
12 |
13 | ```java
14 | private class Engine extends CanvasWatchFaceService.Engine {
15 | boolean mIsRound;
16 | int mChinSize;
17 |
18 | @Override
19 | public void onApplyWindowInsets(WindowInsets insets) {
20 | super.onApplyWindowInsets(insets);
21 | mIsRound = insets.isRound();
22 | mChinSize = insets.getSystemWindowInsetBottom();
23 | }
24 | ...
25 | }
26 | ```
27 |
28 | 当重新绘制表盘时，检查成员变量 `mIsRound` 和 `mChinSize` 的值来适应我们的设计。
29 |
30 | ## 容纳 Card
31 |
32 | 当用户接收到一个 notification，notification card 可能会遮盖屏幕很大一部分，这取决于[系统 UI 的风格](http://hukai.me/android-training-course-in-chinese/wearables/watch-faces/drawing.html#SystemUI)。表盘应该适应这些情况，确保当 notification card 出现时用户仍然可以看到时间。
33 |
34 | 当 notification card 出现时，模拟表盘需要调整，如缩小表盘使得自身不被 card 覆盖。数字表盘在屏幕显示时间的区域不会被 card 覆盖，通常不需要作出调整。使用 `WatchFaceService.getPeekCardPosition()` 方法确定在 card 上方可用于调整表盘的空间。
35 |
36 | 
37 |
38 | **Figure 1.** 当 notification card 出现时，一些模拟表盘需要调整
39 |
40 | 在环境模式下，card 的背景是透明的。如果我们的表盘在环境模式下，card 的附近包含详细的信息，那么可以考虑在 card 的上面绘制一个黑色方块，确保用户可以读到 card 的内容。
41 |
42 | ## 配置系统指示图标
43 |
44 | 为了确保系统指示图标一直可见，当创建一个 `WatchFaceStyle` 实例时，我们可以将配置系统指示图标在屏幕的位置和决定是否需要背景保护：
45 |
46 | * 使用 `setStatusBarGravity()` 方法设置状态栏的位置。
47 | * 使用 `setHotwordIndicatorGravity()` 方法设置热词的位置。
48 | * 使用 `setViewProtection()` 方法，用一个灰色的半透明背景保护状态栏和热词。由于系统指示图标是白色的，如果我们的表盘背景是明亮的，这样做事很必要的。
49 |
50 | 
51 |
52 | **Figure 2.** 状态栏
53 |
54 | 更多关于系统指示图标的内容，请查看[配置系统 UI](http://hukai.me/android-training-course-in-chinese/wearables/watch-faces/drawing.html#SystemUI) 和 [设计指南](http://developer.android.com/design/wear/watchfaces.html)。
55 |
56 | ## 使用相对尺寸
57 |
58 | 不同厂商的 Android Wear 设备屏幕会有不同的尺寸和分辨率。我们的表盘应该通过使用相对尺寸而不是绝对像素值来适应这些差异。
59 |
60 | 当我们绘制表盘时，用 [Canvas.getWidth()](http://developer.android.com/reference/android/graphics/Canvas.html#getWidth()) 和 [Canvas.getHeight()](http://developer.android.com/reference/android/graphics/Canvas.html#getHeight()) 方法获得画布的尺寸，然后以屏幕尺寸一部分所占比例的值来设置图片的位置。如果重新绘制表盘的组件来响应 card，那么根据屏幕里 card 上方剩下空间所占比例的值来重新绘制表盘。
--------------------------------------------------------------------------------
/connectivity/efficient-downloads/redundant-redundant.md:
--------------------------------------------------------------------------------
1 | # 重复的下载是冗余的
2 |
3 | > 编写:[kesenhoo](https://github.com/kesenhoo) - 原文:
4 |
5 | 减少下载的最基本方法是仅仅下载那些我们需要的。从数据的角度看，我们可以通过传递类似上次更新时间这样的参数来制定查询数据的条件。
6 |
7 | 同样，在下载图片的时候，server 那边最好能够减少图片的大小，而不是让我们下载完整大小的图片。
8 |
9 | ## 缓存文件到本地
10 |
11 | 另一个重要的技术是避免下载重复的数据。可以使用缓存机制来处理这个问题。缓存静态的资源，包括按需下载例如完整的图片（只要合理和兴）。这些缓存的资源需要分开存放，使得我们可以定期地清理这些缓存，从而控制缓存数据的大小。
12 |
13 | 为了保证 app 不会因为缓存而导致显示的是旧数据，请在缓存中获取数据的同时检测其是否过期，当数据过期的时候，会提示进行刷新。
14 |
15 |
16 |
17 | ```java
18 | long currentTime = System.currentTimeMillis();
19 |
20 | HttpURLConnection conn = (HttpURLConnection) url.openConnection();
21 |
22 | long expires = conn.getHeaderFieldDate("Expires", currentTime);
23 | long lastModified = conn.getHeaderFieldDate("Last-Modified", currentTime);
24 |
25 | setDataExpirationDate(expires);
26 |
27 | if (lastModified < lastUpdateTime) {
28 | // Skip update
29 | } else {
30 | // Parse update
31 | }
32 | ```
33 |
34 | 使用这种方法，可以有效保证缓存里面一直是最新的数据。
35 |
36 | 我们可以缓存非敏感数据到非受管的外部缓存目录（目录会是sdcard下面的`Android/data/data/com.xxx.xxx/cache`）：
37 |
38 | ```java
39 | Context.getExternalCacheDir();
40 | ```
41 |
42 | 或者，我们可以使用受管/安全的应用缓存。请注意，当系统的可用存储空间较小时，存放在内存中的数据有可能会被清除（类似:`system/data/data/com.xxx.xxx./cache`）。
43 |
44 | ```java
45 | Context.getCache();
46 | ```
47 |
48 | 缓存在上面两个地方的文件都会在 app 卸载的时候被清除。
49 |
50 | **Ps：请注意这点:发现很多应用总是随便在 sdcard 下面创建一个目录用来存放缓存，可是这些缓存又不会随着程序的卸载而被删除，这其实是不符合规范，程序都被卸载了，为何还要留那么多垃圾文件，而且这些文件有可能会泄漏一些隐私信息。除非你的程序是音乐下载，拍照程序等等，这些确定程序生成的文件是会被用户需要留下的，不然都应该使用上面的那种方式来获取 Cache 目录。**
51 |
52 | ## 使用 HttpURLConnection 响应缓存
53 |
54 | 在 `Android 4.0` 里面为 `HttpURLConnection` 增加了一个响应缓存（这是一个很好的减少 http 请求次数的机制，Android 官方推荐使用 HttpURLConnection 而不是 Apache 的 DefaultHttpClient，就是因为前者不仅仅有针对 android 做 http 请求的优化，还在4.0上增加了 Reponse Cache，这进一步提高了效率)。我们可以使用反射机制开启 HTTP response cache，看下面的例子：
55 |
56 | ```java
57 | private void enableHttpResponseCache() {
58 | try {
59 | long httpCacheSize = 10 * 1024 * 1024; // 10 MiB
60 | File httpCacheDir = new File(getCacheDir(), "http");
61 | Class.forName("android.net.http.HttpResponseCache")
62 | .getMethod("install", File.class, long.class)
63 | .invoke(null, httpCacheDir, httpCacheSize);
64 | } catch (Exception httpResponseCacheNotAvailable) {
65 | Log.d(TAG, "HTTP response cache is unavailable.");
66 | }
67 | }
68 | ```
69 |
70 | 上面的示例代码在 Android 4.0 以上的设备上会开启 response cache，同时不会影响到之前的程序。
71 |
72 | 在cache被开启之后，所有cache中的HTTP请求都可以直接在本地存储中进行响应，并不需要开启一个新的网络连接。被cache起来的response可以被server所确保没有过期，这样就减少了下载所需的带宽。
73 |
74 | 没有被cached的response会为了方便下次请求而被存储在response cache中。
--------------------------------------------------------------------------------
/performance/improving-layouts/smooth-scrolling.md:
--------------------------------------------------------------------------------
1 | # 使得ListView滑动顺畅
2 |
3 | > 编写:[allenlsy](https://github.com/allenlsy) - 原文:
4 |
5 | 保持程序流畅的关键，是让主线程（UI 线程）不要进行大量运算。你要确保在其他线程执行磁盘读写、网络读写或是 SQL 操作等。为了测试你的应用的状态，你可以启用 [StrictMode](http://developer.android.com/reference/android/os/StrictMode.html)。
6 |
7 | ## 使用后台线程
8 |
9 | 你应该把主线程中的耗时间的操作，提取到一个后台线程（也叫做“worker thread工作线程”）中，使得主线程只关注 UI 绘画。很多时候，使用 [AsyncTask](http://developer.android.com/reference/android/os/AsyncTask.html) 是一个简单的在主线程以外进行操作的方法。系统会自动把`execute()`的请求放入队列中并线性调用执行。这个行为是全局的，这意味着你不需要考虑自己定义线程池的事情。
10 |
11 | 在下面的例子中，一个 AsyncTask 被用于在后台线程载入图片，并在载入完成后把图片显示到 UI 上。当图片正在载入时，它还会显示一个进度提示。
12 |
13 | ```java
14 | // Using an AsyncTask to load the slow images in a background thread
15 | new AsyncTask() {
16 | private ViewHolder v;
17 |
18 | @Override
19 | protected Bitmap doInBackground(ViewHolder... params) {
20 | v = params[0];
21 | return mFakeImageLoader.getImage();
22 | }
23 |
24 | @Override
25 | protected void onPostExecute(Bitmap result) {
26 | super.onPostExecute(result);
27 | if (v.position == position) {
28 | // If this item hasn't been recycled already, hide the
29 | // progress and set and show the image
30 | v.progress.setVisibility(View.GONE);
31 | v.icon.setVisibility(View.VISIBLE);
32 | v.icon.setImageBitmap(result);
33 | }
34 | }
35 | }.execute(holder);
36 | ```
37 |
38 | 从 Android 3.0 (API level 11) 开始, AsyncTask 有个新特性，那就是它可以在多个 CPU 核上运行。你可以调用 `executeOnExecutor()`而不是`execute()`，前者可以根据CPU的核心数来触发多个任务同时进行。
39 |
40 | ## 在 ViewHolder 中填入视图对象
41 |
42 | 你的代码可能在 ListView 滑动时经常使用 `findViewById()`，这样会降低性能。即使是 Adapter 返回一个用于回收的 inflate 后的视图，你仍然需要查看这个元素并更新它。避免频繁调用 `findViewById()` 的方法之一，就是使用 ViewHolder（视图占位符）的设计模式。
43 |
44 | 一个 ViewHolder 对象存储了他的标签下的每个视图。这样你不用频繁查找这个元素。第一，你需要创建一个类来存储你会用到的视图。比如：
45 |
46 | ```java
47 | static class ViewHolder {
48 | TextView text;
49 | TextView timestamp;
50 | ImageView icon;
51 | ProgressBar progress;
52 | int position;
53 | }
54 | ```
55 |
56 | 然后，在 Layout 的类中生成一个 ViewHolder 对象：
57 |
58 | ```java
59 | ViewHolder holder = new ViewHolder();
60 | holder.icon = (ImageView) convertView.findViewById(R.id.listitem_image);
61 | holder.text = (TextView) convertView.findViewById(R.id.listitem_text);
62 | holder.timestamp = (TextView) convertView.findViewById(R.id.listitem_timestamp);
63 | holder.progress = (ProgressBar) convertView.findViewById(R.id.progress_spinner);
64 | convertView.setTag(holder);
65 | ```
66 |
67 | 这样你就可以轻松获取每个视图，而不是使用 `findViewById()` 来不断查找子视图，节省了宝贵的运算时间。
68 |
--------------------------------------------------------------------------------