## JNI 简介

JNI（Java Native Interface）是“Java 本地接口”的缩写，用于指使用 C 和 C++ 语言开发的接口。由于 JNI 是 JVM 规范的一部分，所以我们编写的 JNI 程序可以在任何实现了 JNI 规范的 Java 虚拟机上运行。这一特性允许我们复用大量用 C/C++ 编写的代码。

然而，开发 JNI 程序会受到系统环境的限制，因为用 C/C++ 编写的代码在编译时依赖于操作系统提供的库函数，并需要链接到本地库上。因此，编译后的二进制代码只能在特定操作系统环境下运行。由于不同操作系统有各自的本地库和 CPU 指令集，各平台对标准 C/C++ 规范和库函数的实现方式也有所不同。这使得使用了 JNI 接口的 Java 程序不再具备完全的跨平台能力。如果要实现跨平台，需要在不同操作系统下编译出相应的动态库。



JNI 开发流程主要包括以下六步：

1. 编写声明了 `native` 方法的 Java 类。
2. 将 Java 源代码编译成 `.class` 字节码文件。
3. 使用 `javah -jni` 命令生成 `.h` 头文件（`javah` 是 JDK 自带的命令，`-jni` 参数用于生成符合 JNI 规范的函数声明）。
4. 用本地代码实现 `.h` 头文件中的函数。
5. 将本地代码编译成动态库（Windows: `.dll`, Linux/Unix: `.so`, Mac OS X: `.jnilib`）。
6. 将动态库拷贝到 `java.library.path` 本地库搜索目录下，并运行 Java 程序。

通过以上步骤，可以成功创建并运行 JNI 程序，实现 Java 与本地代码的交互。


![image.png](/static/img/b7f03d9199f788beab84c0aa41a1af44.image.webp)


## NDK简介

（英语：Native Development Kit，简称NDK）是一种基于原生程序接口的软件开发工具。通过此工具开发的程序直接以本地语言运行，而非依赖虚拟机。因此，只有像Java这样基于虚拟机运行的语言才需要使用原生开发工具包。

NDK提供了一系列工具，帮助开发者快速开发C或C++的动态库，并能自动将.so文件和Java应用一起打包成APK。这些工具极大地简化了开发过程。NDK集成了交叉编译器，并提供了相应的.mk文件，用于处理CPU、平台和ABI等差异。开发人员只需简单修改.mk文件（例如指定需要编译的文件和编译特性要求），就可以创建出.so文件。

NDK可以自动将.so文件和Java应用一起打包，显著减轻了开发人员的工作量。

在Android NDK的`platforms\<android版本>\arch-arm\usr\include\jni.h`头文件中，声明了所有可用的JNI接口函数。该文件包含两个重要的结构体：JNINativeInterface和JNIInvokeInterface。JNINativeInterface是JNI本地接口，实际上是一个接口函数指针表，包含所有JNI接口函数的指针，所有原生代码都可以调用这些接口函数。而JNIInvokeInterface是JNI调用接口，包含3个保留项和5个函数指针，这些函数用于访问全局的JNI接口，常用于原生多线程程序开发。

```c++
#if defined(__cplusplus)
typedef _JNIEnv JNIEnv;
typedef _JavaVM JavaVM;
#else
typedef const struct JNINativeInterface* JNIEnv;
typedef const struct JNIInvokeInterface* JavaVM;
#endif
```

如果使用C++代码调用JNI接口函数，JNIEnv被定义为 `_JNIEnv` 结构体，该结构体的第一个字段是一个JNINativeInterface结构体的指针。如果是C代码调用JNI接口函数，JNIEnv直接定义为JNINativeInterface结构体的指针。因此，可以将JNIEnv的首地址解释为JNINativeInterface的首地址使用，通过首地址和索引值即可找到需要调用的JNI接口函数。每个函数地址占用4个字节的空间。

## NDK两种开发模式

在 Android 开发中，NDK（Native Development Kit）提供了两种主要的开发模式：`ndk-build` 和 `CMake`。本文将详细介绍这两种模式的特点和使用场景。

## 1. ndk-build 模式

`ndk-build` 是 Android Studio 2.2 之前主流的 NDK 开发模式，主要特点包括:

- **脚本化构建**：使用 `Android.mk` 和 `Application.mk` 文件定义构建过程。
- **成熟稳定**：长时间使用，有较多的社区资源和支持。
- **直接集成**：无需额外配置，适合已有项目及偏好命令行工具的开发者。

## 2. CMake 模式

自 Android Studio 2.2 起，NDK 开发开始原生支持 `CMake`。主要特点包括:

- **跨平台支持**：CMake 是一种跨平台构建工具，能简化跨平台项目配置。
- **CLion 支持**：与 JetBrains 的 CLion 编辑器无缝整合，提升 C/C++ 开发体验。
- **现代构建系统**：利用 CMake 的现代功能，如自动依赖管理和更简洁的配置语法。

Android Studio 在 2.2 版本整合了 CLion 的代码，使其全面支持通过 CMake 进行 NDK 开发，提升了项目配置和管理的灵活性和便捷性。



## 为何要用到NDK

概括来说主要分为以下几种情况：

1. **代码的保护**：
   - APK的Java层代码很容易被反编译。
   - C/C++库的反汇编难度较大。

2. **调用第三方C/C++库**：
   - 大部分开源库是用C/C++代码编写的。

3. **便于移植**：
   - 用C/C++编写的库可以方便地在其他嵌入式平台上再次使用。

下面介绍一下Android NDK的入门学习过程：

入门的最好办法就是学习Android自带的例子。这里通过学习Android NDK自带的demo程序：`hello-jni` 来达到这个目的。

## 一、 开发环境的搭建

我用的windwos的AS软件，安装即可。
 
## 二、代码的编写

### 1.首先是写java代码

建立一个Android应用工程`HelloJni`创建HelloJni.java文件：


![image.png](/static/img/2f4a9e6d1961498f4bae99ab31bb76f7.image.webp)


![image.png](/static/img/fb25b20ffecce6730127776a5c2c7a8d.image.webp)



HelloJni.java :
``` java
/*
 * 版权所有 (C) 2009 The Android Open Source Project
 *
 * 根据 Apache License 2.0 版（“许可证”）授权；
 * 除非遵守此许可证，否则您不得使用此文件。
 * 您可以在以下网址获得许可证副本：
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * 除非适用法律要求或书面同意，按“原样”分发的许可软件
 * 不得附带任何明示或暗示的保证或条件。
 * 有关许可证下特定语言管理权限的详细信息，请参阅许可证。
 */
package com.example.hellojni;

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

public class HelloJni extends Activity {
    /**
     * 活动首次创建时调用。
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        /* 创建一个TextView并设置其内容。
         * 文本是通过调用本地函数检索的。
         */
        TextView tv = new TextView(this);
        tv.setText(stringFromJNI());
        setContentView(tv);
    }

    /* 本地方法，由 'hello-jni' 本地库实现，
     * 此库与此应用一起打包。
     */
    public native String stringFromJNI();

    /* 这是另一个本地方法声明，*未*由 'hello-jni' 实现。
     * 这只是为了显示您可以在Java代码中声明任意多的本地方法，
     * 它们的实现仅在首次调用它们时在当前加载的本地库中搜索。
     *
     * 尝试调用此函数将导致 java.lang.UnsatisfiedLinkError 异常！
     */
    public native String unimplementedStringFromJNI();

    /* 在应用启动时加载 'hello-jni' 库。
     * 库已在安装时由包管理器解压到
     * /data/data/com.example.HelloJni/lib/libhello-jni.so。
     */
    static {
        System.loadLibrary("hello-jni");
    }
}

```

这段代码逻辑简单，注释也十分清晰，这里只需指出两点：

1. 
```java
static { 
    System.loadLibrary("hello-jni"); 
}
```
这段代码会在程序启动时加载 `hello-jni` 库。由于它在 `static` 块中，代码会在任何类的 `onCreate` 方法执行之前运行。如果程序中存在多个类，且 `HelloJni` 不是应用程序的入口类，那么库 `libhello-jni.so` 会在首次使用 `HelloJni` 类时加载。

2.
```java
public native String stringFromJNI(); 
public native String unimplementedStringFromJNI();
```
这两段代码中的 `native` 关键字表明这些方法是本地方法，即它们由本地代码（C/C++）实现，Java代码中仅仅是声明。

在使用 Eclipse 编译工程时，生成相应的 `.class` 文件。这一步必须在下一步生成 `.h` 文件之前完成，因为生成 `.h` 文件需要对应的 `.class` 文件。

### 2. 编写相应的C/C++代码

刚开始学的时候，有个问题会让人很困惑，相应的C/C++代码如何编写，函数名如何定义？ 这里讲一个方法，利用javah这个工具生成相应的.h文件，然后根据这个.h文件编写相应的C/C++代码。

#### 2.1 生成相应.h文件：

就拿我这的环境来说，首先在终端下进入刚刚建立的HelloJni工程的目录：

`braincol@ubuntu:~$ cd workspace/android/NDK/hello-jni/`

ls查看工程文件
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ ls 
AndroidManifest.xml  assets  bin  default.properties  gen  res  src 
```
可以看到目前仅仅有几个标准的android应用程序的文件（夹）。

首先我们在工程目录下建立一个jni文件夹：
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ mkdir jni 
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ ls 
AndroidManifest.xml  assets  bin  default.properties  gen  jni  res  src 
```
下面就可以生成相应的.h文件了：

`braincol@ubuntu:~/workspace/android/NDK/hello-jni$ javah -classpath bin -d jni com.example.hellojni.HelloJni `

-classpath bin：表示类的路径

-d jni: 表示生成的头文件存放的目录

`com.example.hellojni.HelloJni` 则是完整类名

这一步的成功要建立在已经在 bin/com/example/hellojni/  目录下生成了 HelloJni.class的基础之上。

现在可以看到jni目录下多了个.h文件：
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ cd jni/ 
braincol@ubuntu:~/workspace/android/NDK/hello-jni/jni$ ls 
com_example_hellojni_HelloJni.h
```
我们来看看`com_example_hellojni_HelloJni.h`的内容：

com_example_hellojni_HelloJni.h :
``` c
 /* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_example_hellojni_HelloJni */

#ifndef _Included_com_example_hellojni_HelloJni
#define _Included_com_example_hellojni_HelloJni
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_hellojni_HelloJni
 * Method:    stringFromJNI
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_hellojni_HelloJni_stringFromJNI
  (JNIEnv *, jobject);

/*
 * Class:     com_example_hellojni_HelloJni
 * Method:    unimplementedStringFromJNI
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif
```
上面代码中的JNIEXPORT 和 JNICALL 是jni的宏，在android的jni中不需要，当然写上去也不会有错。

从上面的源码中可以看出这个函数名那是相当的长，不过还是很有规律的， 完全按照：`java_pacakege_class_mathod` 形式来命名。

也就是说：
```
Hello.java中 stringFromJNI() 方法对应于 C/C++中的 Java_com_example_hellojni_HelloJni_stringFromJNI() 方法

HelloJni.java中的 unimplementedStringFromJNI() 方法对应于 C/C++中的 Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI() 方法 
```
注意下其中的注释：
```
Signature: ()Ljava/lang/String; 

()Ljava/lang/String;
```
()表示函数的参数为空（这里为空是指除了`JNIEnv *, jobject` 这两个参数之外没有其他参数，`JNIEnv*, jobject`是所有jni函数必有的两个参数，分别表示jni 环境和对应的java类（或对象）本身），

`Ljava/lang/String;` 表示函数的返回值是java的String对象。

 

#### 2.2 编写相应的.c文件：

hello-jni.c :
``` c
 /*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#include <string.h>
#include <jni.h>

/* This is a trivial JNI example where we use a native method
 * to return a new VM String. See the corresponding Java source
 * file located at:
 *
 *   apps/samples/hello-jni/project/src/com/example/HelloJni/HelloJni.java
 */
jstring
Java_com_example_hellojni_HelloJni_stringFromJNI( JNIEnv* env,
                                                  jobject thiz )
{
    return (*env)->NewStringUTF(env, "Hello from JNI !");
}
```
这里只是实现了`Java_com_example_hellojni_HelloJni_stringFromJNI`方法，而 `Java_com_example_hellojni_HelloJni_unimplementedStringFromJNI` 方法并没有实现，因为在HelloJni.java中只调用了`stringFromJNI()`方法，所以`unimplementedStringFromJNI()`方法没有实现也没关系，不过建议最好还是把所有java中定义的本地方法都实现了，写个空函数也行，有总比没有好。

`Java_com_example_hellojni_HelloJni_stringFromJNI()` 函数只是简单的返回了一个内容为 `"Hello from JNI !"` 的jstring对象（对应于java中的String对象）。

hello-jni.c文件已经编写好了，现在可以把`com_example_hellojni_HelloJni.h`文件给删了，当然留着也行，只是我还是习惯把不需要的文件给清理干净了。

### 3. 编译hello-jni.c 生成相应的库

#### 3.1 编写Android.mk文件

在jni目录下（即hello-jni.c 同级目录下）新建一个Android.mk文件，Android.mk 文件是Android 的 makefile文件，内容如下：
``` makefile
# Copyright (C) 2009 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := hello-jni
LOCAL_SRC_FILES := hello-jni.c

include $(BUILD_SHARED_LIBRARY)
```
这个Androd.mk文件很短，下面我们来逐行解释下：  
`LOCAL_PATH := $(call my-dir)`  

一个Android.mk 文件首先必须定义好LOCAL_PATH变量。它用于在开发树中查找源文件。在这个例子中，宏函数’my-dir’, 由编译系统提供，用于返回当前路径（即包含Android.mk file文件的目录）。  

`include $( CLEAR_VARS)`  

CLEAR_VARS由编译系统提供，指定让GNU MAKEFILE为你清除许多LOCAL_XXX变量（例如 LOCAL_MODULE, LOCAL_SRC_FILES, LOCAL_STATIC_LIBRARIES, 等等...), 除了LOCAL_PATH 。这是必要的，因为所有的编译控制文件都在同一个GNU MAKE执行环境中，所有的变量都是全局的。  
 
`LOCAL_MODULE := hello-jni`  

编译的目标对象，LOCAL_MODULE变量必须定义，以标识你在Android.mk文件中描述的每个模块。名称必须是唯一的，而且不包含任何空格。  

注意：编译系统会自动产生合适的前缀和后缀，换句话说，一个被命名为'hello-jni'的共享库模块，将会生成'libhello-jni.so'文件。  

**重要注意事项**：

如果你把库命名为‘libhello-jni’，编译系统将不会添加任何的lib前缀，也会生成 'libhello-jni.so'，这是为了支持来源于Android平台的源代码的Android.mk文件，如果你确实需要这么做的话。

`LOCAL_SRC_FILES := hello-jni.c`

LOCAL_SRC_FILES变量必须包含将要编译打包进模块中的C或C++源代码文件。注意，你不用在这里列出头文件和包含文件，因为编译系统将会自动为你找出依赖型的文件；仅仅列出直接传递给编译器的源代码文件就好。

注意，默认的C++源码文件的扩展名是’.cpp’. 指定一个不同的扩展名也是可能的，只要定义LOCAL_DEFAULT_CPP_EXTENSION变量，不要忘记开始的小圆点（也就是’.cxx’,而不是’cxx’）

`include $(BUILD_SHARED_LIBRARY)`

BUILD_SHARED_LIBRARY表示编译生成共享库，是编译系统提供的变量，指向一个GNU Makefile脚本，负责收集自从上次调用`include $(CLEAR_VARS)`以来，定义在LOCAL_XXX变量中的所有信息，并且决定编译什么，如何正确地去做。还有 BUILD_STATIC_LIBRARY变量表示生成静态库：lib$(LOCAL_MODULE).a；BUILD_EXECUTABLE 表示生成可执行文件，可以直接把可执行文件 adb push 到某目录并chmod 给予执行权限，然后 adb shell 直接执行它。

 
#### 3.2 生成.so共享库文件
Andro文件已经编写好了，现在可以用android NDK开发包中的 ndk-build脚本生成对应的.so共享库了，方法如下：
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni/jni$ cd .. 
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ ls 
AndroidManifest.xml  assets  bin  default.properties  gen  jni  libs  obj  res  src 
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ ndk-build 
Gdbserver      : [arm-linux-androideabi-4.4.3] libs/armeabi/gdbserver 
Gdbsetup       : libs/armeabi/gdb.setup 
Install        : libhello-jni.so => libs/armeabi/libhello-jni.so 
```
可以看到已经正确的生成了libhello-jni.so共享库了， 我们去 libs/armeabi/ 目录下看看：
```
braincol@ubuntu:~/workspace/android/NDK/hello-jni$ cd libs/ 
braincol@ubuntu:~/workspace/android/NDK/hello-jni/libs$ ls 
armeabi 
braincol@ubuntu:~/workspace/android/NDK/hello-jni/libs$ cd armeabi/ 
braincol@ubuntu:~/workspace/android/NDK/hello-jni/libs/armeabi$ ls 
gdbserver  gdb.setup  libhello-jni.so
```
### 4. 在eclipse重新编译HelloJni工程，生成apk

eclipse中刷新下HelloJni工程，重新编译生成apk，libhello-jni.so共享库会一起打包在apk文件内。

在模拟器中看看运行结果：  

hello-jni  
![](../pictures/hellojni.png)

## 附：使用 android 脚本生成android 工程
在使用 ndk-build 工具前，需要先有一个Android 工程，这个工程可以从Android NDK 的 samples 目录下随便复制一份，也可以使用Android SDK 开发包 tools 目录下的 android 脚本生成。  
android 脚本可以用来管理 AVD、android 工程，完整命令可以 “android --help” 查看。  
`android create project -n hellojni -p hellojni -t android-19 -k com.example.hellojni -a HelloJni`  
命令行解释如下：  
"-n" 指定android 工程的名称；"-t" 指定生成android 工程的平台版本，也就是`android list` 列出的版本之一；"-p" 指定生成工程的目录名；"-k" 指定 android 工程的包名；"-a" 指定默认activity的名称；`android create project` 会根据默认activity 文件名自动生成相应的java 文件，并生成AndroidManifest.xml。    


## Reference
http://www.cnblogs.com/hibraincol/archive/2011/05/30/2063847.html

【Android Java】Android NDK 开发基础

# Android 工程项目结构解析


## 工程关键部分

以 Android Studio（或 Eclipse + ADT）为例，大部分开发工作集中在以下几个目录：

- **java**：存放业务功能的 Java 代码。
- **res**：存放各种资源文件，如图片、字符串、动画、音频以及各种 XML 文件。



## res 资源文件夹介绍

`res` 目录用于存放各种资源文件：

- **drawable**：存放位图文件（.png, .jpg, .9.png, .gif 等）。
- **mipmap**：比 `drawable` 更适合存放启动图标，同样支持不同分辨率（hdpi, mdpi, xhdpi, xxhdpi）。
- **layout**：存放各种布局文件（XML 格式）。
- **menu**：存放菜单相关的 XML 文件。
- **values**：存放常量资源，如 `strings.xml`、`colors.xml` 等。

`assets` 目录需要手动创建，区别在于资源文件不会在 `R.java` 中生成 id。

### 图片资源

- **drawable**：存放各种位图文件，以及其他 `drawable` 类型的 XML 文件。
- **mipmap**：存放不同分辨率的启动图标。
  - mipmap-hdpi（高分辨率）
  - mipmap-mdpi（中等分辨率）
  - mipmap-xhdpi（超高分辨率）
  - mipmap-xxhdpi（超超高分辨率）

### 布局资源

`layout` 目录存放布局文件，通过为特定屏幕适配创建相应的文件夹，如 `layout-480x320`。

### 菜单资源

`menu` 目录用于存放菜单项相关的资源 XML。现在实体菜单按钮减少，用途变少。

### values 目录

- `demens.xml`：定义尺寸资源。
- `string.xml`：定义字符串资源。
- `styles.xml`：定义样式资源。
- `colors.xml`：定义颜色资源。
- `arrays.xml`：定义数组资源。
- `attrs.xml`：自定义控件的属性。

### raw 目录

存放原生资源（音频、视频、XML 等），通过 `openRawResource(int id)` 获取资源的二进制流。

### 动画资源

- **animator**：存放属性动画的 XML 文件。
- **anim**：存放补间动画的 XML 文件。

## 使用资源文件

资源文件在 `R.java` 下生成对应的资源 id，通过资源 id 进行访问：

### 在 Java 代码中使用

```java
txtName.setText(getResources().getText(R.string.name));
imgIcon.setBackgroundResource(R.drawable.icon);
txtName.setTextColor(getResources().getColor(R.color.red));
setContentView(R.layout.main);
txtName = (TextView) findViewById(R.id.txt_name);
```

### 在 XML 代码中使用

```xml
<TextView
    android:text="@string/hello_world"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:background="@drawable/img_back"/>
```

## 深入了解三个文件

#### 主体代码：`MainActivity.java`

```java
package jay.com.example.firstapp;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}
```

#### 布局文件：`activity_main.xml`

```xml
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />
</RelativeLayout>
```

#### Android 配置文件：`AndroidManifest.xml`

```xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="jay.com.example.firstapp">
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity" android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>
```

除了上述内容，`AndroidManifest.xml` 中还需声明权限和组件。

【Android Java】Android工程的相关文件说明

## 应用清单

每个应用的根目录中都必须包含一个 `AndroidManifest.xml` 文件（且文件名精确无误）。清单文件向 Android 系统提供应用的必要信息，系统必须具有这些信息方可运行应用的任何代码。

### 清单文件主要功能

此外，清单文件还可执行以下操作：
- **为应用的 Java 软件包命名**：软件包名称充当应用的唯一标识符。
- **描述应用的各个组件**：包括 Activity、服务、广播接收器和内容提供程序。它还为实现每个组件的类命名并发布其功能，如可以处理的 Intent 消息。
- **确定托管应用组件的进程**。
- **声明应用权限**：访问 API 中受保护部分所需的权限和与其他应用交互所需的权限。
- **列出 Instrumentation 类**：提供分析和其他信息（仅在开发阶段）。
- **声明应用所需的最低 Android API 级别**。
- **列出应用必须链接到的库**。



> **注**：准备在 Chromebook 上运行的 Android 应用时，要考虑一些重要的硬件和软件功能限制。详见 Chromebook 的应用清单兼容性文档。

## 清单文件结构

下面的代码段显示了清单文件的通用结构及其可包含的每个元素：
```xml
<?xml version="1.0" encoding="utf-8"?>
<manifest>
    <uses-permission />
    <permission />
    ...
    <application>
        <activity>
            <intent-filter>
                <action />
                <category />
                <data />
            </intent-filter>
            <meta-data />
        </activity>
        ...
    </application>
</manifest>
```

### 可包含的元素

按字母顺序列出的所有合法元素：
```xml
<action> <activity> <activity-alias> <application> <category> 
<data> <grant-uri-permission> <instrumentation>
<intent-filter> <manifest> <meta-data>
<permission> <permission-group> <permission-tree>
<provider> <receiver> <service>
<supports-screens> <uses-configuration>
<uses-feature> <uses-library> <uses-permission> <uses-sdk>
```
> **注**：这些是仅有的合法元素 – 无法添加自定义元素或属性。

## 文件约定

### 元素
- **必需元素**：`<manifest>` 和 `<application>`，每个只能出现一次。
- **顺序**：`<activity-alias>` 必须在别名所指的 `<activity>` 之后。`<application>` 元素必须是 `<manifest>` 内最后一个元素。

### 属性
- 所有属性名以 `android:` 前缀开头（除根 `<manifest>` 元素的某些属性外）。

### 声明类名
通过 `name` 属性声明子类：
```xml
<manifest package="com.example.project">
    <application>
        <service android:name=".SecretService" />
    </application>
</manifest>
```

### 多个值
通过重复元素指定多个值：
```xml
<intent-filter>
    <action android:name="android.intent.action.EDIT" />
    <action android:name="android.intent.action.INSERT" />
</intent-filter>
```

### 资源值
指定资源值：
```xml
<activity android:icon="@drawable/smallPic" />
```

## 文件功能

### Intent 过滤器
组件通过 intent 过滤器公布可响应的 intent 类型：
```xml
<activity>
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>
```

### 权限
通过 `<uses-permission>` 声明应用需要的权限：
```xml
<manifest>
    <uses-permission android:name="android.permission.CALL_EMERGENCY_NUMBERS" />
</manifest>
```

通过 `<permission>` 声明应用定义的权限：
```xml
<manifest>
    <permission android:name="com.example.project.DEBIT_ACCT" />
    <uses-permission android:name="com.example.project.DEBIT_ACCT" />
    <application>
        <activity android:name="com.example.project.FreneticActivity"
                  android:permission="com.example.project.DEBIT_ACCT" />
    </application>
</manifest>
```

### 图标和标签
可设置图标和标签属性：
```xml
<application android:icon="@drawable/icon" android:label="@string/app_name">
    <activity android:label="@string/activity_name" />
</application>
```

### 库
通过 `<uses-library>` 声明应用使用的库：
```xml
<application>
    <uses-library android:name="com.example.SomeLibrary" android:required="true" />
</application>
```

## 参考
[Android 开发者文档](https://developer.android.google.cn/guide/topics/manifest/manifest-intro.html)

【Android Java】AndroidManifest.xml

## 一、基础知识

1. **Android SDK/NDK**:  
    - **Android SDK** 包含了调试器、库、模拟器、文档、实例代码和教程。  
    - **NDK** 是支持使用 C/C++ 开发的工具包，适用于原生应用程序开发。



2. **ADT**:  
    用于 Eclipse 的 Android 开发工具（ADT）插件，扩展了 Eclipse IDE，支持 Android 应用程序的创建和调试。

3. **AVD (Android Virtual Device)**:  
    AVD 是一个模拟器实例，用来模拟真实设备。

4. **Activity**:  
    Activity 是一个包含应用用户界面窗口的组件，一个应用可以有多个 Activity。Activity 是所有程序的核心，具有自己的生命周期，由系统控制，程序无法改变。

5. **Intent**:  
    Intent 是 Android 中的消息通信机制，用于组件之间的通信，实现调用者和被调用者的解耦。
    - **显式 Intent**: 通过指定具体的组件类来启动对应的组件。
    - **隐式 Intent**: 不指定组件属性，需要系统根据信息确定满足此 Intent 的组件。

6. **Toast**:  
    Toast 是 Android 中用来显示信息的一种机制，与 Dialog 不同，Toast 没有焦点，显示时间有限，自动消失。

7. **Android 操作系统**:  
    Android 是基于 Linux 的开源手机操作系统。

8. **APK (Android Package)**:  
    APK 是 Android 安装包。APK 文件实际上是 zip 格式，但后缀名修改为 APK。通过解压可以看到 .dex 文件，Dex 是 Dalvik VM 执行文件的格式。

9. **Android 四大组件**:
    - **Activity**: 一个单独的屏幕，可以显示控件并处理用户事件。
    - **Broadcast Receiver**: 处理广播的组件，通过 Context.sendBroadcast() 等方法发送广播。
    - **Service**: 在后台运行的组件，与其他组件交互，用于执行长时间的操作。
    - **Content Provider**: 用于对外共享数据，提供统一接口进行数据操作。

10. **常用布局管理器**:  
    - **LinearLayout**: 线性布局，分为水平和垂直两种单行布局。  
    - **FrameLayout**: 所有组件放在左上角，一个覆盖一个。  
    - **TableLayout**: 表格布局，每行一个 TableRow，可以增加组件。  
    - **RelativeLayout**: 相对布局，根据组件或父容器位置确定组件位置。

11. **Android 应用打包**:  
    Android 应用使用 Java 语言编写，通过 aapt 工具把编译好的代码和资源文件打包成 .apk 文件，该文件是发布和安装应用的媒介。

12. **Android 体系结构**:  
    分为四层：应用层、应用框架层、系统运行层、Linux 内核层。

13. **Dalvik 虚拟机**:  
    每个 Android 应用在自己的进程中运行，拥有独立的 Dalvik 虚拟机实例，执行 .dex 格式文件。虚拟机基于寄存器设计，可以高效运行多个虚拟系统。

14. **Activity 生命周期**:  
    - **Resumed**: 前台运行，可交互（也称 "running" 状态）。
    - **Paused**: 部分遮蔽，不可交互。
    - **Stopped**: 完全隐藏，不可见。实例和状态信息保留，但不能执行代码。

15. **Activity 之间传递数据**:
    - **Intent**: 将数据封装在 Intent 变量中，传递对象时需序列化。
    - **剪切板**: 使用系统剪切板传递数据。
    - **全局变量**: 通过全局对象传递数据。
    - **静态变量**: 使用静态属性传递数据。

16. **从 Activity 返回数据**:
    - **startActivity()**: 启动意图。
    - **startActivityForResult()**: 启动意图并获取返回结果，需实现 onActivityResult 方法。

17. **结束 Activity 生命周期**:  
    **finish()** 方法用来结束 Activity 的生命周期。

## 二、实现 DEMO

1. **利用 Intent 在两个 Activity 之间传递数据**:

    **调用者 Main.java**:
    ```java
    public class Main extends Activity {
        private Button button;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            button = findViewById(R.id.button);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Intent intent = new Intent(Main.this, OtherActivity.class);
                    intent.putExtra("name", "张三");
                    intent.putExtra("age", 123);
                    intent.putExtra("address", "北京");
                    startActivity(intent);
                }
            });
        }

        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
    }
    ```

    **被调用者 OtherActivity.java**:
    ```java
    public class OtherActivity extends Activity {
        private TextView textView;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.other);
            textView = findViewById(R.id.msg);
            Intent intent = getIntent();
            int age = intent.getIntExtra("age", 0);
            String name = intent.getStringExtra("name");
            String address = intent.getStringExtra("address");
            textView.setText("age -->>" + age + "\nname -->>" + name + "\naddress -->>" + address);
        }
    }
    ```

    **主 Activity 的布局文件 main.xml**:
    ```xml
    <Button
        android:id="@+id/button"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="测试 Intent 传递数据" />
    ```

    **被调用者的布局文件 other.xml**:
    ```xml
    <TextView
        android:id="@+id/msg"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"/>
    ```

    **在 Manifest 中配置 Activity**:
    ```xml
    <activity android:name=".Main" />
    <activity android:name=".OtherActivity" />
    ```

### android:id
这是视图的唯一标识符，可以在程序代码中通过该标识符引用对象。引用资源对象时需使用 `@` 符号，紧随 `@` 之后的是资源类型（如 `id`），然后是资源名称（如 `button/msg`）。`+` 号用于第一次定义资源 ID。

【Android Java】Android开发基础知识

## Java 的反射机制

Java 反射机制允许你在运行时获取类的详细信息，并且调用对象的方法。它的主要作用包括：
1. 判断任意对象所属的类；
2. 动态构建类的对象；
3. 获取类的成员变量和方法；
4. 调用对象的方法；
5. 生成动态代理。



### 基本示例

以下代码展示了如何使用反射获取类的所有属性：

```java
package org.example;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Main {
    public static void main(String[] args) {
        try {
            // 获取类
            Class<?> c = Class.forName("java.lang.String");

            // 获取所有属性
            Field[] fields = c.getDeclaredFields();
            StringBuffer sb = new StringBuffer();
            sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() + " {\n");

            // 遍历每个属性
            for (Field field : fields) {
                sb.append("\t");
                sb.append(Modifier.toString(field.getModifiers()) + " ");
                sb.append(field.getType().getSimpleName() + " ");
                sb.append(field.getName() + ";\n");
            }
            sb.append("}\n");
            System.out.println(sb);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
```

运行后，你会看到 `String` 类的所有属性，例如：

```text
public final class String {
	private final byte[] value;
	private final byte coder;
	private int hash;
	private boolean hashIsZero;
	private static final long serialVersionUID;
	static final boolean COMPACT_STRINGS;
	private static final ObjectStreamField[] serialPersistentFields;
	private static final char REPL;
	public static final Comparator CASE_INSENSITIVE_ORDER;
	static final byte LATIN1;
	static final byte UTF16;
}
```

### 常见的反射方法

这些方法可以帮助你在运行时获取和操作类的信息：

```java
getName()：获得类的完整名字。
getFields()：获得类的 public 类型的属性。
getDeclaredFields()：获得类的所有属性。
getMethods()：获得类的 public 类型的方法。
getDeclaredMethods()：获得类的所有方法。
getMethod(String name, Class<?>... parameterTypes)：获得特定的方法。
getConstructors()：获得类的 public 类型的构造方法。
getConstructor(Class<?>... parameterTypes)：获得特定的构造方法。
newInstance()：通过类的无参构造方法创建一个新对象。
```

以下代码展示了如何动态调用方法：

```java
// 获取方法
Method method = activityClass.getMethod("setContentView", int.class);
// 调用方法
method.invoke(activity, layoutId);
```

### 调用示例

```java
public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
    Class<?> ownerClass = owner.getClass();
    Class<?>[] argsClass = new Class<?>[args.length];
    for (int i = 0; i < args.length; i++) {
        argsClass[i] = args[i].getClass();
    }
    Method method = ownerClass.getMethod(methodName, argsClass);
    return method.invoke(owner, args);
}

public Object invokeStaticMethod(String className, String methodName, Object[] args) throws Exception {
    Class<?> ownerClass = Class.forName(className);
    Class<?>[] argsClass = new Class<?>[args.length];
    for (int i = 0; i < args.length; i++) {
        argsClass[i] = args[i].getClass();
    }
    Method method = ownerClass.getMethod(methodName, argsClass);
    return method.invoke(null, args);
}
```

Java中反射相关的类包括：

```text
java.lang.Class: 代表类文件的对象
java.lang.reflect.Constructor: 代表构造方法
java.lang.reflect.Field: 代表成员变量
java.lang.reflect.Method: 代表成员方法
java.lang.reflect.Modifier: 判断方法类型
java.lang.annotation.Annotation: 代表注解
```

## Java 注解

注解是Java的元数据，可以为代码提供信息。注解本身通过反射进行解释和处理。常见注解如 `@Override` 表示方法重写。

### 注解示例

```java
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}
```

元注解有如下类型：

```java
@Retention(RetentionPolicy.SOURCE) // 编译时丢弃
@Retention(RetentionPolicy.CLASS)  // 默认类型，编译时可用
@Retention(RetentionPolicy.RUNTIME) // 运行时可通过反射获取
```

```java
@Target(ElementType.TYPE)       // 作用于类
@Target(ElementType.FIELD)      // 作用于字段
@Target(ElementType.METHOD)     // 作用于方法
@Target(ElementType.PARAMETER)  // 作用于参数
@Target(ElementType.CONSTRUCTOR) // 作用于构造方法
@Target(ElementType.ANNOTATION_TYPE)  // 作用于注解
@Target(ElementType.PACKAGE)   // 作用于包
```

### Android 中的注解

在Android中，注解可以简化代码，尤其是视图绑定，如下所示：

#### MainActivity 示例

```java
@ContentView(R.layout.activity_main)
public class MainActivity extends AppCompatActivity {
    @ViewInject(R.id.button1)
    private Button button1;
    @ViewInject(R.id.button2)
    private Button button2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        AnnotateUtils.inject(this);
        button1.setText("Button 1");
        button2.setText("Button 2");
    }
}
```

#### 实现注解支持的工具类

```java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ContentView {
    int value();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
    int value();
}

public class AnnotateUtils {
    public static void inject(Activity activity) {
        injectContentView(activity);
        injectViews(activity);
    }

    private static void injectContentView(Activity activity) {
        Class<? extends Activity> clazz = activity.getClass();
        ContentView contentView = clazz.getAnnotation(ContentView.class);
        if (contentView != null) {
            try {
                Method method = clazz.getMethod("setContentView", int.class);
                method.invoke(activity, contentView.value());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static void injectViews(Activity activity) {
        Class<? extends Activity> clazz = activity.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            ViewInject viewInject = field.getAnnotation(ViewInject.class);
            if (viewInject != null) {
                try {
                    field.setAccessible(true);
                    field.set(activity, activity.findViewById(viewInject.value()));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
```

以上代码展示了如何通过注解简化视图绑定，从而减少冗余代码。这样可以使代码更简洁易读。

## Reference
[Android注解与反射机制](http://efany.github.io/2016/04/02/Android%E6%B3%A8%E8%A7%A3%E4%B8%8E%E5%8F%8D%E5%B0%84%E6%9C%BA%E5%88%B6/)