androiduseslibrary

㈠ android移动学习系统有没有基础结点模型

http://www.eoeandroid.com/forum.php?mod=viewthread&tid=275199
目录
一、AndroidManifest.xml整体结构

二、各个节点详细介绍

1、<manifest>属性

2、应用程序运行环境相关

系统版本

<uses-sdk>

系统软硬件环境

<uses-feature>

<uses-configuration>

3、屏幕尺寸相关

<supports-screens>

<compatible-screens>

4、权限相关

<uses-permission>

<permission>

<permission-group>

<permission-tree>

5、测试标签属性

<instrumentation>

6、系统标签

<protected-broadcast>

<package-verifier>

<original-package>

7、<application>属性

<activity>

<activity-alias>

<meta-data>

<provider>

<grant-uri-permission>

<path-permission>

<receiver>

<service>

<uses-library>

<intent-filter>

<action>

<category>

<data>

一、AndroidManifest.xml整体结构
[mw_shl_code=java,true]
<manifest>
<uses-permission />
<permission />
<permission-tree />
<permission-group />
<instrumentation />
<uses-sdk />
<uses-configuration />
<uses-feature />
<supports-screens />
<compatible-screens />
<supports-gl-texture />
<application>
<activity>
<intent-filter>
<action />
<category />
<data />
</intent-filter>
<meta-data />
</activity>
<activity-alias>
<intent-filter> . . . </intent-filter>
<meta-data />
</activity-alias>
<service>
<intent-filter> . . . </intent-filter>
<meta-data/>
</service>
<receiver>
<intent-filter> . . . </intent-filter>
<meta-data />
</receiver>
<provider>
<grant-uri-permission />
<meta-data />
<path-permission />
</provider>
<uses-library />
</application>
</manifest>
[/mw_shl_code]

二、各个节点详细介绍
1、<manifest>属性
<manifest xmlns:android=http://schemas.android.com/apk/res/android
package="string"
android:sharedUserId="string"
android:sharedUserLabel="string resource"
android:versionCode="integer"
android:versionName="string"
android:installLocation=["auto"|"internalOnly"|"preferExternal"]>
...
</manifest>

说明：
这个元素是AndroidManifest.xml文件的根元素。它必须包含一个<application>元素，并且必须要指定xmlns:android和package属性。

属性：
xmlns:android：定义android的命名空间。

package：一个完整的java语言风格的应用程序包的名称，这个必须是唯一的，名字可以包含大小写字母、数字和下划线 ('_')，但只能以字母开头。

android:sharedUserId：这个属性定义了一个Linux 用户ID的名称，这个名称能够跟其他应用程序共享。默认情况下，Android会给它的每个应用程序都分配一个唯一的用户ID。但是，如果有两个或更多的应用程序把这个属性都设置了相同的值，那么它们将共享这个相同的ID---假如并且它们具有相同的数字签名。拥有相同用户ID的应用程序能够访问彼此的数据，并且它们也可运行在相同的进程中。

android:sharedUserLabel：（API Level 3）这个属性给共享的userid定义了一个用户可读的标签。这个标签必须用字符串资源来设置，不能使用原生的字符串。只有在sharedUserId属性被设置，这个属性才有意义。

android:versionCode：apk版本号，值为数字，用于版本判断，对用户不可见。
android:versionName：apk当前版本的名称，对用户可见，由三部分组成：<major>.<minor>.<point>，如：3.4.4。
android:installLocation：（API Level 8）apk安装位置，apk可以安装在内部存储上或外部存储上。

auto

系统自己判断安装位置，安装位置不定，优先安装在内部存储上，用户可以移动安装位置；

internalOnly

（默认值）强行安装在内部存储上，当内部存储空间不足时，系统将不会安装该应用。用户不能移动安装位置。

preferExternal

应用程序偏好安装在外部存储器 上（SD卡）。系统并不保证恪守这一个规则。如果外部存储器不可用或空间不足，或者应用程序使用了forward-locking机制（这种机制不支持外 部存储），那么应用程序就可以安装在内部存储器上。一旦安装，用户能够通过系统设置在内外存储器之间移动应用程序。

警告：如果应用程序使用的Google Play的复制保护功能，那么它就不能被安装在设备的SD卡上。但是，如果使用Google Play的应用程序许可，那么它就能够被安装在内部或外部存储器上，包括SD卡。
注意：默认情况下，应用程序会被安装在内部存储器上，除非把这个属性值定义为auto或preferExternal，应用程序才能够被安装在外部存储器上。
当应用程序被安装在外部存储器上的时候：
1. .apk文件被保存在外部存储器上，但是任何应用程序数据（如数据库）依然被保存在内部设备存储器上；
2. 用一个key把存储器中保存的.apk文件加密，只允许应用程序在安装它的设备上运行。用户不能把安装在SD卡上应用程序转移到另一个设备的SD卡上，虽然在一个设备上能够使用多个SD卡；
3. 在用户要求的时候，应用程序能够被转移到内部存储器上。用户也可以要求把应用程序从内部存储器移动到外部存储器上。但是，如果这个属性被设置为internalOnly，那么系统不允许用户把应用程序转移到外部存储器上。

2、应用程序运行环境相关

系统版本
<uses-sdk>
<uses-sdk
android:minSdkVersion="integer"
android:targetSdkVersion="integer"
android:maxSdkVersion="integer" />

被包含于：
<manifest>

说明：
这个元素用API 的级别（一个整数）来说明应用程序会跟哪些Android平台版本兼容。由应用程序给出的API级别会跟给定不同的设备中的Android系统的API级别比较。

属性：
android:minSdkVersion：程序运行的最小API版本，如果Android系统的API级别比该应用程序清单中的这个属性值小，那么系统就阻止安装该应用程序。如果不指定该属性，默认最小API版本为1，即兼容所有版本。

android:targetSdkVersion：（APILevel 4）程序的目标版本，即应用测试时所针对的目标平台版本。当程序运行在比该版本高的平台上时，系统将以兼容模式来运行程序以确保程序能够正常运行。不指定该属性时，该值与minSdkVersion相同。

android:maxSdkVersion：（API Level 4）不建议设定该值，指定程序能运行的最高版本，当当前系统版本比该值高时，该程序将不能安装，如果系统升级后的版本号高于该值时，该程序将被删除。从Android 2.0.1以后系统在安装程序或系统升级的时候将不再检测和使用该属性。但Google Play在把应用程序展示给用户下载的时候，会继续使用这个属性作为过滤条件。

系统软硬件环境
<uses-feature>
<uses-feature
android:name="string"
android:required=["true" | "false"]
android:glEsVersion="integer" />

被包含于：
<manifest>
不谢 望采纳

㈡ Android初学者提问AndroidManifest文件问题

<?xml version="1.0" encoding="utf-8"?>
<manifest>
<!-- 基本配置 -->
<uses-permission />
<permission />
<permission-tree />
<permission-group />
<instrumentation />
<uses-sdk />
<uses-configuration />
<uses-feature />
<supports-screens />
<compatible-screens />
<supports-gl-texture />

<!-- 应用配置 -->
<application>

<!-- Activity 配置 -->
<activity>
<intent-filter>
<action />
<category />
<data />
</intent-filter>
<meta-data />
</activity>

<activity-alias>
<intent-filter> . . . </intent-filter>
<meta-data />
</activity-alias>

<!-- Service 配置 -->
<service>
<intent-filter> . . . </intent-filter>
<meta-data/>
</service>

<!-- Receiver 配置 -->
<receiver>
<intent-filter> . . . </intent-filter>
<meta-data />
</receiver>

<!-- Provider 配置 -->
<provider>
<grant-uri-permission />
<meta-data />
</provider>

<!-- 所需类库配置 -->
<uses-library />
</application>
</manifest>

㈢ Eclipse 配置好android开发环境，一直用的好好的，今天突然报错

Add following code to AndroidManifest.
<instrumentation android:name="android.test.InstrumentationTestRunner"
android:targetPackage="your.package"
android:label="your tests label" />
<uses-library android:name="android.test.runner" />

- Right click project on Project Explorer Panel on Eclipse, then click "Run" > "Run Configurations...", then select "android.test.InstrumentationTestRunner" in Instrumentation TestRunner.

㈣ Android 怎么自定义共享库

在源码根目录下有个 vendor (供应商) 目录，专门用于存放各个供应商的会有代码。其中有一个个 sample 目录，这是 Google 用于示范如何编写自定义共享库的示例，它展示了自定义共享库、JNI 调用、对库的使用方法及皮肤定制等功能。下面我们通过对该示例进行分析，让大家熟悉这个轻量级的框架。


1、首先看一下 sample 目录的结构：

sample
├── Android.mk
├── apps
│ ├── Android.mk
│ ├── client
│ └── upgrade
├── frameworks
│ ├── Android.mk
│ └── PlatformLibrary
├── MODULE_LICENSE_APACHE2
├── procts
│ ├── AndroidProcts.mk
│ └── sample_addon.mk
├── README.txt
├── sdk_addon
│ ├── hardware.ini
│ └── manifest.ini
└── skins
└── WVGAMedDpi

Android.mk： 该文件用于编写构建规则，默认继承 Android 的 make 框架。
frameworks： 该目录在这里的意义等同于 Android 源码中的 frameworks 。
PlatformLibrary： 该目录就自定义共享库。

apps： 该目录用于编写依赖该库的应用程序。经过测试也可以用来编写不依赖该库的程序，这有个好处，让开发商可以把自己特有的应用集成到框架中。
client 与 upgrade： 这是两个依赖该库的应用程序示例。
procts： 该目录中的文件对包含该库与 Android 框架集成的信息，如模块名称等。
AndroidProcts.mk： 指明该模块的 make 配置文件的在哪里。
sample_addon.mk ：模块的配置信息。

sdk_addon： 该目录对该库的硬件需求进行定义。
hardware.ini： 定义模块对硬件的需求。
manifest.ini： 模块的说明文件。名称、供应商等。
skins： 该目录用于存放自定义皮肤。
WVGAMedDpi： 已经定义好的一套皮肤。

2.如何封装 Java 共享库？

PlatformLibrary 为我们展示了封装 Java 共享库的方法。其目录结构如下： frameworks/PlatformLibrary
├── Android.mk
├── com.example.android.platform_library.xml
├── java
│ └── com
│ └── example
│ └── android
│ └── platform_library
│ └── PlatformLibrary.java
└── README.txt

Android.mk： 该文件说明如何构建该模块。
com.example.android.platform_library.xml： 该文件是模块注册时需要的文件。该文件需要被放置到 /system/etc/permissions 目录下。
Java /*： Java 源码所在目录。具体步骤：

a、编写 Java 库，并将源码放到 java 目录下。这一步和编写普通 Java 程序没有差别。
b、编写 Android.mk，内容如下：

# 获得当前目录，清空环境变量
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS) # 源码所在目录，all-subdir-java-files 表示所有了目录中的 Java 文件。
LOCAL_SRC_FILES := \
$(call all-subdir-java-files) # 该模块是可选的。
LOCAL_MODULE_TAGS := optional # Java 模块名称
LOCAL_MODULE:= com.example.android.platform_library # 编译为 Java 库。最近以 jar 的形式而不是 apk 的形式存在。
include $(BUILD_JAVA_LIBRARY) # 构建该库的 API 文档
include $(CLEAR_VARS)
LOCAL_SRC_FILES := $(call all-subdir-java-files) $(call all-subdir-html-files)
LOCAL_MODULE:= platform_library

# 文档对应的库
LOCAL_DROIDDOC_OPTIONS := com.example.android.platform_library

# 库的类型
LOCAL_MODULE_CLASS := JAVA_LIBRARIES
LOCAL_DROIDDOC_USE_STANDARD_DOCLET := true # 编译为 Java API。
include $(BUILD_DROIDDOC)

c、编写 com.example.android.platform_library.xml，内容如下：
< xml version="1.0" encoding="utf-8" >
<permissions>
<!-- 库的名称及对应的 Jar 文件位置 -->
<library name="com.example.android.platform_library"
file="/system/framework/com.example.android.platform_library.jar"/>
</permissions> 现在基本的库我们已经编写完成，现在需要对框架中的其它文件进行配置。
d、编写 sample/frameworks/Android.mk, 内容如下：

# 包含子目录中的所有 make 文件 include $(call all-subdir-makefiles) 该文件与 sample/Android.mk 文件相同。
e、编写 sample/sdk_addon/manifest.ini，内容如下： # 该模块的名称、供应商及描述
name=Sample Add-On
vendor=Android Open Source Project
description=sample add-on # 构建该模块的 Android 平台代号
api=3 # 模块的版本号。必须为整数。
revision=1 # 该模块中包括的共享库列表
libraries=com.example.android.platform_library # 对每个库的详细定义，格式如下:
# <library.name>=<name>.jar;<desc> # <library.name>: 通过前面 libraies 定义的库的名称。
# <name>.jar: 包含库 API 的 jar 文件。该文件放在 libs/add-on 下面。
com.example.android.platform_library=platform_library.jar;Sample optional plaform library 该文件还可包括该模块的其它定义，如皮肤等，为了保持该文档清晰易懂的初衷，这里不做介绍，需要了解可以给我邮件。
f、编写 sample/procts/sample_addom.mk，内容如下：

# 要植入系统镜像的应用及可选类库。可以包括 Java 库和本地库。这里我们只有 Java 库。
PRODUCT_PACKAGES := \ com.example.android.platform_library # 把 xml 文件复制到系统镜像中相应的位置去。
PRODUCT_COPY_FILES := \ vendor/
sample/frameworks/PlatformLibrary/com.example.android.platform_library.xml:system/etc/permissions/
com.example.android.platform_library.xml # 这个扩展的名称
PRODUCT_SDK_ADDON_NAME := platform_library # 把模块的 manifest 和硬件配置文件复制到系统镜像中相应的位置。 PRODUCT_SDK_ADDON_COPY_FILES := \
vendor/sample/sdk_addon/manifest.ini:manifest.ini \
vendor/sample/sdk_addon/hardware.ini:hardware.in # 把库的 Jar 包复制到相应的位置。 PRODUCT_SDK_ADDON_COPY_MODULES := \
com.example.android.platform_library:libs/platform_library.jar # 文档的名称。必须与。
# LOCAL_MODULE:= platform_library
PRODUCT_SDK_ADDON_DOC_MODULE := platform_library # 这个扩展继承系统扩展。 $(call inherit-proct, $(SRC_TARGET_DIR)/proct/sdk.mk) # 这个扩展的真实名字。这个名字会用于编译。
# 用 'make PRODUCT-<PRODUCT_NAME>-sdk_addon' 的形式来编译此扩展。
PRODUCT_NAME := sample_addon

g、编写 sample/procts/AndroidProcts.mk，内容如下：
PRODUCT_MAKEFILES := \
$(LOCAL_DIR)/sample_addon.mk h、最后运行make -j8 PRODUCT-sample_addon-sdk_addon，编译扩展。
至此，我们就完成了 Java 库的封装。

3、接下来我们再来看如何通过 JNI 的方式对 C 代码进行封装。

a、在 sample/frameworks/PlatformLibrary 目录下添加一个文件夹，用于放置 JNI 本地代码，目录结构如下：

frameworks/PlatformLibrary/jni
├── Android.mk
└── PlatformLibrary.cpp

b、把 frameworks/PlatformLibrary/java/com/example/android/platform_library/PlatformLibrary.java
文件改写为 JIN 调用接口，代码如下 ： package com.example.android.platform_library; import android.util.Config;
import android.util.Log; public final class PlatformLibrary {
static { / Load the library. If it's already loaded, this does nothing. System.loadLibrary("platform_library_jni");
private int mJniInt = -1; public PlatformLibrary() {} / Test native methods. public int getInt(boolean bad) {
// this alters mJniInt //
int result = getJniInt(bad); // reverse a string, for no very good reason //
String reverse = reverseString("Android!"); Log.i("PlatformLibrary", "getInt: " + result + ", '" + reverse + "'"); return mJniInt; //
/ Simple method, called from native code. private static void yodel(String msg) {
Log.d("PlatformLibrary", "yodel: " + msg); //
/ Trivial native method call. If "bad" is true, this will throw an
/ exception. native private int getJniInt(boolean bad); / Native method that returns a new string that is the reverse of
/ the original. This also calls yodel(). native private static String reverseString(String str);
}

c、在 frameworks/PlatformLibrary/jni/PlatformLibrary.cpp 中编写 PlatformLibrary.java 中规定本地调用的具体实现。
d、编写 frameworks/PlatformLibrary/jni/Android.mk，内容如下：

LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS) LOCAL_MODULE_TAGS := optional # JNI 模块的名称
LOCAL_MODULE:= libplatform_library_jni # 依赖的源代码文件
LOCAL_SRC_FILES:= \
PlatformLibrary.cpp # 编译时需要的库
LOCAL_SHARED_LIBRARIES := \
libandroid_runtime \
libnativehelper \
libcutils \
libutils # 没有静态库
LOCAL_STATIC_LIBRARIES := # 包含必须的 JNI 头文件
LOCAL_C_INCLUDES += \
$(JNI_H_INCLUDE) # 编译器选项
LOCAL_CFLAGS += # 对该模块不进行预编译。使用预编译可以提高模块的性能。
LOCAL_PRELINK_MODULE := false # 把它编译成动态共享库
include $(BUILD_SHARED_LIBRARY) 该文件主要定义了本地库的名字、依赖、编译选项及编译方式。
e、修改 frameworks/PlatformLibrary/Android.mk，在末尾添加如下两行：

include $(CLEAR_VARS) # 调用子目录中的 make 文件。
include $(call all-makefiles-under,$(LOCAL_PATH))

f、修改 sdk_addon/sample_addon.mk，在PRODUCT_PACKAGES 中添加该 JNI 本地库。

PRODUCT_PACKAGES := \
com.example.android.platform_library \
libplatform_library_jni

g、编译即可。至此，添加 JNI 库完毕。

4、添加接下来我们再看看如何添加原生应用程序

添加原生应用程序就很简单了，只需要把按照 Android 应用开发的基本方法，写好一个应用，该应用可以依赖这个扩展，也可以不依赖。如 sample 中的 client 应用，目录结构如下： apps/client/
├── AndroidManifest.xml
├── Android.mk
└── src
└── com
└── example
└── android
└── platform_library
└── client
└── Client.java

a、在应用根目录中添加一个 Android.mk 文件，内容如下：

LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS) LOCAL_MODULE_TAGS := user # 目标名称
LOCAL_PACKAGE_NAME := PlatformLibraryClient # 只编译这个apk包中的java文件
LOCAL_SRC_FILES := $(call all-java-files-under, src) # 使用当前版本的 SDK

LOCAL_SDK_VERSION := current # 依赖使用刚才编写的扩展
LOCAL_JAVA_LIBRARIES := com.example.android.platform_library include $(BUILD_PACKAGE)

b、在 AndroidManifest.xml 中添加一句：
<uses-library android:name="com.example.android.platform_library" />

c、修改 sdk_addon/sample_addon.mk，在PRODUCT_PACKAGES 中添加该 JNI 本地库。

PRODUCT_PACKAGES := \
com.example.android.platform_library \
libplatform_library_jni \
PlatformLibraryClient

d、编译即可。至此，添加 JNI 库完毕。

5、其他功能如添加皮肤等，这里就不一一示范了，请参考<sdk-src>/vendor/sample。

㈤ Android中什么时候需要在AndroidManifest.xml中添加声明

在AndroidManifest.xml中可以：
1.添加权限声明。比如要用到网络，添加<uses-permission android:name="android.permission.INTERNET"></uses-permission>；
2.添加新的Activity。比如增加的Home.java类，继承Activity,添加<activity android:name="Home" android:configChanges="orientation|keyboardHidden|navigation" />
3.为额外的库添加声明。比如要用到Google Map的时候，不是Android内部包，引入包后，添加<uses-library android:name="com.google.android.maps"/>
4.程序运行的最低版本声明。添加<uses-sdk android:minSdkVersion="3"></uses-sdk>
5.为自己的后台Service声明。添加<service
android:name=".MyService"
android:exported="true"
android:process=":remote" >
</service>
6.其它情况，比如加入Admob广告：添加<meta-data android:value="yourID" android:name="ADMOB_PUBLISHER_ID"/>;
广播事件：<receiver android:name="HippoCustomIntentReceiver" >
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
<action android:name="HIPPO_ON_SERVICE_001" />
<category android:name="android.intent.category.HOME" />
</intent-filter>
</receiver>
还有就是修改程序ICON的时候，可以这里面修改<application android:icon="@drawable/icon" android:label="@string/app_name">

㈥ 如何将一个android library打包成一个可用文件

第一步，把普通的android project设置成库项目
库项目也是一个标准的android项目，因此你先创建一个普通的android项目。 这个项目可以起任何的名称，任何的报名，设置其他需要设置的字段等，如图1所示。
接着把项目设置成库项目，步骤如下
在Package Explorer中, 鼠标右键项目文件夹，点击 Properties.
在Properties 窗口, 选择"Android" ，Library 属性显示在右下边.
把"is Library" 单选框选择上，再点击 Apply.
点击 OK 关闭Properties 窗口.
这时，这个项目就变成库项目了。
当然，java项目也可以让其变成一个库项目，非常简单，执行上面的四步。其他程序项目就可以引用库项目了。
图 1.使一个项目为库项目
创建manifest文件
一个库项目的manifest文件也和标准的android应用程序一样，声明所有共享的组件。
比如APIDemo中的TicTacToeLib 这个例子，库项目声明了Activity GameActivity:
<manifest>
...
<application>
...
<activity android:name="GameActivity" />
...
</application>
</manifest>

第二步 引用库项目
如果你开发的应用程序想要包括库项目中的代码和资源，非常简单，引用步骤如下

在Package Explorer中, 鼠标右键项目文件夹，点击 Properties.
在Properties 窗口, 选择"Android" ，Library 属性显示在右下边.
点击Add ，打开了Project Selection 对话框.
从可用库项目列表选择一个项目，然后点击 OK.
对话框关闭之后点击 Apply （在Properties 窗口）.
点击 OK 关闭Properties 窗口.

完成以上六步，Eclipse 会重建项目，把库项目中的内容包含进去。 如图2所示
图 2. 让项目引用一个库项目
如果你想增加多个库项目的引用，使用up和down可以设置他们的相对的优先级和合并顺序。工具在合并引用的库的时候顺序是从低优先级（列表的下面）到高优先级（列表的上面）。 如果不只一个库定义了相同的资源ID，这个工具选择资源时会选择高优先级的资源。应用程序自身拥有最高的优先级，自身的资源zThe application itself has highest priority and its resources are always used in preference to identical resource IDs defined in libraries.

在menifest文件中声明库中的组件
在manifest 文件中必须增加对在当前程序中用到的库项目中的所有的组件 。比如，你必须声明任何用到的 <activity>, <service>, <receiver>, <provider>等,<permission>, <uses-library>, 和其他类似的元素。
声明库项目中的组件时，必须使用包含包名的类全名。
在TicTacToeMain 例子中，声明库Activity GameActivity :

<manifest>
...
<application>
...
<activity android:name="com.example.android.tictactoe.library.GameActivity" />
...
</application>
</manifest>

For more information about the manifest file, see the documentation for AndroidManifest.xml.
本答案来自于互联网仅供参考学习作用
如果您对我的回答有不满意的地方，还请您继续追问；
答题不易，互相理解，互相帮助！

㈦ android如何检测哪些应用有service

ServiceTestCase 继承于继承了Junit
框架中的TestCase的AndroidTestCase类。该类中包含有测试应用的许可，控制被测试的应用和Service
等大量方法。同时也提供了模拟的应用(Applcation)和上下文(Context)方便我们可以使Service 独立于其应用进行测试。

Service
TestCase.setUp()方法在每个测试用例调用之前执行，该方法执行的时候配置测试数据通过复制并获得当前系统提供的Context.
你可以通过getSystemContext()取得系统的当前Context。如果你重写setUp()方法的话，第一条语句应该是super.setUp()。setApplication(Application)方法和setContext(Context)方法允许你在Service启动之前设置模拟的Context和模拟的Application，如果不做设定，将自动为测试指定MockApplication和MockContext。在调用startService()或者bindService()时，ServiceTestcase会自动初始化测试环境。因此，如果需要设定特定的测试环境，必须要在启动被测Service之前创建需要模拟的对象等等。

需要注意的是ServiceTestCase
.bindService()方法和Service.bindService()方法的参数不同的：ServiceTestCase.bindService()
方法只需要提供Intent对象，而Service.bindService()还需要指定ServiceConnection和flag。而且ServiceTestCase.bindService()方法返回一个IBinder对象的子类，而Service.bindService
()返回的是布尔值。

在每条测试用例运行结束后，teardown()方法会按照Service的生命周期进行回收。比如，通过bindService()方法启动Service的情况下，teardown()方法会自动依次调用该Service的onUnbind()方法和onDestroy()方法。

ServiceTestCase默认会执行()方法。用于验证该测试类是否在运行其他测试用例之前成功地设置了上下文。

下面以SAF的Security组件的API测试为例，描述测试整个过程：

首先Security组件对外提供的API是以AIDL方式暴露的两个方法

int getAgentVersionCode()

String exec(String[] args, String directory, boolean noResult, boolean
isSync)

因此需要使用ServiceTestCase的bindService()方法来进行测试。

首先新建测试工程，修改AndroidManifest.xml

<application

android:icon="@drawable/ic_launcher"

android:label="@string/app_name" >

<uses-library android:name="android.test.runner" >

</uses-library>

</application>

<instrumentation

android:name=".TestRunner"

android:targetPackage="saf.cmcc.security.agent" >

</instrumentation>

指定被测应用包名，指定TestRunner，声明使用android.test.runner库。

新建TestRunner类

public class TestRunner extends InstrumentationTestRunner {

@Override

public
TestSuite getAllTests() {

InstrumentationTestSuite
suite = new InstrumentationTestSuite(this);

suite.addTestSuite(ApiTest.class);

return
suite;

}

}

新建测试类ApiTest

public class ApiTest extends ServiceTestCase<SecurityService> {

public
ApiTest() {

super(SecurityService.class);

}

protected void
setUp() throws Exception {

Log.e(getName(), "setUp...");

super.setUp();

}

protected void
teardown() throws Exception {

Log.e(getName(),
"tearDown...");

super.tearDown();

}

/**

* Test bind
service

*/

public void
testBindable() {

Intent
startIntent = new Intent();

startIntent.setClass(getSystemContext(),
SecurityService.class);

IBinder
service = bindService(startIntent);

assertEquals(true,
service.isBinderAlive());

}

/**

* Test
getAgentVersionCode

*/

public void
testGetAgentVersionCode() {

Intent
startIntent = new Intent();

startIntent.setClass(getSystemContext(),
SecurityService.class);

IBinder
service = bindService(startIntent);

if
(service.isBinderAlive()) {

SecurityAgent
securityAgent = SecurityAgent.Stub

.asInterface(service);

int
versionCode = 0;

try {

versionCode
= securityAgent.getAgentVersionCode();

} catch
(RemoteException e) {

// TODO
Auto-generated catch block

e.printStackTrace();

}

assertEquals(2,
versionCode);

}

}

}

使用与被测应用相同签名编译安装测试apk，即可运行测试了

㈧ 如何创建Android库以及Android aar文件详解

创建 Android 库

Android 库在结构上与 Android 应用模块相同。它可以提供构建应用所需的一切内容，包括源代码、资源文件和 Android 清单。不过，Android 库将编译到您可以用作 Android 应用模块依赖项的 Android 归档 (AAR：Android Archive Resource) 文件，而不是在设备上运行的 APK。与 JAR 文件不同，AAR 文件可以包含 Android 资源和一个清单文件，这样，除了 Java 类与方法外，您还可以捆绑布局和可绘制对象等共享资源。

库模块在以下情况下非常有用：

• 构建使用某些相同组件（例如 Activity、服务或 UI 布局）的多个应用。

• 构建存在多个 APK 变体（例如免费版本和付费版本）的应用并且需要在两种版本中使用相同的核心组件。
  在任何一种情况下，只需要将您希望重用的文件移动到库模块中，然后以依赖项的形式为每个应用模块添加库。本页面将说明如何执行这两个操作。

创建库模块

要在您的项目中创建一个新的库模块，请按以下步骤操作：
1、点击** File > New > New Mole。**
2、在出现的 Create New Mole 窗口中，依次点击** Android Library 和 Next。还存在一个用于创建 Java 库的选项，可以构建传统的 JAR 文件。尽管 JAR 文件在大多数项目中都非常实用（尤其在您希望与其他平台共享代码时），但这种文件不允许您包含 Android 资源或清单文件，而后者对于 Android 项目中的代码重用非常有用。**因此，本指南将侧重论述创建 Android 库。
3、为您的库命名，并为库中代码选择一个最低的 SDK 版本，然后点击 Finish。

在 Gradle 项目同步完成后，库模块将显示左侧的 Project 面板中。如果您未看到新模块文件夹，请确保将视图切换为 Android 视图。

将应用模块转换为库模块

如果您现有的应用模块包含您希望重用的所有代码，则可以按照以下步骤将其转换为库模块：

1、打开现有应用模块的 build.gradle 文件。您应在顶部看到以下内容：

• apply plugin: 'com.android.application'



2、按照下面所示更改插件分配：

• apply plugin: 'com.android.library'



3、点击 Sync Project with Gradle Files。

就这么简单。模块的整个结构仍然相同，但是现在它将作为 Android 库运行，构建也将创建一个 AAR 文件，而不是 APK。

生成aar

在Android Studio1.4中，New project，先默认新建一个Applicaton mole，接后File > New > New Mole，选择Androd Library > Next，指定Library Name和Mole Name。

新建的Library与正常的Application最大区别是mole build.gradle中是**apply plugin: ‘com.android.library’ **而不是 apply plugin: 'com.android.application'

Build > Make project，自动生成aar文件。



以依赖项形式添加您的库

要在另一个应用模块中使用您的 Android 库的代码，请按以下步骤操作：

1、通过两种方式之一将库添加到您的项目（如果您是在相同项目中创建的库模块，则该模块已经存在，您可以跳过此步骤）：

• 添加已编译的 AAR（或 JAR）文件：
  1、点击 File > New Mole。
  2、依次点击 Import .JAR/.AAR Package 和** Next**。
  3、输入 AAR 或 JAR 文件的位置，然后点击 Finish。

• 将库模块导入到您的项目中：
  1、点击** File > New > Import Mole。**
  2、输入库模块目录的位置，然后点击 Finish。
  库模块将复制到您的项目中，因此您可以尽管编辑库代码。如果您希望维护一个版本的库代码，则此方法可能不是您想要的，您应按照上文所述导入编译的 AAR 文件。

2、确保库列在您 settings.gradle 文件的顶部，如下面名为“my-library-mole”的库所示：

• include ':app', ':my-library-mole'



3、打开应用模块的 build.gradle 文件，并向 dependencies 块中添加一行新代码，如下面的片段所示：

• dependencies {


• compile project(":my-library-mole")


• }



4、点击 Sync Project with Gradle Files。
在上面的示例中，名为 my-library- mole 的 Android 库模块成为 build.gradle 文件所在模块的构建依赖项。
您的应用模块现在可以访问 Android 库中的任何代码和资源，库 AAR 文件在构建时已捆绑到您的 APK 中。
不过，如果希望单独共享 AAR 文件，则可以在 项目名称/模块名称/build/outputs/aar/ 中找到它，也可以通过点击 Build > Make Project 的方式重新生成此文件。

选择要设为公开的资源

库中的所有资源在默认情况下均处于公开状态。要将所有资源隐式设为私有，您必须至少将一个特定的属性定义为公开。资源包括您项目的 res/ 目录中的所有文件，例如图像。要阻止您的库用户访问仅供内部使用的资源，您应通过声明一个或多个公开资源的方式来使用这种自动私有标识机制。

要删除某个公开资源，请将一个声明添加到您的库的 public.xml文件中。如果您之前尚未添加公开资源，则需要在您的库的 res/values/目录中创建public.xml 文件。

下面的示例代码可以创建两个名称分别为 mylib_app_name和 mylib_public_string 的公开字符串资源：

• <resources>


• <public name="mylib_app_name" type="string"/>


• <public name="mylib_public_string" type="string"/>


• </resources>```


• 如果希望任何资源保持对使用您的库的开发者可见，您应当将其设为公开。例如，尽管 [v7 appcompat 库](https://developer.android.com/topic/libraries/support-library/features.html#v7-appcompat)中的大多数资源都是私有资源，但是为了支持[Material Design](https://developer.android.com/design/material/index.html)，控制工具栏小部件的属性应当公开。将属性隐式设为私有不仅可以阻止您的库用户从内部库资源获得代码自动完成建议，还让您能够在不中断您的库客户端的情况下重命名或移除私有资源。私有资源不在代码自动完成和 [Theme Editor](https://developer.android.com/studio/write/theme-editor.html) 的作用范围内，并且如果您尝试引用私有资源，[Lint](https://developer.android.com/studio/write/lint.html) 将显示警告。##开发注意事项在开发您的库模块和相关应用时，请注意以下行为和限制。


• 将库模块引用添加至您的 Android 应用模块后，您可以设置它们的相对优先级。构建时，库会按照一次一个的方式与应用合并，并按照从低到高的优先级顺序。


• * **资源合并冲突**


• 构建工具会将库模块中的资源与相关应用模块的资源合并。如果在两个模块中均定义了给定资源 ID，将使用应用中的资源。


• 如果多个 AAR 库之间发生冲突，将使用依赖项列表首先列出（位于 dependencies块顶部）的库中的资源。


• 为了避免常用资源 ID 的资源冲突，请使用在模块（或在所有项目模块）中具有唯一性的前缀或其他一致的命名方案。



• * **库模块可以包含 JAR 库**


• 您可以开发一个自身包含 JAR 库的库模块；不过，您需要手动编辑相关应用模块的构建路径，并添加 JAR 文件的路径。



• * **库模块可以依赖外部 JAR 库**


• 您可以开发一个依赖于外部库（例如 Maps 外部库）的库模块。在这种情况下，相关应用必须针对包含外部库（例如 Google API 插件）的目标构建。另外也要注意，库模块和相关应用都必须在其清单文件的 [<uses- library>


• ](https://developer.android.com/guide/topics/manifest/uses-library-element.html) 元素中声明外部库。* **库模块不得包含原始资源**


• 工具不支持在库模块中使用原始资源文件（保存在 assets/目录中）。应用使用的任何原始资源都必须存储在应用模块自身的 assets/目录中。



• * **应用模块的 minSdkVersion必须大于或等于库定义的版本**


• 库作为相关应用模块的一部分编译，因此，库模块中使用的 API 必须与应用模块支持的平台版本兼容。



• * **每个库模块都会创建自己的 R 类**


• 在您构建相关应用模块时，库模块将先编译到 AAR 文件中，然后再添加到应用模块中。因此，每个库都有其自己的 R 类，并根据库的软件包名称命名。从主模块和库模块生成的 R 类会在所需的所有软件包（包括主模块的软件包和库的软件包）中创建。



• * **库模块可能包含自己的 ProGuard 配置文件**


• 通过将 [ProGuard](https://developer.android.com/studio/build/shrink-code.html) 配置文件添加到包含其 ProGuard 指令的库，您可以在自己的库上启用代码压缩。构建工具会为库模块将此文件嵌入到生成的 AAR 文件中。在您将库添加到应用模块时，库的 ProGuard 文件将附加至应用模块的 ProGuard 配置文件 (proguard.txt)。通过将 ProGuard 文件嵌入到您的库模块中，您可以确保依赖于此库的应用模块不必手动更新其 ProGuard 文件即可使用库。当 ProGuard 在 Android 应用模块上运行时，它会同时使用来自应用模块和库的指令，因此您不应当只在库上运行 ProGuard。


• 要指定您的库的配置文件名称，请将其添加到 consumerProguardFiles方法中，此方法位于您的库的 build.gradle文件的 defaultConfig块内。例如，以下片段会将 lib-proguard-rules.txt设置为库的 ProGuard 配置文件：



android {
defaultConfig {
consumerProguardFiles 'lib-proguard-rules.txt'
}
...
}

• 默认情况下，应用模块会使用库的发布构建，即使在使用应用模块的调试构建类型时亦是如此。要使用库中不同的构建类型，您必须将依赖项添加到应用的 build.gradle文件的 dependencies块中，并在库的 build.gradle文件中将 publishNonDefault设置为 true。例如，您应用的 build.gradle文件中的以下代码段会使应用在应用模块于调试模式下构建时使用库的调试构建类型，以及在应用模块于发布模式下构建时使用库的发布构建类型：



dependencies {
debugCompile project(path: ':library', configuration: 'debug')
releaseCompile project(path: ':library', configuration: 'release')
}

• 您还必须在自己库的 build.gradle文件的 android 块内添加以下代码行，以便将此库的非发布配置展示给使用它的项目：



android {
...
publishNonDefault true
}```
不过请注意，设置 publishNonDefault会增加构建时间。
为了确保您的库的 ProGuard 规则不会将意外的压缩副作用施加到应用模块，请仅包含适当规则，停用不适用于此库的 ProGuard 功能。尝试协助开发者的规则可能会与应用模块或它的其他库中的现有代码冲突，因此不应包含这些规则。例如，您的库的 ProGuard 文件可以指定在应用模块的压缩期间需要保留的代码。

注：Jack 工具链仅支持 ProGuard 的部分压缩和模糊选项。

AAR 文件详解

AAR 文件的文件扩展名为 .aar，Maven 工件类型也应当是 aar。文件本身是一个包含以下强制性条目的 zip文件：

• /AndroidManifest.xml

• /classes.jar

• /res/

• /R.txt

此外，AAR 文件可能包含以下可选条目中的一个或多个：

• /assets/

• /libs/**名称 **.jar

• /jni/abi 名称 /名称.so（其中 abi 名称是 Android 支持的 ABI 之一）

• /proguard.txt

• /lint.jar

㈨ android的问题，刚才在eclipse上改了点程序，之后运行一看，结果eclipse提示找不到launch，请问怎么办

头一回 遇到你说的问题，你在androidmanifest文件里修改了东西吧 。这里相当于总的调度，你需要好好看一下再改动！

AndroidManifest.xml文件综合详解
文章分类:移动开发
一，重要性AndroidManifest.xml是Android应用程序中最重要的文件之一。它是Android程序的全局配置文件，是每个 android程序中必须的文件。它位于我们开发的应用程序的根目录下，描述了package中的全局数据，包括package中暴露的组件（activities, services, 等等），以及他们各自的实现类，各种能被处理的数据和启动位置等重要信息。
因此，该文件提供了Android系统所需要的关于该应用程序的必要信息，即在该应用程序的任何代码运行之前系统所必须拥有的信息。一个典型的Android应用程序的结构如下图所示：

二，主要功能它指定了该应用程序的Java包：该包名作为应用程序的一个独特标识。
它描述了应用程序组件：该应用程序由哪些activity，service，broadcast receiver和content provider组成。它指定了实现每个组件的类以及公开发布它们的能力(例如，它们能持有哪个Intent信息)。这些声明使Android系统知道这儿有什么组件以及在什么条件下它们可以被载入。
它决定那些进程将容纳应用程序组件。
它声明了本应用程序必须拥有哪些许可，以便访问API的被保护部分，以及与其他应用程序交互。
它也声明了其他应用程序在和该应用程序交互时需要持有的许可。
它列出了Instrumentation类，可以在应用程序运行时提供简档和其他信息。这些声明仅当应用程序在开发和测试过程中被提供；它们将在应用程序正式发布之前被移除。
它声明了该应用程序所需的Android API的最小化水平。
它列出了该应用程序必须链接的库。

三，主要结构及规则下面列表显示了manifest文件的通常的结构以及它可以含有的元素。每个元素，连同它的所有属性，会在各个单独的文档里进行充分的描绘。

<?xml version="1.0" encoding="utf-8"?>
<manifest> //根节点，描述了package中所有的内容
<uses-permission /> //请求你的package正常运作所需赋予的安全许可。一个manifest能包含零个或更多此元素
<permission /> //声明了安全许可来限制哪些程序能使用你的package中的组件和功能。一个manifest能包含零个或更多此元素
<permission-tree />
<permission-group />
<instrumentation /> //声明了用来测试此package或其他package指令组件的代码。一个manifest能包含零个或更多此元素
<uses-sdk /> //指定当前应用程序兼容的最低sdk版本号
<application> //包含package中application级别组件声明的根节点。此元素也可包含 application中全局和默认的属性，如标签，icon，主题，必要的权限，等等。一个manifest能包含零个或一个此元素（不允许多余一个）
<activity> //用来与用户交互的主要工具。当用户打开一个应用程序的初始页面时一个activity,大部分被使用到的其他页面也由不同的activity所实现并声明在另外的activity标记中。
<intent-filter> //声明了指定的一组组件支持的Intent值
<action />
<category />
<data />
<type/>
<schema/>
<authority/>
<path/>
</intent-filter>
<meta-data />
</activity>
<activity-alias>
<intent-filter> . . . </intent-filter>
<meta-data />
</activity-alias>
<service> //Service是能在后台运行任意时间的组件
<intent-filter> . . . </intent-filter>
<meta-data/>
</service>
<receiver> //IntentReceiver能使你的application获得数据的改变或者发生的操作，即使它当前不在运行
<intent-filter> . . . </intent-filter>
<meta-data />
</receiver>
<provider> //ContentProvider是用来管理持久化数据并发布给其他应用程序使用的组件
<grant-uri-permission />
<meta-data />
</provider>
<uses-library />
<uses-configuration />
</application>
</manifest>
下面是按照字母顺序排列的所有可以出现在manifest文件里的元素。它们是唯一合法的元素；你不能加入你自己的元素或属性。
<action>
<activity>
<activity-alias>
<application>
<category>
<data>
<grant-uri-permission>
<instrumentation>
<intent-filter>
<manifest>
<meta-data>
<permission>
<permission-group>
<permission-tree>
<provider>
<receiver>
<service>
<uses-configuration>
<uses-library>
<uses-permission>
<uses-sdk>
说明：AndroidManifest.xml文件的结构、元素，以及元素的属性，可以在Android SDK文档中查看详细说明。而在看这些众多的元素以及元素的属性前，需要先了解一下这些元素在命名、结构等方面的规则：
元素：在所有的元素中只有<manifest>和<application>是必需的，且只能出现一次。如果一个元素包含有其他子元素，必须通过子元素的属性来设置其值。处于同一层次的元素，这些元素的说明是没有顺序的。
属性：按照常理，所有的属性都是可选的，但是有些属性是必须设置的。那些真正可选的属性，即使不存在，其也有默认的数值项说明。除了根元素<manifest>的属性，所有其他元素属性的名字都是以android:前缀的；
定义类名：所有的元素名都对应其在SDK中的类名，如果你自己定义类名，必须包含类的数据包名，如果类与application处于同一数据包中，可以直接简写为“.”；
多数值项：如果某个元素有超过一个数值，这个元素必须通过重复的方式来说明其某个属性具有多个数值项，且不能将多个数值项一次性说明在一个属性中；
资源项说明：当需要引用某个资源时，其采用如下格式：@[package :]type :name 。 例如 <activity android:icon=”@drawable/icon ” . . . >
字符串值：类似于其他语言，如果字符中包含有字符“\”，则必须使用转义字符“\\”；

四，详细说明值得一提一些常用之处：
1，几乎所有的AndroidManifest.xml（以及许多其他Android的xml的文件）在第一个元素中包含了命名空间的声明 xmlns:android="http://schemas.android.com/apk/res/android"。这样使得Android中各种标准属性能在文件中使用，提供了大部分元素中的数据。
2，大部分manifests包含了单个<application>的元素，它定义了所有的application级别组件和属性，并能在package中使用。
3，任何被用户看作顶层应用程序，并能被程序启动器所用的package，需要包含至少一个Activity组件来支持MAIN操作和LAUNCHER种类。动作android.intent.action.MAIN指示这是应用程序的入口点。类别 android.intent.category.LAUNCHER将此Activity放在启动器窗口中。
在最外层的<manifest>中包含了包名如 package="cn.androidlover.demo" 、软件的版本号 android:versionCode="1" 以及 android:versionName="1.0"的属性，而里面一层的<application>分支中将可能包含Android程序的四种对象 Activity、Service、Content Provider以及Receiver。我们每添加上面四个类型中的任一种新对象都需要在androidmanifest.xml文件中添加相应节点，否则运行时将会产生异常。每一个activity必须要一个<activity>标记对应，无论它给外部使用或是只用于自己的package 中。如果一个activity没有对应的标记，你将不能运行它。
此文件一个重要的地方就是它所包含的intent-filters。这些filters描述了activity启动的位置和时间。每当一个 activity（或者操作系统）要执行一个操作，例如：打开网页或联系簿时，它创建出一个intent的对象。它能承载一些信息描述了你想做什么，你想处理什么数据，数据的类型，和一些其他信息。Android比较了intent对象中和每个application所暴露的intent-filter中的信息，来找到最合适的activity来处理调用者所指定的数据和操作。关于intent的更多信息请访问Intent参考页面。
application属性介绍：
有关AndroidManifest.xml文件的application分支我们有必要了解一些常见的属性，这里可以看到一些我们实用的选项，比如允许调试android:debuggable、任务关系android:taskAffinity，比如我们常见的方式创建一个新的任务实用标记 FLAG_ACTIVITY_NEW_TASK，为程序制定一个主题，可以使用android:theme指向一个主题文件。平时我们创建的程序使用一些安全敏感项，会需要请求系统许可权限，这里可以使用android:permission来制定相关的许可，每个程序的service、 activity、content provider、receiver都需要在application的节点内实现。有关完整的属性可以查看:
<application android:allowClearUserData=["true" | "false"]
android:allowTaskReparenting=["true" | "false"]
android:debuggable=["true" | "false"]
android:description="string resource"
android:enabled=["true" | "false"]
android:hasCode=["true" | "false"]
android:icon="drawable resource"
android:label="string resource"
android:manageSpaceActivity="string"
android:name="string"
android:permission="string"
android:persistent=["true" | "false"]
android:process="string"
android:taskAffinity="string"
android:theme="resource or theme" >
. . .
</application>
另外：Activity的属性常用的可能为android:name和android:label两个，但我们需要了解所有的属性以帮助解决复杂的问题，完整的如下:

android:allowTaskReparenting=["true" | "false"]
android:alwaysRetainTaskState=["true" | "false"]
android:clearTaskOnLaunch=["true"" | "false"]
android:configChanges=[one or more of: "mcc" "mnc" "locale" "touchscreen" "keyboard" "keyboardHidden" "navigation" "orientation" "fontScale"]
android:enabled=["true" | "false"]
android:excludeFromRecents=["true" | "false"]
android:exported=["true" | "false"]
android:finishOnTaskLaunch=["true" | "false"]
android:icon="drawable resource"
android:label="string resource"
android:launchMode=["multiple" | "singleTop" | "singleTask" | "singleInstance"]
android:multiprocess=["true" | "false"]
android:name="string"
android:noHistory=["true" | "false"]
android:permission="string"
android:process="string"
android:screenOrientation=["unspecified" | "user" | "behind" | "landscape" | "portrait" | "sensor" | "nonsensor"]
android:stateNotNeeded=["true" | "false"]
android:taskAffinity="string"
android:theme="resource or theme"
android:windowSoftInputMode=[one or more of: "stateUnspecified" "stateUnchanged" "stateHidden" "stateAlwaysHidden" "stateVisible" "stateAlwaysVisible" "adjustUnspecified" "adjustResize" "adjustPan"]

从Provider节点中用到的定义，可以看到包含了权限控制、排序方式完整的如下:
<provider android:authorities="list"
android:enabled=["true" | "false"]
android:exported=["true" | "false"]
android:grantUriPermissions=["true" | "false"]
android:icon="drawable resource"
android:initOrder="integer"
android:label="string resource"
android:multiprocess=["true" | "false"]
android:name="string"
android:permission="string"
android:process="string"
android:readPermission="string"
android:syncable=["true" | "false"]
android:writePermission="string" >
</provider>
而对于服务相关定义如下:
<service android:enabled=["true" | "false"]
android:exported[="true" | "false"]
android:icon="drawable resource"
android:label="string resource"
android:name="string"
android:permission="string"
android:process="string" >
</service>
最后是Broadcast使用的Receiver定义，一般配合和隐式处理。
<receiver android:enabled=["true" | "false"]
android:exported=["true" | "false"]
android:icon="drawable resource"
android:label="string resource"
android:name="string"
android:permission="string"
android:process="string" >
</receiver>
总之，AndroidManifest.xml文件虽然看起来复杂，但是，只要我们理清中里面各元素的作用，那么一切就变得简单了。

㈩ 如何在Android真机上检测是否有Google Map add-on

方法有两个：

1）维护两条代码分支：
一条分支是针对于内置有Google Map add-on的Android真机，另一条分支是没有内置有Google Map add-on的Android真机。
但是这样做会增加维护成本，而且粗心的用户可能会在自己的机器上安装了不匹配的分支，从而降低了软件的友好度。

2）仍然只保留一条代码分支：
国外一位大牛指出：在<uses-library>标签中还包含了一个没有公布的属性"android:required"，你可以将com.google.android.maps库的这个属性设置为false，即:
<!-- The "android:required" attribute was added in API level 5 (Android 2.0) -->
<uses-library android:name="com.google.android.maps" android:required="false" />

这代表如果在目标机器上内置了Google Map add-on，则可以正常使用应用；如果目标机器没有内置Google Map add-on，也可以成功安装应用。但是开发人员需要在代码中自行判断Google Map add-on是否可用，