Home » Android » java – Hosting an executable within Android application

java – Hosting an executable within Android application

Posted by: admin April 23, 2020 Leave a comment


I am working on an Android application that depends on an ELF binary:
our Java code interacts with this binary to get things done. This
runtime needs to be started and terminated on Application startup and
application exit / on demand.


  1. I am assuming that we will be able to execute this binary using the
    Runtime.exec() API. Is there any constraints as to where I
    need to be putting my library in the folder structure? How would the system runtime locate this executable? Is there some sort of class path setting?

  2. Since the application has dependencies on this Runtime, I was
    thinking of wrapping it around a service so that it can be started or
    stopped as required. What is the best way to handle such executables
    in Android project?

  3. What are other alternatives, assuming that I do not have source code for this executable?

Please advice.


How to&Answers:

1) No, there should be no constrains, besides those that access system files and thus require root. The best place would be straight to /data/data/[your_package_name] to avoid polluting elsewhere.

2) A very thorough discussion about compiling against native libraries can be found here: http://www.aton.com/android-native-libraries-for-java-applications/ . Another option is a cross-compiler for arm (here is the one used to compile the kernel, it’s free: http://www.codesourcery.com/sgpp/lite/arm ). If you plan to maintain a service that executes your cammand, be warned that services can be stopped and restarted by android at any moment.

3) Now, if you don’t have the source code, I hope that your file is at least compiled as an arm executable. If not, I don’t see how you could even run it.

You will execute the file by running the following commands in your java class:

String myExec = "/data/data/APPNAME/FILENAME";
Process process = Runtime.getRuntime().exec(myExec);
DataOutputStream os = new DataOutputStream(process.getOutputStream());
DataInputStream osRes = new DataInputStream(process.getInputStream());

I know nothing about your executable, so you may or may not need to actually get the inputStream and outputStream.

I am assuming that running adb to push the binary file is out of the question, so
I was looking for a neat way to package it. I found a great post about including an executable in your app. Check it out here:

The important part is this one (emphasis mine):

From Android Java app, using assets folder

  • Include the binary in the assets folder.
  • Use getAssets().open(FILENAME) to get an InputStream.
  • Write it to /data/data/APPNAME (e.g. /data/data/net.gimite.nativeexe), where your application has access to write files and make it executable.
  • Run /system/bin/chmod 744 /data/data/APPNAME/FILENAME using the code above.
  • Run your executable using the code above.

The post uses the assets folder, insted of the raw folder that android suggests for static files:

Tip: If you want to save a static file in your application at compile time, save the file in your project res/raw/ directory. You can open it with openRawResource(), passing the R.raw. resource ID. This method returns an InputStream that you can use to read the file (but you cannot write to the original file).

To access the data folder, you can follow the instructions here:
Also, there’s the File#setExecutable(boolean); method that should works instead of the shell command.

So, putting everything together, I would try:

InputStream ins = context.getResources().openRawResource (R.raw.FILENAME)
byte[] buffer = new byte[ins.available()];
FileOutputStream fos = context.openFileOutput(FILENAME, Context.MODE_PRIVATE);

File file = context.getFileStreamPath (FILENAME);

Of course, all this should be done only once after installation. You can have a quick check inside onCreate() or whatever that checks for the presence of the file and executes all this commands if the file is not there.

Let me know if it works. Good luck!


Here is a complete guide for how to package and run the executable. I based it on what I found here and other links, as well as my own trial and error.

1.) In your SDK project, put the executable file in your /assets folder

2.) Programmatically get the String of that files directory (/data/data/your_app_name/files) like this

String appFileDirectory = getFilesDir().getPath();
String executableFilePath = appFileDirectory + "/executable_file";

3.) In your app’s project Java code: copy the executable file from /assets folder into your app’s “files” subfolder (usually /data/data/your_app_name/files) with a function like this:

private void copyAssets(String filename) {

AssetManager assetManager = getAssets();

InputStream in = null;
OutputStream out = null;
Log.d(TAG, "Attempting to copy this file: " + filename); // + " to: " +       assetCopyDestination);

try {
    in = assetManager.open(filename);
    Log.d(TAG, "outDir: " + appFileDirectory);
    File outFile = new File(appFileDirectory, filename);
    out = new FileOutputStream(outFile);
    copyFile(in, out);
    in = null;
    out = null;
} catch(IOException e) {
Log.e(TAG, "Failed to copy asset file: " + filename, e);

Log.d(TAG, "Copy success: " + filename);

4.) Change the file permissions on executable_file to actually make it executable. Do it with Java calls:

File execFile = new File(executableFilePath);

5.) Execute the file like this:

Process process = Runtime.getRuntime().exec(executableFilePath);

Note that any files referred to here (such as input and output files) must have their full path Strings constructed. This is because this is a separate spawned process and it has no concept of what the “pwd” is.

If you want to read the command’s stdout you can do this, but so far it’s only working for me for system commands (like “ls”), not the executable file:

BufferedReader reader = new BufferedReader(
new InputStreamReader(process.getInputStream()));
int read;
char[] buffer = new char[4096];
StringBuffer output = new StringBuffer();
while ((read = reader.read(buffer)) > 0) {
    output.append(buffer, 0, read);

Log.d(TAG, “output: ” + output.toString());


I’ve done something like this using the NDK. My strategy was to recompile the program using the NDK and write some wrapper JNI code that called into the program’s main function.

I’m not sure what the lifecycle of NDK code is like. Even services that are intended to be long-running can be started and stopped by the system when convenient. You would probably have to shutdown your NDK thread and restart it when necessary.


For executing binary file starting from Android 10 it’s only possible from read-only folder. It means that you should pack binary with your app. Android doc

  1. Put android:extractNativeLibs="true" into AndroidManifest;
  2. Put your binary to src/main/resources/lib/* directory, where * – stands for architecture of CPU, for instance armeabi-v7a;
  3. Use code like this for executing:

    private fun exec(command: String, params: String): String {
    try {
        val process = ProcessBuilder()
            .directory(File(filesDir.parentFile!!, "lib"))
            .command(command, params)
        val reader = BufferedReader(
        val text = reader.readText()
        return text
    } catch (e: Exception) {
        return e.message ?: "IOException"

Here is discussion with answer from android team on reddit.