lista - script para android

Cómo construir un ejecutable para el shell de Android

Question

A veces necesito ejecutar un comando o script en mi dispositivo, pero no están disponibles o no existen.

¿Podemos agregar algunos comandos adicionales al shell del dispositivo Android , excepto aquellos comandos que ya están disponibles en él?

Por ejemplo, agregue el comando screenrecord a mi dispositivo (mi dispositivo tiene una API de Android inferior a 19), que no está disponible en él.

Sé cómo obtener la lista de comandos disponibles en el dispositivo con adb shell

adb shell ls /system/bin 

pero quiero agregar más comandos y scripts personalizados, para hacer algo especial y trabajar.

¿Hay alguna forma de hacerlo? O es imposible?

Answer 1

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

app/build/intermediates/ndkBuild/debug/obj/local/arm64-v8a/objs-debug/test1

para arm64-v8a y correspondiente para otras plataformas.

Answer 2

Si en caso de que obtenga este error:

error: solo los ejecutables independientes de posición (PIE) son compatibles cuando creó el ejecutable usando CMake ,

agregue estas líneas a la aplicación gradle

default config
{
..........
..........
externalNativeBuild
{
 cmake 
  { 
   targets "my_command"
   abiFilters "armeabi-v7a"
   arguments "-DANDROID_PIE=ON" //important
  }
 }
...........
}

Answer 3

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

I. PREPARAR EL CÓDIGO DE FUENTE

Como ejemplo, considere mycommand.c :

#include <stdio.h>

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

II CONSTRUIR EJECUTABLE

Eclipse

En el supuesto de que la ubicación del NDK esté configurada en Eclipse , cree un nuevo Android Application Project y realice los siguientes pasos.

1. Añadir soporte nativo . Haga clic derecho en el proyecto en Project Explorer > Android Tools > Add Native Support > Finish

2. Agregue el código fuente , es decir, coloque mycommand.c en la carpeta project_root / jni .

3. Edite Android.mk en project_root / jni siguiente manera:

   LOCAL_PATH := $(call my-dir)
   
   include $(CLEAR_VARS)
   
   LOCAL_MODULE     := mycommand
   LOCAL_SRC_FILES  := mycommand.c
   
   include $(BUILD_EXECUTABLE)

4. Cree Application.mk * en la carpeta project_root / jni :

   APP_ABI := all

5. project_root/libs/<abi>/mycommand ejecutable y project_root/libs/<abi>/mycommand en project_root/libs/<abi>/mycommand .

* Aquí se generan binarios para all arquitecturas de CPU compatibles. Use adb shell cat /proc/cpuinfo para descubrir la arquitectura de la CPU y establecer APP_ABI según APP_ABI admitidos .

Android Studio y ndk-build

Los pasos son los siguientes.

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

2. 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"
           }
       }
   }

3. Cree el proyecto y busque el ejecutable en /app/.externalNativeBuild/ndkBuild/debug/obj/local/<abi>/mycommand

Android Studio y CMake

1. Agregue mycommand.c a la mycommand.c /app/src/main/cpp y edite CMakeLists.txt :

   cmake_minimum_required(VERSION x.x.x)
   
   add_executable(mycommand
                  src/main/cpp/mycommand.c )

2. Editar build.gradle :

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

3. Cree el proyecto y busque el ejecutable en /app/.externalNativeBuild/cmake/debug/<abi>/mycommand

III. EMPUJE EL BINARIO AL DISPOSITIVO

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

• En un dispositivo no rooteado , puede empujar el binario a /data/local/tmp :

  adb push mycommand /data/local/tmp

• En el dispositivo rooteado , puede insertar el binario en la tarjeta SD y luego copiarlo a /system/bin (después de volver a montar la partición en modo de lectura-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. SET PERMISO EJECUTABLE ( opcional )

Establezca el permiso del binario para ser ejecutable ( no es necesario hacerlo en el caso de /data/local/tmp ). A continuación se usa chmod 555 (r-xr-xr-x):

adb shell chmod 555 /path/to/mycommand

V. EJECUTAR MANDO

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

• En un dispositivo no rooteado , use la ruta absoluta al comando:

  $ /data/local/tmp/mycommand
  My Command!

• En el dispositivo rooteado , en caso de que el binario se haya copiado en /system/bin , puede llamarlo por el nombre del archivo:

  $ mycommand
  My Command!