dynamische Generierung Dalvik Bytecode in einen laufenden Dalvik/Android-Anwendung

Question

Diese Frage gestellt wurde (und beantwortet) oft über dynamische Generierung und Laden von Java-Bytecode zur Laufzeit in eine Dalvik VM ausgeführt wird, aber ist es eine Möglichkeit, dex-Dateien zu laden/Bytecodes in eine App zur Laufzeit?

Dank

Answer 1

Die Dalvik-Team möchte eine erstklassige Laufzeitcodegenerierung Bibliothek bauen. Wir verfolgen die Feature-Anforderung als Android bug 6322. Leider haben wir eine sehr lange Liste von Leistungs- und Korrektheitsproblemen, daher kann ich Ihnen keine Zeit geben, wann wir uns mit diesem Problem beschäftigen werden.

Es gibt einige Alternativen, aber sie werden alle etwas Arbeit:

• Führen Sie Ihre Anwendung auf einem Standard-JVM und trainieren den gesamten Code Laufzeit Generation gibt. Speichern Sie die .class-Dateien aus dem Speicher in Dateien und führen Sie dann dx für diese Dateien aus. Wenn Sie ziemlich anspruchsvoll sind, können Sie all diese Arbeit in Ihren Build integrieren.

• Schließen Sie das Open-Source-DX-Tool als Projektbibliothek ein und führen Sie es programmgesteuert aus Ihrer Anwendung aus, möglicherweise im Classloader Ihrer Anwendung. Dies wird die Binärdatei Ihrer Anwendung aufblähen.

Answer 2

ist es eine Möglichkeit, dex Dateien/Bytecode in eine App bei Laufzeit zu laden?

Betrachten Sie DexFile und DexClassLoader.

Answer 3

Wenn innerhalb jeder C oder C++ Programm, Sie wollen in die DEX-Klassen laden und aufrufen, können Sie sehen, wie die Dalvik VM gestartet wird, innerhalb des Android Runtime - zum Beispiel Gerüste/base/cmds/app_process/app_main.cpp:

status_t app_init(const char* className, int argc, const char* const argv[]) 
{ 
    LOGV("Entered app_init()!\n"); 

    AndroidRuntime* jr = AndroidRuntime::getRuntime(); 
    jr->callMain(className, argc, argv); 

    LOGV("Exiting app_init()!\n"); 
    return NO_ERROR; 
} 

Als "jr" Android Runtime bereits gestartet ist, wird callMain() aufgerufen werden:

status_t AndroidRuntime::callMain(
    const char* className, int argc, const char* const argv[]) 
{ 
    JNIEnv* env; 
    jclass clazz; 
    jmethodID methodId; 

    LOGD("Calling main entry %s", className); 

    env = getJNIEnv(); 
    if (env == NULL) 
     return UNKNOWN_ERROR; 

    clazz = findClass(env, className); 
    if (clazz == NULL) { 
     LOGE("ERROR: could not find class '%s'\n", className); 
     return UNKNOWN_ERROR; 
    } 

    methodId = env->GetStaticMethodID(clazz, "main", "([Ljava/lang/String;)V"); 
    if (methodId == NULL) { 
     LOGE("ERROR: could not find method %s.main(String[])\n", className); 
     return UNKNOWN_ERROR; 
    } 
<...> 
    env->CallStaticVoidMethod(clazz, methodId, strArray); 
    return NO_ERROR; 
} 

Von oben können wir sehen, wie die Codes DEX Klassen geladen und CallStaticVoidMe thod() beginnt mit der Interpretation der DEX-Codes.

Answer 4

Ich habe ASM und BCEL verwendet Java-Klassen zu erzeugen, und dann habe ich konvertiert sie Dateien Dex. Endlich habe ich JAR-Dateien zum dynamischen Laden auf dem Gerät erstellt.

Sie können meinen Code überprüfen :)

https://github.com/sciruela/android

Answer 5

A related answer schlägt Dexmaker für dynamische Dalvik Bytecode Generation.