Comment puis-je Charger un fichier jar de façon dynamique dans une application android (version 4.0.3)

J'ai trouvé la solution à mon problème.

Pour charger dynamiquement pot, les classes qui implémentent une interface dans une application android, certaines tâches doivent être faites dans le bocal :

• Créer votre propre manisfest pour le pot et mettre cette information

   Manifest-Version: 1.0
  Module-Class: com.example.myjar.MyPeripheral

• Exporter votre pot à l'aide d'eclipse et de mettre en paramètre il utilise son propre manisfest

• Créer les classes.dex associés pour le pot
  (ce fichier est nécessaire par le Dalvik VM, il suffit de pot peut pas être lu par le dalvik VM)

  dx --dex --output=C:\classes.dex C:\MyJar.jar

Attention, le nom de l'indice dex fichier DOIT ÊTRE classes.dex

• Ajouter le fichier classes.dex dans le fichier jar

  aapt add C:\MyJar.jar C:\classes.dex

• Vous devez également avoir le droit d'écrire dans le cache dalvik répertoire

     adb shell chmod 777 /data/dalvik-cache

  Le faire à chaque fois, votre relancer votre émulateur

• mettre ce fichier jar dans l'émulateur par exemple sur la SDcard

• Utiliser un PathClassLoader pour charger le fichier jar

  dalvik.system.PathClassLoader myClassLoader = new dalvik.system.PathClassLoader("/Sdcard/MyJar.jar", ModuleLoader.class.getClassLoader());

NB : le LogCat dans Eclipse vous donne de précieuses informations. N'oubliez pas de regarder ses messages

Ci-dessous, le code :

Mon interface :

package com.example.StandartPeripheral; 
public interface IPeripheral {
public boolean Initialize();
public boolean configure();
public boolean execute();
public String GetName();
}

MyPeripheral qui implémente l'interface

public class MyPeripheral implements IPeripheral {
//public static void main(String[] args) {}
private final String PeripheralName = "MyPeripheral";
public boolean Initialize()
{
System.out.println("Initialize "); 
return true;
};
public boolean configure()
{
System.out.println("Configure !"); 
return true;
};
public boolean execute()
{
System.out.println("Execute !"); 
return true;
};
public String GetName()
{
return PeripheralName;
}
}

Comment charger dynamiquement les fichiers jar

package com.example.ModuleLoader;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import android.annotation.SuppressLint;
import android.content.Context;
import com.example.StandartPeripheral.IPeripheral;
public class ModuleLoader { 
private static List<URL> urls = new ArrayList<URL>(); 
//to retrieve the unknown list of jar files contained in the directory folder
//in my case it was in the SDCard folder
//link to create a SDCard directory on the Eclipse emulator
//http://blog.lecacheur.com/2010/01/14/android-avoir-acces-a-une-carte-memoire-dans-lemulateur/
//retrieve the classes of all this jar files and their URL (location)
private static List<String> getModuleClasses(String folder)
{ 
List<String> classes = new ArrayList<String>(); 
//we are listing the jar files
File[] files = new File(folder).listFiles(new ModuleFilter()); 
for(File f : files)
{ 
JarFile jarFile = null; 
try 
{ 
//we open the jar file
jarFile = new JarFile(f); 
//we recover the manifest 
Manifest manifest = jarFile.getManifest(); 
//we recover the class name of our peripherals thanks to ours manifest
String moduleClassName = manifest.getMainAttributes().getValue("Module-Class"); 
classes.add(moduleClassName); 
urls.add(f.toURI().toURL()); 
}
catch (IOException e) 
{ 
e.printStackTrace(); 
} 
finally
{ 
if(jarFile != null)
{ 
try
{ 
jarFile.close(); 
}
catch (IOException e) 
{ 
e.printStackTrace(); 
} 
} 
} 
} 
return classes; 
} 
private static class ModuleFilter implements FileFilter { 
@Override 
public boolean accept(File file) { 
return file.isFile() && file.getName().toLowerCase().endsWith(".jar"); 
} 
}
//This function loads the jar file into the dalvik system
//retrieves the associated classes using its name
//and try to know if the loaded classes are implementing our interface
public static List<IPeripheral> loadModules(String folder, Context CurrentContext)  { 
List<IPeripheral> modules = new ArrayList<IPeripheral>(); 
List<String> classes = getModuleClasses(folder);
int index  = 0;
for(String c : classes)
{ 
try
{ 
dalvik.system.PathClassLoader myClassLoader = new dalvik.system.PathClassLoader(urls.get(index).toString(), ModuleLoader.class.getClassLoader());
Class<?> moduleClass = Class.forName(c, true, myClassLoader); 
//check and cast to an interface, then use it
if(IPeripheral.class.isAssignableFrom(moduleClass))             
{ 
@SuppressWarnings("unused")
Class<IPeripheral> castedClass = (Class<IPeripheral>)moduleClass; 
IPeripheral module =  (IPeripheral)moduleClass.newInstance(); 
modules.add(module); 
}  
index++;
}
catch (ClassNotFoundException e1) 
{ 
e1.printStackTrace(); 
} 
catch (InstantiationException e) 
{ 
e.printStackTrace(); 
}
catch (IllegalAccessException e) 
{ 
e.printStackTrace(); 
} 
} 
return modules; 
}
}

OriginalL'auteur Virginie Voirin