## 一、基础知识

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/)

【Android Java】Java的反射机制

## 一. 类与文件

1. **Java文件中类的规则**
   * 一个Java文件可以包含多个类class。
   * 只能有一个public类，且文件名必须与public类名相同。这一点和matlab函数模块相似。
   * 使用`javac`编译后，会生成多个`类名.class`文件。运行时，使用`java 类名`执行具有主函数的类。

2. **Jar文件的创建与执行**
   * 多个class文件可以打包成一个jar文件。
   * 使用`java -jar test.jar`执行前，需要在`MANIFEST.MF`中定义`Main-Class`属性，例如：`Main-Class: test.someClassName`。

3. **包（package）**
   * 包用于组织相关类、接口及其他包。
   * 包对应的目录结构以`/`表示层级，例如 `E:/Java/workspace/Demo/bin/p1/p2/Test.java`。
   * 包名表示层级关系，例如 `p1.p2.Test` 表示包 `p1.p2` 下的 `Test` 类。

4. **import 导入**
   * `import`语句只能导入包中的类或接口，不能导入整个包。
   * 通常使用通配符`*`导入包下所有类或接口，例如：`import java.util.*;`。



## 二. 关键字

### final
* **修饰类**：类不能被继承。
* **修饰方法**：方法不能被重写。
* **修饰变量**：变量成为常量，只能赋值一次。

**覆盖规则**：
1. 子类覆盖父类方法时，子类方法的访问权限要大于或等于父类。
2. 静态方法只能覆盖静态方法。
3. 父类方法添加`final`后，子类不能覆盖。
4. 子类方法可以使用`super.method`调用父类方法，但不能调用父类的`private`方法。

### static
1. **静态成员（静态变量和静态方法）**
   * 随类加载而加载，且优于对象存在。
   * 被所有对象共享，可以通过类名调用（例如：`类名.成员`）。

2. **静态代码块**
   * 随类加载而执行，并且只执行一次，用于类的初始化。
   * 静态代码块执行优先于构造函数和对象初始化。

3. **注意事项**
   * 静态方法只能访问静态成员。
   * 静态方法中不能使用`this`和`super`关键字。
   * 主函数（`main`方法）是静态的。main一般是`public static void main(String[] args)` 。

### this & super
* **this**
   * 代表当前类对象的引用。
   * 可用于区分成员变量和同名的局部变量。

* **super**
   * 代表父类的引用。
   * 用于调用父类的构造函数、方法或成员变量。

### interface
* 接口中的成员默认是`public static final`（变量）和`public abstract`（方法）。
* 类与接口之间实现关系用`implements`。接口之间可用`extends`继承，且支持多继承。
* 抽象类提供部分实现，而接口只能定义抽象方法。这是抽象类的优势。

## 三. 继承

* 子类构造函数默认调用父类的无参构造函数（`super();`）。
* 如果父类没有无参构造函数，子类必须使用`super(参数列表)`调用父类构造函数。
* 如果子类构造函数使用`this`调用本类其他构造函数，则不能同时使用`super`，因为二者必须在第一行。

## 四. 多态

1. **成员变量**
   * 编译时：使用引用类型变量所属类的成员变量。
   * 运行时：也是使用引用类型变量所属类的成员变量。

2. **成员函数**
   * 编译时：使用引用类型变量所属类的方法。
   * 运行时：使用对象实际类型的方法。

3. **静态方法**
   * 编译和运行时都是使用引用类型变量所属类的静态方法。

## 五. 内部类

* **成员内部类**：直接访问外部类成员，外部类访问需创建内部类对象。
* **静态内部类**：创建时不依赖外部类对象。

示例：
```java
outer.inner in = new outer().new inner();
in.show();
```
静态内部类：
```java
outer.inner in = new outer.inner();
in.show(); 
```

```java
class Outer {
    int num = 3;
    class Inner {
        int num = 4;
        void show() {
            int num = 5;
            System.out.println(Outer.this.num);
        }
    }
    void method() {
        new Inner().show();
    }
}
```
* **局部内部类**：只能访问被`final`修饰的局部变量。
* **匿名内部类**：即匿名子类对象，用于简化代码。

示例：
```java
abstract class Demo {
    abstract void show();
}

class Outer {
    int num = 4;
    public void method() {
        new Demo() {
            void show() {
                System.out.println("show ..." + num);
            }
        }.show();
    }
}

class InnerClassDemo4 {
    public static void main(String[] args) {
        new Outer().method();
    }
}
```
错误示例：
```java
Object obj = new Object() {
    public void show() {
        System.out.println("show run");
    }
};
obj.show();
```
因为`Object`类没有`show()`方法。

典型使用场景：函数参数为接口类型时，使用匿名内部类。
```java
interface Inter {
    void show1();
    void show2();
}

class InnerClassDemo5 {
    public static void main(String[] args) {
        show(new Inter() {
            public void show1() {}
            public void show2() {}
        });
    }

    public static void show(Inter in) {
        in.show1();
        in.show2();
    }
}
```

## 六. 异常

* 函数抛出的异常需要声明或捕获，未声明的必须捕获。
* 调用抛出异常的函数需要捕获或继续抛出，未处理会编译失败。
* 使用`catch`捕获异常，无法解决时使用`throws`延续异常处理。

**自定义异常**：继承自`Exception`或`RuntimeException`。

## 七. 访问权限

类间访问权限：

<table border="1">
  <tr>
<th></th>
   <th>public</th>
   <th>protected</th>
<th>default</th>
   <th>private</th>
  </tr>
  <tr>
<td>同一类中</td>
   <td>Y</td>
   <td>Y</td>
<td>Y</td>
   <td>Y</td>
  </tr>
  <tr>
<td>同一包中</td>
   <td>Y</td>
   <td>Y</td>
<td>Y</td>
   <td>N</td>
  </tr>
<tr>
<td>子类中</td>
   <td>Y</td>
   <td>Y</td>
<td>N</td>
<td>N</td>
  </tr>
<tr>
<td>不同包中</td>
   <td>Y</td>
   <td>N</td>
<td>N</td>
   <td>N</td>
  </tr>
</table>

## 八. 线程

### 方式一：继承Thread类
```java
class SubThread extends Thread {
    public void run() {
        System.out.println("hahah");
    }
}
SubThread s = new SubThread();
s.start();
```

### 方式二：实现Runnable接口
1. 实现Runnable接口。
2. 覆盖`run`方法。
3. 通过Thread类创建线程对象，并传递Runnable对象。
4. 调用`start`方法。

好处：分离任务和线程实现，避免单继承限制。

```java
class ThreadImpl implements Runnable {
    public void run() {
        System.out.println("runnable run");
    }
}
Thread t = new Thread(new ThreadImpl());
t.start();
```

### 方式三：实现Callable接口，通过Future获取结果
1. 实现Callable接口的`call`方法，有返回值。
2. 使用FutureTask包装Callable对象。
3. 使用Thread创建并启动线程。
4. 通过FutureTask的`get`方法获取返回值。

```java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args) {
        CallableThreadTest ctt = new CallableThreadTest();
        FutureTask<Integer> ft = new FutureTask<>(ctt);
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值" + i);
            if (i == 20) {
                new Thread(ft, "有返回值的线程").start();
            }
        }
        try {
            System.out.println("子线程的返回值：" + ft.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Integer call() throws Exception {
        int i = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return i;
    }
}
```

### 三种创建线程方式对比

**Runnable、Callable接口方式**：
* 优势：可以继承其他类，适合多个线程处理同一资源。
* 劣势：编程复杂，需要`Thread.currentThread()`获取当前线程。

**Thread继承方式**：
* 优势：编写简单，直接用`this`获取当前线程。
* 劣势：无法再继承其他类。

【Android Java】Java基础

我要看一遍这个教程，加上我个人的梳理整理，作为更强大的教程。为何要学这个教程，因为我要掌握NDK的交叉编译。



原教程：

https://github.com/JnuSimba/AndroidSecNotes/tree/master


Java语言基础

[Java Basic](https://www.dong-blog.fun/post/1911)

[Java 反射机制到Android 的注解](https://www.dong-blog.fun/post/1912)


Android开发基础

[Android开发基础知识](https://www.dong-blog.fun/post/1913)

[AndroidManifest.xml](https://www.dong-blog.fun/post/1914)

[Android 工程相关文件说明](https://www.dong-blog.fun/post/1915)

[Android NDK 开发基础](https://www.dong-blog.fun/post/1916)

Android 基于监听的事件处理机制
Android Handler消息传递机制
Android 基于回调的事件处理机制
Android 安全概述

Android 安全概述
Android Linux 内核层安全
Android 本地用户空间层安全
Android 框架层安全
Android 应用层安全
Android 安全的其他话题
Android 应用安全

Android Application Security
OWASP Mobile top 10_2014
Android Activity Security
Android Broadcast Security
Android Content Provider Security
Android Logcat Security
Android Service Security
Android逆向基础

apk 反编译基础
smali 语法
ARM 寄存器简介
ARM 汇编伪指令简介
ARM 汇编指令简介
Android系统安全

Android 中堆unlink 利用学习
Android 系统漏洞挖掘
Android 调试工具

Smali Instrumentation
Ida Pro.md
Android Hook（上）
Android Hook（下）
Android Hook 框架（Cydia篇）
Android Hook 框架（XPosed篇）
Android Java 层的anti-Hook 技巧
Android 应用程序通用脱壳方法研究
Android ART 运行时（上）
Android ART 运行时（下）
初识JEBAPI
常见app加固厂商脱壳方法
Android Hook 技术防范漫谈
Android Native Hook 技术线路概述
Android Native Hook 工具实践
Android Inline Hook 的指令修复详解

Android Java NDK 教程录

标题：如何在Android Java的Ubuntu系统上编译出`libopencv_java4.so`



### 安装CMake：

```bash
cd ~
wget https://github.com/Kitware/CMake/releases/download/v3.30.3/cmake-3.30.3-linux-x86_64.tar.gz
tar -xzvf cmake-3.30.3-linux-x86_64.tar.gz
sudo ln -sf $(pwd)/cmake-3.30.3-linux-x86_64/bin/* /usr/bin/
cmake --version
```

### 安装Java支持：

```bash
sudo apt-get install ant openjdk-8-jdk -y
```

### 安装Android NDK：

```bash
wget https://dl.google.com/android/repository/android-ndk-r27b-linux.zip
unzip android-ndk-r27b-linux.zip
```

### 配置环境变量：

在`~/.bashrc`文件中添加以下内容：

```bash
export ANDROID_NDK=/ssd/xiedong/android-ndk-r27b
export PATH=$PATH:$ANDROID_NDK
export ANT_HOME=/usr/bin/ant
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export PATH=$ANT_HOME:$JAVA_HOME/bin:$PATH
```

然后使其生效：

```bash
source ~/.bashrc
```

### 验证NDK是否成功配置：

```bash
$ANDROID_NDK/ndk-build --version
# 返回以下信息即表示成功：
# GNU Make 4.3
# Built for x86_64-pc-linux-gnu
# Copyright (C) 1988-2020 Free Software Foundation, Inc.
# License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
# This is free software: you are free to change and redistribute it.
# There is NO WARRANTY, to the extent permitted by law.
```


### 配置Python支持：

确保安装了Python3.2以上版本的miniconda3，具体安装过程这里略。

### 获取并准备OpenCV源代码：

```bash
git clone https://github.com/opencv/opencv.git --depth 1
git clone https://github.com/opencv/opencv_contrib.git --depth 1
mkdir build && cd build
```

### 运行CMake配置：

```bash
cmake -D CMAKE_BUILD_TYPE=RELEASE \
      -D CMAKE_BUILD_WITH_INSTALL_RPATH=ON \
      -D ANDROID_ABI=arm64-v8a \
      -D ANDROID_PLATFORM=android-21 \
      -D CMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake \
      -D OPENCV_ENABLE_NONFREE=ON \
      -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib/modules \
      -D BUILD_opencv_freetype=ON \
      -D WITH_FREETYPE=ON \
      -D ENABLE_CXX11=ON \
      -D BUILD_TESTS=OFF \
      -D BUILD_EXAMPLES=OFF \
      -D BUILD_ANDROID_PROJECTS=OFF \
      -D BUILD_SHARED_LIBS=ON \
      -D WITH_OPENCL=OFF \
      -D BUILD_opencv_java=ON \
      -D BUILD_opencv_java_bindings_generator=ON \
      -D OPENCV_GENERATE_PKGCONFIG=ON \
      -D ANT_EXECUTABLE=/usr/bin/ant \
      ..
```

如果看到以下信息，说明Java环境配置有误：

```plaintext
-- Java:
-- ant: NO
-- Java wrappers: NO
-- Java tests: NO
```

### 编译：

```bash
make -j$(nproc)
```

当日志中出现如下提示时，表示编译成功：

```plaintext
[100%] Linking CXX shared module ../../../jni/arm64-v8a/libopencv_java4.so
```

通过以上步骤，你就可以在Android Java环境下的Ubuntu系统中成功编译出`libopencv_java4.so`库了。

Android Java Ubuntu系统如何编译出 libopencv_java4.so

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。