前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Android程序中,内嵌ELF可执行文件-- Android开发C语言混合编程总结

Android程序中,内嵌ELF可执行文件-- Android开发C语言混合编程总结

作者头像
俺踏月色而来
发布2019-06-15 15:55:48
1.7K0
发布2019-06-15 15:55:48
举报
文章被收录于专栏:月色的自留地
前言

都知道的,Android基于Linux系统,然后覆盖了一层由Java虚拟机为核心的壳系统。跟一般常见的Linux+Java系统不同的,是其中有对硬件驱动进行支持,以避开GPL开源协议限制的HAL硬件抽象层。 大多数时候,我们使用JVM语言进行编程,比如传统的Java或者新贵Kotlin。碰到对速度比较敏感的项目,比如游戏,比如视频播放。我们就会用到Android的JNI技术,使用NDK的支持,利用C++开发高计算量的模块,供给上层的Java程序调用。 本文先从一个最简单的JNI例子来开始介绍Android中Java和C++的混合编程,随后再介绍Android直接调用ELF命令行程序的规范方法,以及调用混合了第三方库略微复杂的命令行程序。

Android Studio配置

第一个配置是安装Android的SDK,这是开发Android程序必须的。 进入Android Studio的设置界面,Mac的快捷键是Command+,,Windows和Linux版本请自行从菜单中选择。 在设置界面中,从左侧顺序选择:Appearance&Behavior -> System Settings -> Android SDK,可以进入到SDK的设置。

右侧的SDK版本列表中,最前面显示了✔️或者后面显示了Installed,表示该版本的SDK已经安装。通常如果没有特殊需要,只安装1个最新版本的SDK即可。图中我是因为某些项目特殊的要求,安装了两个特定不同版本的SDK。 希望安装某版本的SDK,只要点选相应行最前面的多选框,然后单击右下角确认按钮即可安装。 如果不是自己从头开始,而是接手了其他开发人员的源码,源码中可能指定了特定版本的SDK。这时候可以修改其项目配置文件中版本的设置,到你安装的SDK版本。更简单的方法是直接在这里安装对应的SDK,防止因为版本依赖出现的很多繁琐问题。

第二个配置的是NDK,还在刚才SDK设置的界面中,点击界面上侧中间的“SDK Tools”标签,可以进入到NDK设置的界面。

NDK的设置没有那么多的选择,只要安装就好,已经安装碰到有新版本,也可以随性选择更新或者使用老版本继续。NDK不同版本间的兼容性都还不错,大多都不用担心。 NDK的设置是Android开发中,Java/C混合编程需要的。

第三个配置是增加一个外部工具javah,这个工具是将Java编写的“包装”文件,转换一个C/C++的.h文件。虽然Java/C++都是面向对象语言,但两者的面向对象实现是不同的。所以在Java中某个类的方法,转换到C++的世界中,是使用很长的函数名来做区分。这种情况使用手工编写虽然效果一样,但很容易出错,使用javah工具则能自动完成。 在Android Studio设置界面左侧的列表中,顺序选择Tools -> External Tools,单击右侧界面左下角的“+”,新建一个工具,比如就叫"javah"。

其中三个需要设置的内容分别是:

  • javah程序路径:$JDKPath$/bin/javah,这个跟jdk安装的路径有关。
  • 命令行参数:-classpath . -jni -d $ModuleFileDir$/src/main/jni $FileClass$,主要指定输出路径。
  • 工作目录:$ModuleFileDir$/src/main/Java,当前项目路径。

至此Android Studio的主要设置就完成了,当然只是最基本必须的设置,如果自己还有其它需求,类似git仓库地址等,可以再自行设置。 下面就可以开始进行项目的开发。

先准备一个基本的Android程序

在Android Studio界面选择New Project,如果是在开始界面,直接点击主界面上的按钮;也可以在文件菜单中选择。

选择基本的Empty Activity就好。

接着是项目的设置,项目名称、存储位置这些都不用说了,最低的API版本决定了你的程序可以在最低什么版本的Android手机上执行,如果没有特殊需要,尽量可以低一点,毕竟Android手机的升级比例,比iOS是低了好多倍的。 这样,项目就建立完成,Android Studio使用标准模板,对项目做了初始化。我们可以在这个基础上再添加自己的内容。

从屏幕左侧项目文件的列表中,选择app -> res -> layout -> acitvity_main.xml文件,文件会在右侧打开,模式是交互式的界面设计器。在其中,按照下图的样子,我们增加一个TextView控件和一个按钮。文本框是为了将来显示输出的结果,按钮当然就是开始执行的触发器。

TextView控件我们修改一下名字,叫textView1。按钮的名字改为button1,另外为按钮的onClick属性增添一个调用:bt1_click。 界面部分就完成了,记着存盘,然后可以关掉这个文件。

这时候,Android Studio界面会显示在MainActivity.java文件的位置。这是新建项目之后自动打开的文件,也是这个项目的主窗口程序文件。我们首先编辑窗口布局文件的时候,这个文件被隐藏在了后面。 我们在文件的库引用部分,增加如下两行:

代码语言:javascript
复制
import android.widget.TextView;
import android.view.View;

这两行是我们接下来的程序会使用到的库引用。 在类的变量声明部分,增加这样两行:

代码语言:javascript
复制
    TextView textview1;
    int c=0;

第一行是声明一个文本框,用于关联到刚才界面编辑器中加入的文本框。 c变量就是一个简单的计数器,我们希望每点击一次按钮,这个计数器累加1,从而确认我们每次点击都被响应了,而不是程序没有任何反馈给用户。 在onCreate函数的最后,增加关联文本框的代码:

代码语言:javascript
复制
        textview1=(TextView)findViewById(R.id.textView1);

R.id.后面的textView1就是我们在界面编辑的时候,为文本框起的名字。 接着,在类的最后,增加按钮点击响应的处理函数:

代码语言:javascript
复制
    public void bt1_click(View view){
        c = c+1;
        textview1.setText("click:"+c);
    }

清晰起见,我们把这部分完成的代码再抄过来一遍:

代码语言:javascript
复制
package com.test.calljni;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import android.view.View;

public class MainActivity extends AppCompatActivity {

    TextView textview1;
    int c=0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textview1=(TextView)findViewById(R.id.textView1);
    }
    public void bt1_click(View view){
        c = c+1;
        textview1.setText("click:"+c);
    }
}

程序完成,可以从Build菜单选择Make Project编译项目。然后在Run菜单选择Run 'app'。 如果是第一次使用Android Studio,你还可能会被提醒需要你新建一个Android模拟器来执行程序。当然也可以把打开了调试功能的Android手机插在电脑上进行真机调试。 执行的结果如图:

点击两次按钮后,画面变为:

好了,我们的基本实验平台准备完成,下面才是进入正题。

调用JNI库

每个JNI库都分为两部分,一个是C++编写的.so动态链接库,另一部分则是Java对这个动态链接库的封装。我们先从Java部分看起。

编写JNI库的Java封装类

开始写这个JNI库之前,我们首先要对这个库的总体功能、结构划分、接口类型充分做好规划,这样才能保证两种语言之间的顺畅调用。因为尚没有一种工具可以同时有效的对两种语言进行跟踪调试,所以在接口部分如果碰到问题,往往只能在大量的日志输出中去查找线索,费时费力。 作为一个简单的演示,我们的JNI库功能很简单,从Java封装的角度看,我们有一个名为JniLib的Java类,其中包含一个方法,叫callToCpp,这个方法,将会在C++中来实现。 在文件列表中,选择MainActivity.java所在的包名,点击右键,选择New->Java Class。 一切选用默认设置,类名为JniLib。

Android Studio会自动生成并打开一个JniLib.java文件。其中只有一个而空白的类定义。我们在其中继续编写自己的内容。 这个封装类的代码非常简单,我们直接列出全部:

代码语言:javascript
复制
package com.test.calljni;

public class JniLib {
    static {
        System.loadLibrary("JniLib");
    }

    public static native String callToCpp();
}

其中的静态部分,相当于构造函数了,直接载入一个动态链接库,名称为“JniLib”。这个是对于Java来说的库名,实际对应的文件名将是libJniLib.so。就是说,Android在载入动态链接库的时候,自动在给定的链接库名称前面添加“lib”,后面添加“.so”后缀。这个我们在后面还会更直观的展示。 接着是声明一个native类型的函数,callToCpp(),native表示这个函数将在刚刚载入的libJniLib.so中实现,也就是将由C++来实现。

由封装类生成C++头文件

下面是利用这个JniLib类,生成C++使用的.h头文件。 在Android Studio界面的左侧列表中,用鼠标右键点击JniLib文件,弹出菜单中选择External Tools -> javah,这个javah就是我们前面建立的附加工具。

此时最好将Android Studio左侧的视图从默认的“Android”方式修改到“Project”方式,这样能更清晰的看到目录层次关系。 随后左侧列表中,跟Java文件夹同级,会出现一个jni文件夹,其中有一个文件:com_test_calljni_JniLib.h,这就是刚才由javah自动生成的。 头文件生成到src/main/jni目录,这是我们在javah扩展工具设定的时候所确定下来的。 在列表中双击com_test_calljni_JniLib.h文件打开,其内容为:

代码语言:javascript
复制
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_test_calljni_JniLib */

#ifndef _Included_com_test_calljni_JniLib
#define _Included_com_test_calljni_JniLib
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_test_calljni_JniLib
 * Method:    callToCpp
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_test_calljni_JniLib_callToCpp
  (JNIEnv *, jclass);

#ifdef __cplusplus
}
#endif
#endif

Java_com_test_calljni_JniLib_callToCpp函数定义这一行,对应就是我们在Java JniLib类中所声明的callToCpp方法。整个函数名中包含了封装语言Java/Java包名com.test.calljni/类名JniLib/方法名callToCpp几个部分。 请注意文件第一行的提醒信息,这个头文件的内容不要自行修改,如果修改Java封装文件JniLib.java导致了类名、函数名的变化,应当重复上一步,使用javah工具重新完整生成头文件。

C++实现JNI库

继续用C++编写我们的函数实现。用鼠标右键点击列表中的jni文件夹,新建一个c++源文件,名称定为JniLib.cpp。 内容如下:

代码语言:javascript
复制
#include "com_test_calljni_JniLib.h"

JNIEXPORT jstring JNICALL Java_com_test_calljni_JniLib_callToCpp
  (JNIEnv *env, jclass){
    return (*env).NewStringUTF("从cpp返回的文本。");
  };

c++代码中,首先是引用刚才由javah生成的头文件,这是为了保证c++中定义的函数,严格吻合Java封装类中所指定的类型。 函数的定义比较长,可以从.h文件中直接拷贝进来。因为JNIEnv参数我们会用到,所以我们在后面添加一个具体的变量名,这里用“env”。 函数中只有一条语句,就是返回一个文本字符串,使用JNI中提供的NewStringUTF函数把这个C++的字符串转换为一个Java的String对象。

NDK编译脚本

使用NDK系统编译JNI库,还需要有两个文件,都将位于src/main/jni文件夹中,一个是Application.mk文件,内容只有一行:

代码语言:javascript
复制
APP_ABI := all

ABI是应用程序二进制接口的缩写,指的是Android主机的CPU类型,不同CPU需要有不同的二进制接口类型。 Java是一种跨CPU的语言,并不要求指定特定的CPU。而C/C++语言,在不同的CPU上,都需要进行特定的编译。 这里设定APP_ABI为all,指的是我们写的这个JniLib库,将接受所有NDK支持的CPU类型。NDK在编译的时候,会自动编译多个不同CPU需要的动态链接库。并都打包在最终的APK文件中。 在不同的Android系统安装的时候,会自动选择正确的CPU类型安装其中一种。

接着看第二个NDK编译所需文件,Android.mk:

代码语言:javascript
复制
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)
LOCAL_MODULE := JniLib
LOCAL_SRC_FILES := JniLib.cpp
include $(BUILD_SHARED_LIBRARY)

用过Makefile的人应当看上去感觉很熟悉。这个就相当于Makefile的主文件,用于描述如何编译我们的JNI库。当然因为我们其中大量的使用了NDK已有的环境变量和脚本,所以Applcation.mk/Android.mk实际都将被NDK的主体Makefile调用,最终完成完整的编译。 其中LOCAL_MODULE变量所指定的名称,就是我们编译之后的模块名称,这个跟JniLib.java中加载的类名,必须是一致的。

Gradle自动编译NDK项目

有了这些,如果用过命令行的话,我们可以直接在命令行对JNI部分进行编译了。 但作为一个完整的程序,我们更希望JNI部分,也能在整体Android Studio项目编译的时候编译,并一起打包进APK。 所以我们修改一下本项目的Gradle脚本,增加NDK编译的配置。Gradle是Android Studio中所采用的开源工具,用于项目的管理和自动构建。 在Android Studio左侧列表中找到app/build.gradle文件,双击打开。在项目的主目录下还有一个build.gradle文件,不要误选到那一个。 在android一节中,defaultConfig之下、buildTypes之上增加如下代码:

代码语言:javascript
复制
    externalNativeBuild {
        ndkBuild {
            path "src/main/jni/Android.mk"
        }
    }

表示本项目使用ndk编译JNI库,本项目JNI库的编译脚本为src/main/jni/Android.mk文件。还可以选择使用CMAKE系统来编译JNI项目,不过为了不扩展太大的话题,这里就不讲了。对CMAKE情有独钟的开发者可以搜索相关资料。 为了能看的清楚,贴一次完整的app/build.gradle文件:

代码语言:javascript
复制
apply plugin: 'com.android.application'

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "com.test.calljni"
        minSdkVersion 19
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    externalNativeBuild {
        ndkBuild {
            path "src/main/jni/Android.mk"
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
}

至此,JNI部分的完整定义就完成了。

在Java中调用JNI库

JNI库的效果,还要修改一下我们程序的MainActivity类,才能体现出来。不然JNI库会被编译,会被打包,但并没有什么用。 首先修改项目的布局文件activity_main.xml文件,在当前按钮的右边,再增加一个按钮,名称为button2,onClick设置为bt2_click,顺便也为按钮设置一个新的显示字符串“CALLJNI”。修改完成存盘,关闭文件。 这个小例子重点是说明同C/C++语言的混合编程,所以很多细节都从简了,比如刚才按钮的显示信息,都应当是定义在资源文件中的,而不是在这里直接使用常量字符串。常量字符串虽然简便,但无法完成多国语言自动切换等基本功能,在正式的项目中应当避免这样使用。 接着在MainActivity.java文件中,增加点击事件处理程序,添加在bt1_click定义的下面就成:

代码语言:javascript
复制
    public void bt2_click(View view){
        c = c+1;
        textview1.setText("click:"+c+"\n"+JniLib.callToCpp());
    }

现在可以完整的编译一遍了,如果没有错误发生,就在模拟器中执行来测试。

点击CALLJNI按钮后,文本框显示的信息表示JNI正常执行了。

解析包含JNI库的APK安装文件

先上一张apk包的文件结构图片吧:

包含JNI库的安装包,比平常的安装包多一个lib文件夹。其中按照支持的CPU类型,再细致分类。最终里面是JNI库的二进制文件。 在我们这个例子中,就是libJniLib.so,如同前面说过的。 APK包安装的时候,根据确定的硬件平台,实际只有一个对应的.so文件会被安装的设备上。

调用一个完整的命令行可执行文件

调用完整的可执行文件,这在Android中并不是官方推荐的。但通常基于Linux系统的编程,这又是不可避免的。很多必要操作,如果开发系统的SDK支持不足,或者用起来不方便。都可以通过直接访问系统层参数文件或者系统层可执行文件来完成。 不同的操作系统,有不同的可执行文件格式。比如Windows的EXE/PE格式,macOS的Mach-O。在Linux上,就是ELF格式。 作为C语言为主要编程工具的Linux系统,拥有庞大的ELF可执行资源,几乎所有的程序都是直接、或者间接由ELF可执行程序完成的,甚至包括JVM本身。 一些新兴语言,比如golang,也提供了直接生成Android二进制文件的交叉编译功能。 所以让Android程序直接可以同ELF可执行程序互动,不仅仅是同C语言混合编程的问题,而是这样可以获得大量社区资源的支持。很多开源项目拿来,很少的修改,就可以在Android程序的背后发挥作用。

早期的Android系统调用可执行程序非常容易,把编译好的程序拷贝到Android中,设置为可执行属性,就可以执行了。 随着Android系统的升级,安全性越来越好,除非root,上面这种方式已经不灵了。越来越多的限制让直接执行内嵌的可执行文件变得不再可行。

在当前的Android版本中,在APK程序中内嵌可执行文件,需要通过以下几个步骤:

  • 在NDK中编译对应的源代码。或者在其它语言环境中,使用对应工具,生成在Android环境可以执行的二进制代码。
  • 除了.so之外的编译结果,并不会自动打包到APK中。所以编译出的二进制代码,需要作为数据文件,放入APK的资源区。
  • 在Java代码中,根据检测到的CPU类型,把对应的可执行文件,从数据区拷贝到Android设备上,并设置为可执行。
  • 在Java代码中调用可执行程序,并获取结果。
编译可执行文件

首先当然是准备一个C/C++代码,比如我们用一个最经典的Hello World。这么多年以来,这居然是兼容性最好的代码了:)

代码语言:javascript
复制
#include<stdio.h>

int main(int argc, char **argv){
    printf("你好世界, I'm hello.c\n");
    return 0;
}

文件名叫hello.c,放到jni文件夹下面。

然后配置Android.mk文件,以编译这个代码。 把下面的代码放置到Android.mk的最后:

代码语言:javascript
复制
include $(CLEAR_VARS)
LOCAL_MODULE := hello
LOCAL_SRC_FILES := hello.c
include $(BUILD_EXECUTABLE)

仔细看,其实只有最后一行有区别,根据英文应当能理解含义,就是编译为可执行文件的意思。

编译结果打包进入APK

因为内置可执行文件并不是官方推荐的方式,所以编译的结果,并不会被自动打包到安装包APK。 经由Gradle调用ndk-build编译的结果保存在如下的路径:

代码语言:javascript
复制
# Debug版本
app/build/intermediates/ndkBuild/debug/obj/local/
# Release版本
app/build/intermediates/ndkBuild/release/obj/local/

同样在Gradle的设置中,可以指定把具体的内容打包到Android的assets文件夹中。assets文件夹中包含的是程序运行所需的资源文件,所以这里,也是把可执行文件,当做资源、数据文件,嵌入在APK中。 请把下面代码,放置到app/build.gradle文件,android.defaultConfig一节的最后:

代码语言:javascript
复制
        sourceSets{
            main{
                assets{
                    srcDirs = ['build/intermediates/ndkBuild/debug/obj/local']
                }
            }
        }

sourceSets.main.assets.srcDirs的设置实际是一个数组,可以包含多个路径。如果开发的项目还有别的数据文件需要打包,可以在这里增添自己的内容。 注意上面示例中设置中的路径,是个不完美的地方。当前指向了debug调试编译输出的结果。在开发完成,正式投产的时候,应当换到release输出结果,也即:build/intermediates/ndkBuild/release/obj/local。不然包含的二进制文件中间会有调试信息,除了文件尺寸会大,也造成不安全因素。 其实我个人常用的方式,是直接用Release方式编译一遍整个项目,然后release文件夹中就会有二进制编译结果。随后Gradle的设置,就一直保持在release版本的打包。反正你也不可能用Android Studio对C/C++代码进行调试,那个工作你肯定是使用另外的开发工具完成的。

然后事情并没有结束,我们打开编译结果的文件夹看一看,是类似下面的样子:

其中同样会根据CPU类型不同,分为几个文件夹,这是预料之中的。但中间除了有我们需要的hello可执行文件,还会有本已打包的JNI库.so文件,以及一些编译输出信息和中间文件。而这些,就成为了我们的垃圾文件,需要排除在外。 可以把下面代码,添加在app/build.gradle中,externalNativeBuild上面的位置,跟externalNativeBuild处在同一级:

代码语言:javascript
复制
    aaptOptions {
        ignoreAssetsPattern '!*.txt:!*.so:!*debug:!*release:!*.a'
    }

这里要吐槽一下Android Studio Gradle脚本的设计。通常讲,ignoreAssetsPattern关键词已经有了“忽略、排除”的含义,是个否定词。而在其中的设置中,又对每个需要排除的内容,前面增加“!”否定,实在是反人类啊......

现在如果编译一遍,看看打包的结果,当然也只是完成了打包,我们还没有执行这个程序。

APK中多了一个assets文件夹,其中根据CPU类型分类,hello已经在里面了。

把可执行程序拷贝到Android系统

这个工作是最复杂的部分,至少比我们演示中显示一个字符串复杂多了。 好在这个程序非常通用,把这个类留着,以后所有同类程序都可以直接拿来使用。 在java文件夹自己的包名上右键点击鼠标,增加一个Java类,命名为CopyElfs。在生成的java文件中,把下面的代码帖进去:

代码语言:javascript
复制
package com.test.calljni;

import android.content.Context;
import android.content.res.AssetManager;
import android.util.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import android.os.Build;

public class CopyElfs {
    String TAG="Ce_Debug:";
    Context ct;
    String appFileDirectory,executableFilePath;
    AssetManager assetManager;
    List resList;
    String cpuType;
    String[] assetsFiles={
            "hello"
    };

    CopyElfs(Context c){
        ct=c;
        appFileDirectory = ct.getFilesDir().getPath();
        executableFilePath = appFileDirectory + "/executable";

        // cpuType = Build.SUPPORTED_ABIS[0];
        cpuType = Build.CPU_ABI;
        assetManager = ct.getAssets();
        try {
            resList = Arrays.asList(ct.getAssets().list(cpuType+"/"));
            Log.d(TAG,"get assets list:"+resList.toString());
        } catch (IOException e){
            Log.e(TAG, "Error list assets folder:", e);
        }
    }
    boolean resFileExist(String filename){
        File f=new File(executableFilePath+"/"+filename);
        if (f.exists())
            return true;
        return false;
    }
    void copyFile(InputStream in, OutputStream out){
        try {
            byte[] buf = new byte[1024];
            int len;
            while ((len = in.read(buf)) > 0) {
                out.write(buf, 0, len);
            }
        } catch (IOException e){
            Log.e(TAG, "Failed to read/write asset file: ", e);
        }
    };
    private void copyAssets(String filename) {
        InputStream in = null;
        OutputStream out = null;
        Log.d(TAG, "Attempting to copy this file: " + filename);

        try {
            in = assetManager.open(cpuType+"/"+filename);
            File outFile = new File(executableFilePath, filename);
            out = new FileOutputStream(outFile);
            copyFile(in, out);
            in.close();
            in = null;
            out.flush();
            out.close();
            out = null;
        } catch(IOException e) {
            Log.e(TAG, "Failed to copy asset file: " + filename, e);
        }
        Log.d(TAG, "Copy success: " + filename);
    }
    void copyAll2Data(){
        int i;

        File folder=new File(executableFilePath);
        if (!folder.exists()){
            folder.mkdir();
        }

        for(i=0;i<assetsFiles.length;i++){
            if (!resFileExist(assetsFiles[i])){
                copyAssets(assetsFiles[i]);
                File execFile = new File(executableFilePath+"/"+assetsFiles[i]);
                execFile.setExecutable(true);
            }
        }
    }

    String getExecutableFilePath(){
        return executableFilePath;
    }
}

类成员assetsFiles数组中,可以包含多个可执行文件,把文件名放在这里,就会被拷贝到Android设备的/data/data/包名/files/excutable/文件夹,并设置为可以执行。 接着在MainActivity类的onCreate成员中,增加对拷贝可执行文件功能的调用:

代码语言:javascript
复制
    CopyElfs ce;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textview1=(TextView)findViewById(R.id.textView1);

        ce = new CopyElfs(getBaseContext());
        ce.copyAll2Data();
    }
执行对Elf执行文件的调用

做了这么多准备性工作,开始真正对程序的调用。 首先还是修改布局文件,再增加一个按钮,名称叫button3,显示字符串是“CALLELF”,onClick的事件处理函数是bt3_click。

这次要添加的代码不仅仅是bt3_click方法,还要对调用命令行程序以及获取其结果单独抽象为一个方法。 考虑到还要增加一些对应的类成员变量,和库文件的引用。我们把完整的MainActivity.java代码列出来:

代码语言:javascript
复制
package com.test.calljni;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import android.view.View;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import android.util.Log;

public class MainActivity extends AppCompatActivity {
    String TAG="Main_Debug:";
    TextView textview1;
    int c=0;
    CopyElfs ce;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textview1=(TextView)findViewById(R.id.textView1);

        ce = new CopyElfs(getBaseContext());
        ce.copyAll2Data();
    }
    public void bt1_click(View view){
        c = c+1;
        textview1.setText("click:"+c);
    }
    public void bt2_click(View view){
        c = c+1;
        textview1.setText("click:"+c+"\n"+JniLib.callToCpp());
    }
    public String callElf(String cmd){
        Process p;
        String tmpText;
        String execResult = "";

        try {
            p = Runtime.getRuntime().exec(ce.getExecutableFilePath() + "/"+cmd);
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
            while ((tmpText = br.readLine()) != null) {
                execResult += tmpText+"\n";
            }
        }catch (IOException e){
            Log.i(TAG,e.toString());
        }
        return execResult;
    }

    public void bt3_click(View view){
        c = c+1;
        textview1.setText("click:"+c+"\n"+callElf("hello"));
    }
}

现在已经完整了,可以编译然后在模拟器执行来尝试一下。

还可以详细探究可执行文件,拷贝到Android设备之后的细节。这个使用adb工具连接到设备上就能看出来,请看下面执行的截图:

编译带有扩展库的可执行文件

前面的例子,我们已经认识到了NDK的强大。而ndk-build编译工具,基本属于一个Makefile的工作方式。 然而在Linux庞大的开源社区中,多种编译管理工具都同时存在。其实不仅仅Android,即便在桌面版的Linux版本中,编译不同的软件包,也是一件费时费力的事情。 因此想继承开源社区的庞大优势,除了上面讲到的这些必要工作,把软件包编译到Android的环境中,是最主要需要完成的工作。 这个话题太大,内容太多也太分散,我们的文章是远远无法涵盖的。以最常用的OpenSSL开源库为例,GitHub上有一个编译脚本,值得参考: https://github.com/lllkey/android-openssl-build

我们下面只演示一下,在自己的程序中,调用openssl库的方式。实际在Android SDK以及Java标准库中,都已经有很多编、解码功能足以满足应用。所以这里只是用于演示操作的方法,正式开发中,要根据实际需要选择开源库来使用。 首先我们把上面编译好的openssl库下载到本地,放到跟当前的Android项目平级就好,其实路径随意自己定,只要在接下来的设置中,指到正确的路径就没有问题。

代码语言:javascript
复制
$ git clone https://github.com/lllkey/android-openssl-build.git

因为这个开源库并非我们项目的一部分,我们只把它的编译结果,链接到我们的项目中:

代码语言:javascript
复制
$ cd calljni/app/src/main/jni
$ ln -s /home/andrew/dev/android/android-openssl-build/result/ openssl
#注意上面的路径,应当是你clone下来的真实路径
$ ls -lh openssl/
total 0
drwxr-xr-x  4 andrew  staff   136B Jun  4 08:48 arm64-v8a
drwxr-xr-x  4 andrew  staff   136B Jun  4 08:48 armeabi-v7a
drwxr-xr-x  4 andrew  staff   136B Jun  4 08:48 x86
drwxr-xr-x  4 andrew  staff   136B Jun  4 08:48 x86_64

下面我们写一个小程序,用于调用openssl库中的md5编码功能,程序名为md5.c,放置在jni路径下面:

代码语言:javascript
复制
#include <stdio.h>
#include <string.h>
#include <openssl/md5.h>

void openssl_md5(const char *data, int size, char *rs){
    unsigned char buf[16];

    memset(buf,0,16);

    MD5_CTX c;
    MD5_Init(&c);
    MD5_Update(&c,data,size);
    MD5_Final(buf,&c);

    char tmp[3];
    strcpy(rs,"");
    int i;
    for (i = 0; i < 16; i++){
        sprintf(tmp,"%02x",buf[i]);
        strcat(rs,tmp);
    }
}

int main(int argc, char **argv){
    if (argc != 2){
        printf("Wrong argument.\n");
        return 1;
    }
    char md5str[33];
    openssl_md5(argv[1],strlen(argv[1]),md5str);
    printf("%s\n",md5str);
    return 0;
}

然后是修改Android.mk编译脚本,这次增加的是三部分。两个是已经编译完成的openssl Android版本库;一个是我们新增的md5.c编译。编译时还要满足,根据不同的CPU类型,选择不同的openssl库,并且编译对应的CPU版本md5可执行文件。这个过程中,需要使用不同的预定义环境参量来完成这个工作:

代码语言:javascript
复制
include $(CLEAR_VARS)
LOCAL_MODULE    := ssl
LOCAL_SRC_FILES := $(LOCAL_PATH)/openssl/$(TARGET_ARCH_ABI)/lib/libssl.a
include $(PREBUILT_STATIC_LIBRARY)

include $(CLEAR_VARS)
LOCAL_MODULE    := crypto
LOCAL_SRC_FILES := $(LOCAL_PATH)/openssl/$(TARGET_ARCH_ABI)/lib/libcrypto.a
include $(PREBUILT_STATIC_LIBRARY)

include $(CLEAR_VARS)
LOCAL_SHARED_LIBRARIES := \
    ssl \
    crypto
LOCAL_C_INCLUDES += $(LOCAL_PATH)/openssl/$(TARGET_ARCH_ABI)/include
LOCAL_MODULE := md5
LOCAL_SRC_FILES := md5.c
include $(BUILD_EXECUTABLE)

上面的代码中:

  • $(PREBUILT_STATIC_LIBRARY)指定了预定义的静态库文件
  • $(LOCAL_PATH)就是指jni文件夹路径
  • $(TARGET_ARCH_ABI)是根据目标CPU的ABI不同,选择不同的库文件和C语言头文件。

想必你也想到了,还要在MainActivity.java中,增加调用md5的代码,当然还有layout文件:

按键响应代码:

代码语言:javascript
复制
    public void bt4_click(View view){
        c = c+1;
        textview1.setText("click:"+c+"\n"+callElf("md5 testString"));
    }

作为md5参数的字符串,在正式的程序中,肯定应当是从某些计算中获取,或者从屏幕的输入框读取。这里直接使用一个常量“testString”。 最后还有特别容易忘的一个地方,就是CopyElfs中可执行文件的列表:

代码语言:javascript
复制
    String[] assetsFiles={
            "hello","md5"
    };

不得不承认,有了上一小节的基础,增加个可执行程序或者第三方库,都不算什么工作量。 程序的执行结果如下:

还可以在台式电脑中验证一下计算的结果:

代码语言:javascript
复制
$ echo -n "testString" | md5
536788f4dbdffeecfbb8f350a941eea3
使用第三方库的其它注意事项

md5程序,使用了openssl的静态链接库.a文件。在Android4之后的版本中,如果不做root,似乎暂时没有好办法使用.so动态链接库。 JNI则可以使用.so文件,这时候在Android.mk中,应当使用$(PREBUILT_SHARED_LIBRARY)参量,来说明一个.so的预定义动态链接库。 使用了第三方的动态链接库,在调用JNI的时候也有额外一点需要注意,就是在载入自己的JNI库之前,必须把用到的依赖库,首先载入进来,否则直接载入JNI库会报错:

代码语言:javascript
复制
public class JniLib {
    static {
        System.loadLibrary("crypto");
        System.loadLibrary("ssl");
        System.loadLibrary("JniLib");
    }
    .......

最后是本文中所使用的示例代码: 链接: https://pan.baidu.com/s/1yDU0q5nikorSyD0av0Ue5w 提取码: 86yp

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2019-06-14 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 前言
  • Android Studio配置
  • 先准备一个基本的Android程序
  • 调用JNI库
    • 编写JNI库的Java封装类
      • 由封装类生成C++头文件
        • C++实现JNI库
        • NDK编译脚本
          • Gradle自动编译NDK项目
            • 在Java中调用JNI库
              • 解析包含JNI库的APK安装文件
              • 调用一个完整的命令行可执行文件
                • 编译可执行文件
                  • 编译结果打包进入APK
                    • 把可执行程序拷贝到Android系统
                      • 执行对Elf执行文件的调用
                      • 编译带有扩展库的可执行文件
                        • 使用第三方库的其它注意事项
                        相关产品与服务
                        云开发 CloudBase
                        云开发(Tencent CloudBase,TCB)是腾讯云提供的云原生一体化开发环境和工具平台,为200万+企业和开发者提供高可用、自动弹性扩缩的后端云服务,可用于云端一体化开发多种端应用(小程序、公众号、Web 应用等),避免了应用开发过程中繁琐的服务器搭建及运维,开发者可以专注于业务逻辑的实现,开发门槛更低,效率更高。
                        领券
                        问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档