▷Cómo construir un ejecutable para Android shell ✔️ Foro Ayuda 【 2024 】

Contamos con la mejor solución que hallamos on line. Nosotros deseamos que te sea de mucha utilidad y si puedes compartir algo que nos pueda ayudar a crecer hazlo libremente.

Solución:

La respuesta proporciona una secuencia de pasos para construir un ejecutable para Android shell a través de ambos Eclipse y Android Studio 2.2+. El último incluye ndk-build y CMake.

I. PREPARAR EL CÓDIGO FUENTE

Como ejemplo considere mycommand.c:

#include 

int main()

    printf("My Command!n");
    return 0;

II. CONSTRUIR EJECUTABLE

Eclipse

En el supuesto de que NDK la ubicación está establecida en Eclipsecrear un nuevo Android Application Project y realiza los siguientes pasos.

Agregar soporte nativo. Haga clic derecho en el proyecto en Project Explorer > Android Tools > Add Native Support > Finish
Añadir código fuentees decir poner mycommand.c bajo project_root/jni carpeta.

Editar Android.mk bajo project_root/jni como sigue:

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE     := mycommand
LOCAL_SRC_FILES  := mycommand.c

include $(BUILD_EXECUTABLE)

Crear Application.mk * bajo la project_root/jni carpeta:
```
APP_ABI := all
```
Construir ejecutable y encontrarlo debajo project_root/libs//mycommand.

*binarios para all Las arquitecturas de CPU admitidas se generan aquí. Utilizar adb shell cat /proc/cpuinfo para averiguar la arquitectura de la CPU y establecer APP_ABI según las ABI admitidas.

Android Studio y ndk-build

Los pasos son los siguientes.

Agregar mycommand.c, Android.mk (igual que en el Eclipse sección anterior) a la /app/src/main/cpp carpeta.

Editar 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"

Construir proyecto y encuentra el ejecutable bajo /app/.externalNativeBuild/ndkBuild/debug/obj/local//mycommand

Android Studio y CMake

Agregar mycommand.c al /app/src/main/cpp carpeta y editar CMakeLists.txt:

cmake_minimum_required(VERSION x.x.x)

add_executable(mycommand
               src/main/cpp/mycommand.c )

Editar build.gradle:

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

Construir proyecto y encuentra el ejecutable bajo /app/.externalNativeBuild/cmake/debug//mycommand

tercero EMPUJE BINARIO EN EL DISPOSITIVO

Empujar mycommand binario desde donde se encuentra en su dispositivo. Tenga en cuenta que los archivos en la tarjeta SD no son ejecutables de forma predeterminada, por lo que el archivo binario debe insertarse en el almacenamiento interno del dispositivo. Dependiendo de si el dispositivo está rooteado o no, tiene las siguientes opciones:

En no rooteado dispositivo al que puede enviar el binario /data/local/tmp:
```
adb push mycommand /data/local/tmp
```
En arraigado dispositivo puede empujar el binario a la tarjeta SD y luego copiarlo a /system/bin (después de volver a montar la partición en modo de lectura y escritura) junto con los otros archivos ejecutables:
```
adb push mycommand /path/to/sdcard
adb shell
su
mount -o rw,remount /system
cp /path/to/sdcard/mycommand /system/bin
```

IV. ESTABLECER PERMISO EJECUTABLE (Opcional)

Establezca el permiso del binario para que sea ejecutable (no es necesario hacer esto en caso de /data/local/tmp). Debajo chmod 555(r-xr-xr-x) se utiliza:

adb shell chmod 555 /path/to/mycommand

V. COMANDO EJECUTAR

Ahora puede instalarse en su dispositivo (con adb shell) y ejecute el comando.

En no rooteado dispositivo use la ruta absoluta al comando:
```
$ /data/local/tmp/mycommand
My Command!
```
En arraigado dispositivo, en caso de que el binario haya sido copiado a /system/binpuede llamarlo por el nombre del archivo:
```
$ mycommand
My Command!
```

En caso de que no tenga binarios en esta ubicación para Android y ndk-buildestán en

appbuildintermediatesndkBuilddebugobjlocalarm64-v8aobjs-debugtest1

para arm64-v8a y correspondiente para otras plataformas.

Si en caso de que esté recibiendo este error:

error: solo se admiten ejecutables independientes de la posición (PIE) cuando creaste el ejecutable usando CHacer,

agregue estas líneas a la aplicación gradle

default config

..........
..........
externalNativeBuild

 cmake 
   
   targets "my_command"
   abiFilters "armeabi-v7a"
   arguments "-DANDROID_PIE=ON" //important
  
 
...........

Si para ti ha sido de provecho este post, nos gustaría que lo compartas con más desarrolladores de este modo nos ayudas a extender nuestro contenido.

¡Haz clic para puntuar esta entrada!

(Votos: 0 Promedio: 0)

Cómo construir un ejecutable para Android shell