Est-il possible de charger dynamiquement une bibliothèque au moment de l'exécution à partir d'une application Android ?

Question

Existe-t-il un moyen de faire en sorte qu'une application Android télécharge et utilise une bibliothèque Java au moment de l'exécution ?

Voici un exemple :

Imaginons que l'application doive effectuer certains calculs en fonction des valeurs d'entrée. L'application demande ces valeurs d'entrée et vérifie ensuite si les valeurs requises sont correctes. Classe ou Method sont disponibles.

Sinon, il se connecte à un serveur, télécharge la bibliothèque nécessaire et la charge au moment de l'exécution pour appeler les méthodes requises en utilisant des techniques de réflexion. L'implémentation peut changer en fonction de divers critères tels que l'utilisateur qui télécharge la bibliothèque.

Answer 1

Désolé, je suis en retard et la question a déjà une réponse acceptée, mais oui vous pouvez télécharger et exécuter des bibliothèques externes. Voici comment j'ai procédé :

Je me demandais si cela était possible et j'ai donc écrit la classe suivante :

package org.shlublu.android.sandbox;

import android.util.Log;

public class MyClass {
    public MyClass() {
        Log.d(MyClass.class.getName(), "MyClass: constructor called.");
    }

    public void doSomething() {
        Log.d(MyClass.class.getName(), "MyClass: doSomething() called.");
    }
}

Et je l'ai emballé dans un fichier DEX que j'ai enregistré sur la carte SD de mon appareil en tant que /sdcard/shlublu.jar .

Ensuite, j'ai écrit le "programme stupide" ci-dessous, après avoir supprimé MyClass de mon projet Eclipse et l'a nettoyé :

public class Main extends Activity {

    @SuppressWarnings("unchecked")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        try {
            final String libPath = Environment.getExternalStorageDirectory() + "/shlublu.jar";
            final File tmpDir = getDir("dex", 0);

            final DexClassLoader classloader = new DexClassLoader(libPath, tmpDir.getAbsolutePath(), null, this.getClass().getClassLoader());
            final Class<Object> classToLoad = (Class<Object>) classloader.loadClass("org.shlublu.android.sandbox.MyClass");

            final Object myInstance  = classToLoad.newInstance();
            final Method doSomething = classToLoad.getMethod("doSomething");

            doSomething.invoke(myInstance);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Il charge essentiellement la classe MyClass de cette façon :

• créer un DexClassLoader

• l'utiliser pour extraire la classe MyClass de "/sdcard/shlublu.jar"

• et stocker cette classe dans le répertoire de l'application "dex" répertoire privé (mémoire interne du téléphone).

Ensuite, il crée une instance de MyClass et invoque doSomething() sur l'instance créée.

Et ça marche... Je vois les traces définies dans MyClass dans mon LogCat :

J'ai essayé à la fois sur un émulateur 2.1 et sur mon téléphone portable HTC physique (qui fonctionne sous Android 2.2 et qui n'est PAS enraciné).

Cela signifie que vous pouvez créer des fichiers DEX externes pour que l'application les télécharge et les exécute. Ici, cela a été fait de la manière forte (laid Object des plâtres, Method.invoke() vilains appels...), mais il doit être possible de jouer avec des Interface pour rendre quelque chose plus propre.

Wow. Je suis le premier surpris. Je m'attendais à un SecurityException .

Quelques faits pour aider à enquêter davantage :

• Mon DEX shlublu.jar a été signé, mais pas mon application.
• Mon application a été exécutée à partir d'Eclipse / connexion USB. Il s'agit donc d'un APK non signé compilé en mode DEBUG.

Answer 2

La réponse de Shlublu est vraiment bien. Quelques petites choses cependant qui pourraient aider un débutant :

• pour le fichier de bibliothèque "MyClass", créez un projet d'application Android distinct dont le fichier MyClass est le seul fichier du dossier src (les autres éléments, tels que project.properties, manifest, res, etc. doivent également s'y trouver).

• dans le manifeste du projet de bibliothèque, assurez-vous que vous avez : <application android:icon="@drawable/icon" android:label="@string/app_name"> <activity android:name=".NotExecutable" android:label="@string/app_name"> </activity> </application> (".NotExecutable" n'est pas un mot réservé. C'est juste que je devais mettre quelque chose ici)

• Pour créer le fichier .dex, il suffit de lancer le projet de bibliothèque en tant qu'application Android (pour la compilation) et de localiser le fichier .apk dans le dossier bin du projet.

• Copiez le fichier .apk sur votre téléphone et renommez-le en fichier shlublu.jar (un APK est en fait une spécialisation d'un jar).

Les autres étapes sont les mêmes que celles décrites par Shlublu.

• Un grand merci à Shlublu pour sa coopération.

Answer 3

Techniquement, cela devrait fonctionner mais qu'en est-il des règles de Google ? De : play.google.com/intl/fr-GB/about/developer-content-policy-print

Une application distribuée via Google Play ne peut pas être modifiée, remplacée ou mise à jour par une méthode autre que le mécanisme de mise à jour de Google Play. en utilisant une méthode autre que le mécanisme de mise à jour de Google Play. De même, une application ne doit pas télécharger de code exécutable (par exemple, des fichiers dex, JAR, .so ) à partir d'une source autre que Google Play. Cette restriction ne s'applique pas s'applique pas au code qui s'exécute dans une machine virtuelle et qui a un accès limité aux API Android (comme JavaScript dans une WebView ou un navigateur).

Answer 4

Je ne suis pas sûr que vous puissiez y parvenir en chargeant dynamiquement du code java. Peut-être pouvez-vous essayer d'intégrer un moteur script dans votre code comme rhino qui peut exécuter des scripts java qui peuvent être téléchargés et mis à jour dynamiquement.

Answer 5

Bien sûr, c'est possible. apk qui n'est pas installé peut être invoqué par l'application Android hôte. généralement, résoudre la ressource et le cercle de vie de l'activité, puis, peut charger jar ou apk dynamiquement. Pour plus de détails, veuillez vous référer à ma recherche open source sur Github : https://github.com/singwhatiwanna/dynamic-load-apk/blob/master/README-en.md

Aussi, DexClassLoader et la réflexion sont nécessaires, maintenant regardez quelques codes clés :

/**
 * Load a apk. Before start a plugin Activity, we should do this first.<br/>
 * NOTE : will only be called by host apk.
 * @param dexPath
 */
public DLPluginPackage loadApk(String dexPath) {
    // when loadApk is called by host apk, we assume that plugin is invoked by host.
    mFrom = DLConstants.FROM_EXTERNAL;

    PackageInfo packageInfo = mContext.getPackageManager().
            getPackageArchiveInfo(dexPath, PackageManager.GET_ACTIVITIES);
    if (packageInfo == null)
        return null;

    final String packageName = packageInfo.packageName;
    DLPluginPackage pluginPackage = mPackagesHolder.get(packageName);
    if (pluginPackage == null) {
        DexClassLoader dexClassLoader = createDexClassLoader(dexPath);
        AssetManager assetManager = createAssetManager(dexPath);
        Resources resources = createResources(assetManager);
        pluginPackage = new DLPluginPackage(packageName, dexPath, dexClassLoader, assetManager,
                resources, packageInfo);
        mPackagesHolder.put(packageName, pluginPackage);
    }
    return pluginPackage;
}

vos demandes ne sont que partiellement fonctionnelles dans le projet open source mentionné au début.