How to Compile C into an Executable Binary File and Run It in Android from Android Shell

How to build an executable for Android shell

The answer provides a sequence of steps for building an executable for Android shell through both Eclipse (outdated) and Android Studio (4.1+ by the time of this writing). The last includes ndk-build and CMake.

I. PREPARE SOURCE CODE

As an example consider mycommand.c:

#include <stdio.h>

int main()
{
    printf("My Command!\n");
    return 0;
}

II. BUILD EXECUTABLE

Eclipse (might be outdated)

In assumption that NDK location is set in Eclipse, create a new Android Application Project and do the following steps.

Add native support. Right click on the project in Project Explorer > Android Tools > Add Native Support > Finish
Add source code, i.e. put mycommand.c under project_root/jni folder.

Edit Android.mk under project_root/jni as follows:

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE     := mycommand
LOCAL_SRC_FILES  := mycommand.c

include $(BUILD_EXECUTABLE)

Create Application.mk * under the project_root/jni folder:
```
APP_ABI := all
```
Build executable and find it under project_root/libs/<abi>/mycommand.

*Binaries for all supported CPU architectures are generated here. Use adb shell cat /proc/cpuinfo to find out the CPU architecture and set APP_ABI as per Supported ABIs.

Android Studio and ndk-build

The steps are as follows.

Add mycommand.c, Android.mk (same as in the Eclipse section above) to the /app/src/main/cpp folder.

Edit build.gradle:

android {
    ...
    defaultConfig {
        ...
        externalNativeBuild {
            ndkBuild {
                targets "mycommand"
                // use a specific ABI filter if needed
                // abiFilters "armeabi-v7a"
            }
        }
    }
    externalNativeBuild {
        ndkBuild {
            path "src/main/cpp/Android.mk"
        }
    }
}

Build project and find the executable under /app/.externalNativeBuild/ndkBuild/debug/obj/local/<abi>/mycommand

Android Studio and CMake

Create a project using the Native C++ template.

Add mycommand.c to the /app/src/main/cpp folder and edit CMakeLists.txt:

cmake_minimum_required(VERSION x.x.x)

add_executable(mycommand
               mycommand.c )

Edit build.gradle:

android {
    ...
    defaultConfig {
        ...
        externalNativeBuild {
            cmake {
                targets "mycommand"
                // use a specific ABI filter if needed
                // abiFilters "armeabi-v7a"
            }
        }
    }
    ...
    externalNativeBuild {
        cmake {
            path "src/main/cpp/CMakeLists.txt"
        }
    }
}

Build project and find the executable under /app/build/intermediates/cmake/debug/obj/<abi>/mycommand

III. PUSH BINARY INTO DEVICE

Push mycommand binary from where it is located into your device. Keep in mind that files on SD card aren't executable by default, so the binary should be pushed into the device's internal storage. Depending of whether device is rooted or not you have the following options:

On non-rooted device you can push the binary to /data/local/tmp:
```
 adb push mycommand /data/local/tmp
```
On rooted device you can push the binary to SD card and then copy it to /system/bin (after remounting the partition in read-write mode) along with the other executable files:
```
 adb push mycommand /path/to/sdcard
 adb shell
 su
 mount -o rw,remount /system
 cp /path/to/sdcard/mycommand /system/bin
```

IV. SET EXECUTABLE PERMISSION (optional)

Set the permission of the binary to be executable (this might not be needed in case of /data/local/tmp). Below chmod 555(r-xr-xr-x) is used:

adb shell chmod 555 /path/to/mycommand

V. RUN COMMAND

Now you can shell into your device (with adb shell) and execute the command.

On non-rooted device use the absolute path to the command:
```
 $ /data/local/tmp/mycommand
 My Command!
```
On rooted device, in case the binary has been copied to /system/bin, you can call it by the file name:
```
 $ mycommand
 My Command!
```

Compile and run C code for Android

Let's start from the bottom up.

Going C (or C++) does not grant your code extra rights under Android.

There are different options of doing all your development without Java. There are frameworks for pure C++ (like NativeActivity), or for C# (MonoDroid), or Scala, or Ruby, or whatnot.

Android NDK also allows to simply build an executable - one that can be run from command line, and has no GUI. Your Android app can launch such executable via standard Java Runtime.exec() and her siblings. Or you can launch this executable from a terminal emulator or adb shell.

If you have root access on your device (or if you flash your own mod), you can launch an executable through the standard Linux init.rc or similar.

Note that in the latter case, you can easily grant your executable root or other permissions.

Want to compile native Android binary I can run in terminal on the phone

Just use the android-ndk. And build a Android.mk like so.
include $(BUILD_EXECUTABLE) is what tells it build a executable instead of a JNI .lib

Android.mk

ifneq ($(TARGET_SIMULATOR),true)

LOCAL_PATH:= $(call my-dir)

include $(CLEAR_VARS)

LOCAL_CFLAGS += -Wall

LOCAL_LDLIBS := -L$(LOCAL_PATH)/lib -llog -g

LOCAL_C_INCLUDES := bionic
LOCAL_C_INCLUDES += $(LOCAL_PATH)/include

LOCAL_SRC_FILES:= main.cpp

LOCAL_MODULE := mycmd

include $(BUILD_EXECUTABLE)

endif  # TARGET_SIMULATOR != true

Execute a pure binary file on Android

adb push exename /data/bin/exename
#next line might be needed if you are developing on Windows
adb shell chmod 777 /data/bin/exename
adb shell /data/bin/exename

But your device has to be rooted. (It also works on emulator.)

Can I use printf in an Android native binary

#include <stdio.h>

int main() {
  printf("Hello, world\n");
  return 0;
}

Then:

~/Library/Android/sdk/ndk/24.0.8215888/toolchains/llvm/prebuilt/darwin-x86_64/bin/clang --target=aarch64-linux-android21 helloworld.c -o helloworld
adb push helloworld /data/local/tmp/helloworld
adb shell /data/local/tmp/helloworld