Android开发实践指南：Pro Android 4英文版

需积分: 1 65 浏览量更新于2024-07-26 收藏 27.45MB PDF 举报

"Pro Android 4 pdf English" 本书籍为 Android 开发指南，旨在指导开发者学习 Android 开发技术。该书籍共分为 17 章节，涵盖了 Android 开发的方方面面。 **Chapter 1: Introducing the Android Computing Platform** 本章节对 Android 计算平台进行了概述，介绍了 Android 的历史、架构、特点等基本知识点。知识点： * Android 的历史发展 * Android 架构的组成部分 * Android 的特点和优势 **Chapter 2: Setting Up Your Development Environment** 本章节介绍了如何设置 Android 开发环境，包括安装 Android SDK、配置 Eclipse 等开发工具。知识点： * 安装 Android SDK 的步骤 * 配置 Eclipse 开发环境 * Android 开发环境的组成部分 **Chapter 3: Understanding Android Resources** 本章节介绍了 Android 资源的概念，包括资源类型、资源加载、资源使用等知识点。知识点： * Android 资源的类型 * 资源加载机制 * 资源使用的最佳实践 **Chapter 4: Understanding Content Providers** 本章节介绍了 Android 内容提供者的概念，包括内容提供者的类型、使用方法等知识点。知识点： * 内容提供者的类型 * 内容提供者的使用方法 * 内容提供者的优点和缺点 **Chapter 5: Understanding Intents** 本章节介绍了 Android 意图的概念，包括意图的类型、使用方法等知识点。知识点： * 意图的类型 * 意图的使用方法 * 意图的优点和缺点 **Chapter 6: Building User Interfaces and Using Controls** 本章节介绍了 Android 用户界面设计的基本知识点，包括界面设计原则、控件使用等。知识点： * 用户界面设计的原则 * 控件的类型和使用 * 界面设计的最佳实践 **Chapter 7: Working with Menus** 本章节介绍了 Android 菜单的概念，包括菜单的类型、使用方法等知识点。知识点： * 菜单的类型 * 菜单的使用方法 * 菜单的优点和缺点 **Chapter 8: Fragments for Tablets and More** 本章节介绍了 Android 碎片的概念，包括碎片的类型、使用方法等知识点。知识点： * 碎片的类型 * 碎片的使用方法 * 碎片的优点和缺点 **Chapter 9: Working with Dialogs** 本章节介绍了 Android 对话框的概念，包括对话框的类型、使用方法等知识点。知识点： * 对话框的类型 * 对话框的使用方法 * 对话框的优点和缺点 **Chapter 10: Exploring ActionBar** 本章节介绍了 Android 动作栏的概念，包括动作栏的类型、使用方法等知识点。知识点： * 动作栏的类型 * 动作栏的使用方法 * 动作栏的优点和缺点 **Chapter 11: Advanced Debugging and Analysis** 本章节介绍了 Android 调试和分析的基本知识点，包括调试工具、分析方法等。知识点： * 调试工具的使用 * 分析方法的选择 * 调试和分析的最佳实践 **Chapter 12: Responding to Configuration Changes** 本章节介绍了 Android 配置更改响应的基本知识点，包括配置更改的类型、响应方法等。知识点： * 配置更改的类型 * 响应配置更改的方法 * 配置更改响应的优点和缺点 **Chapter 13: Working with Preferences and Saving State** 本章节介绍了 Android 首选项和状态保存的基本知识点，包括首选项的类型、状态保存方法等。知识点： * 首选项的类型 * 状态保存方法 * 首选项和状态保存的优点和缺点 **Chapter 14: Exploring Security and Permissions** 本章节介绍了 Android 安全性和权限的基本知识点，包括安全机制、权限类型等。知识点： * 安全机制的类型 * 权限类型 * 安全和权限的优点和缺点 **Chapter 15: Building and Consuming Services** 本章节介绍了 Android 服务的概念，包括服务的类型、使用方法等知识点。知识点： * 服务的类型 * 服务的使用方法 * 服务的优点和缺点 **Chapter 16: Exploring Packages** 本章节介绍了 Android 包的概念，包括包的类型、使用方法等知识点。知识点： * 包的类型 * 包的使用方法 * 包的优点和缺点 **Chapter 17: Exploring Handlers** 本章节介绍了 Android 处理器的概念，包括处理器的类型、使用方法等知识点。知识点： * 处理器的类型 * 处理器的使用方法 * 处理器的优点和缺点

CHAPTER 1: Introducing the Android Computing Platform

loaded as XML files and because resource IDs for those menus are auto-generated.

Here’s how you would declare menus in an XML file:

<item android:id="@+id/menu_clear"

android:orderInCategory="10"

android:title="clear" />

<item android:id="@+id/menu_show_browser"

android:orderInCategory="5"

android:title="show browser" />

</group>

</menu>

Android supports dialogs, and all dialogs in Android are asynchronous. These

asynchronous dialogs present a special challenge to developers accustomed to the

synchronous modal dialogs in some windowing frameworks. We’ll address menus in

Chapter 7 and dialogs in Chapter 9.

Android offers extensive support for animation. There are three fundamental ways to

accomplish animation. You can do frame-by-frame animation. Or you can provide

tweening animation by changing view transformation matrices (position, scale, rotation,

and alpha). Or you can also do tweening animation by changing properties of objects.

The property-based animation is introduced in 3.0 and is the most flexible and

recommended way to accomplish animation. All of these animations are covered in

Chapter 21.

Moreover, Android allows you to define these animations in an XML resource file. Check

out this example, in which a series of numbered images is played in frame-by-frame

animation:

<animation-list xmlns:android="http://schemas.android.com/apk/res/android"

android:oneshot="false">

……

</animation-list>

Android also supports 3D graphics through its implementation of the OpenGL ES 1.0

and 2.0 standards. OpenGL ES, like OpenGL, is a C-based flat API. The Android SDK,

because it’s a Java-based programming API, needs to use Java binding to access the

OpenGL ES. Java ME has already defined this binding through Java Specification

Request (JSR) 239 for OpenGL ES, and Android uses the same Java binding for

OpenGL ES in its implementation. If you are not familiar with OpenGL programming, the

learning curve is steep. Due to space limitations, we are not able to include the OpenGL

coverage in the fourth edition of the book. However we have over 100 pages of

coverage in our third edition.

Android has a number of new concepts that revolve around information at your fingertips

using the home screen. The first of these is live folders. Using live folders, you can

publish a collection of items as a folder on the homepage. The contents of this collection

change as the underlying data changes. This changing data could be either on the

CHAPTER 1: Introducing the Android Computing Platform

device or from the Internet. Due to space limitations, we are not able to cover live folders

in the fourth edition of the book. However, the third edition includes extensive coverage.

The second homepage-based idea is the home screen widget. Home screen widgets are

used to paint information on the homepage using a UI widget. This information can

change at regular intervals. An example could be the number of e-mail messages in your

e-mail store. We describe home screen widgets in Chapter 25. The home screen

widgets are enhanced in 3.0 to include list views that can get updated when their

underlying data changes. These enhancements are covered in Chapter 26.

Integrated Android Search is the third homepage-based idea. Using integrated search,

you can search for content both on the device and also across the Internet. Android

search goes beyond search and allows you to fire off commands through the search

control. Due to space limitations, we can’t include coverage of the search API in the

fourth edition of the book. However, it is covered in the third edition.

Android also supports touchscreen and gestures based on finger movements on the

device. Android allows you to record any random motion on the screen as a named

gesture. This gesture can then be used by applications to indicate specific actions. We

cover touchscreens and gestures in Chapter 27.

Sensors are now becoming a significant part of the mobile experience. We cover

sensors in Chapter 29.

Another necessary innovation required for a mobile device is the dynamic nature of its

configurations. For instance, it is very easy to change the viewing mode of a handheld

between portrait and landscape. Or you may dock your handheld to become a laptop.

Android 3.0 has introduced a concept called fragments to deal with these variations

effectively. Chapter 8 is dedicated to fragments, and Chapter 12 talks about how to deal

with configuration changes.

We also cover the 3.0 feature (which is much enhanced in 4.0) of action bars in Chapter 10.

Action bars bring Android up to par with a desktop menu bar paradigm.

Drag-and-drop is introduced for tablets in 3.0. This feature is now available to phones as

well. We cover drag-and-drop in Chapter 28.

Handheld devices are fully aware of a cloud-based environment. To make server-side

HTTP calls, it is important to understand the threading model to avoid Application Not

Responding messages. We cover the mechanisms available for asynchronous

processing in Chapter 18.

Outside of the Android SDK, there are a number of independent innovations taking place

to make development exciting and easy. Some examples are XML/VM, PhoneGap, and

Titanium. Titanium allows you to use HTML technologies to program the WebKit-based

Android browser. We covered Titanium in the second edition of this book. However, due

to time and space limitations, we are not covering Titanium in this edition.

CHAPTER 1: Introducing the Android Computing Platform

Android Service Components

Security is a fundamental part of the Android platform. In Android, security spans all

phases of the application life cycle—from design-time policy considerations to runtime

boundary checks. We cover security and permissions in Chapter 14.

In Chapter 15, we’ll show you how to build and consume services in Android,

specifically HTTP services. This chapter will also cover interprocess communication

(communication between applications on the same device).

Location-based service is another of the more exciting components of the Android SDK.

This portion of the SDK provides application developers with APIs to display and

manipulate maps, as well as obtain real-time device-location information. We’ll cover

these ideas in detail in Chapter 22.

Android Media and Telephony Components

Android has APIs that cover audio, video, and telephony components. Chapter 23 will

address the telephony API. We’ll cover the audio and video APIs extensively in

Chapter 24.

Starting with Android 2.0, Android includes the Pico Text-to-Speech engine. Due to

space limitations, we are not able to include Text-to-Speech coverage in the fourth

edition of the book. The third edition does cover the Text-to-Speech API.

Last but not least, Android ties all these concepts into an application by creating a single

XML file that defines what an application package is. This file is called the application’s

manifest file (AndroidManifest.xml). Here is an example:

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

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

package="com.ai.android.HelloWorld"

android:versionCode="1"

android:versionName="1.0.0">

<activity android:name=".HelloWorld"

android:label="@string/app_name">

<intent-filter>

</intent-filter>

</activity>

</application>

</manifest>

The Android manifest file is where activities are defined, where services and content

providers are registered, and where permissions are declared. Details about the

manifest file will emerge throughout the book as we develop each idea.

CHAPTER 1: Introducing the Android Computing Platform

Android Java Packages

One way to get a quick snapshot of the Android platform is to look at the structure of

Java packages. Because Android deviates from the standard JDK distribution, it is

important to know what is supported and what is not. Here’s a brief description of the

important packages that are included in the Android SDK:

android.app: Implements the Application model for Android. Primary

classes include Application, representing the start and stop

semantics, as well as a number of activity-related classes, fragments,

controls, dialogs, alerts, and notifications. We work with most of these

classes through out this book.

android.app.admin: Provides the ability to control the device by folks

such as enterprise administrators.

android.accounts: Provides classes to manage accounts such as

Google, Facebook, and so on. The primary classes are

AccountManager and Account. We cover this API briefly in Chapter 30

when we discuss the Contacts API.

android.animation: Hosts all the new property animation classes.

These clases are extensively covered in Chapter 21.

android.app.backup: Provides hooks for applications to back up and

restore their data when folks switch their devices.

android.appwidget: Provides functionality for home screen widgets.

This package is covered extensively in Chapter 25 and Chapter 26

when we talk about home screen widgets, including list-based

widgets.

android.bluetooth: Provides a number of classes to work with

Bluetooth functionality. The main classes include BluetoothAdapter,

BluetoothDevice, BluetoothSocket, BluetoothServerSocket, and

BluetoothClass. You can use BluetoothAdapter to control the locally

installed Bluetooth adapter. For example, you can enable it, disable it,

and start the discovery process. BluetoothDevice represents the

remote Bluetooth device that you are connecting with. The two

Bluetooth sockets are used to establish communication between the

devices. A Bluetooth class represents the type of Bluetooth device you

are connecting to.

android.content: Implements the concepts of content providers.

Content providers abstract out data access from data stores. This

package also implements the central ideas around intents and Android

Uniform Resource Identifiers (URIs). These classes are covered in

Chapter 4.

CHAPTER 1: Introducing the Android Computing Platform

android.content.pm: Implements package manager–related classes. A

package manager knows about permissions, installed packages,

installed providers, installed services, installed components such as

activities, and installed applications.

android.content.res: Provides access to resource files, both

structured and unstructured. The primary classes are AssetManager

(for unstructured resources) and Resources. Some of the classes from

this package are covered in Chapter 3.

android.database: Implements the idea of an abstract database. The

primary interface is the Cursor interface. Some of the classes from this

package are covered in Chapter 4.

android.database.sqlite: Implements the concepts from the

android.database package using SQLite as the physical database.

Primary classes are SQLiteCursor, SQLiteDatabase, SQLiteQuery,

SQLiteQueryBuilder, and SQLiteStatement. However, most of your

interaction is going to be with classes from the abstract

android.database package.

android.drm: Classes related to Digital Rights Management.

android.gesture: Houses all the classes and interfaces necessary to

work with user-defined gestures. Primary classes are Gesture,

GestureLibrary, GestureOverlayView, GestureStore, GestureStroke,

and GesturePoint. A Gesture is a collection of GestureStrokes and

GesturePoints. Gestures are collected in a GestureLibrary. Gesture

libraries are stored in a GestureStore. Gestures are named so that they

can be identified as actions. Some of the classes from this package

are covered in Chapter 27.

android.graphics: Contains the classes Bitmap, Canvas, Camera, Color,

Matrix, Movie, Paint, Path, Rasterizer, Shader, SweepGradient, and

TypeFace.

android.graphics.drawable: Implements drawing protocols and

background images, and allows animation of drawable objects.

android.graphics.drawable.shapes: Implements shapes including

ArcShape, OvalShape, PathShape, RectShape, and RoundRectShape.

android.hardware: Implements the physical Camera-related classes.

The Camera represents the hardware camera, whereas

android.graphics.Camera represents a graphical concept that’s not

to a physical camera at all.

android.hardware.usb: Lets you talk to USB devices from Android.

剩余1007页未读，继续阅读

minili

粉丝: 2

Android开发实践指南：Pro Android 4英文版

Pro Android 2.0 English Version

Android NDK Game Development Cookbook 无水印pdf 0分

OpenCV Android Programming By Example 无水印pdf 0分

flex and bison english pdf

样例输入: 样例输出: 1 2 3 4 5 4 English Math Chinese Chinese 1 2 3 4 3 Chinese 2 English 1 Math 1

python读取英文pdf翻译成中文pdf文件导出代码

3d math primer for graphics and game development (english edition) pdf

i want to practice my English

Android studio汉化

最新资源