Reflection und "extends" Schlüsselwort

[yogle]

Hallo zusammen,

ich bin noch ziemlicher Anfänger, doch bevor ich völlig verzweifle, dachte ich schreib ich lieber mal hier rein, vielleicht kann mir ja jemand helfen. Ich möchte per Reflection mehrere Klassen dynamisch laden und soweit klapp das auch. Stecken bleibe ich aber wenn ich meine eigene Klasse, welche eine Subklasse für eine der dynamisch geladenen ist, in einem Funktionsaufruf verwenden möchte. Ohne Reflection sieht der Code so aus:

Watcher.java

// Diese drei Klassen möchte ich dynamisch laden!
import com.IActivityController
import com.IActivityManager
import com.ActivityManagerNative

public class Watcher
    // Hier ist die wichtige (Sub-)Klassenbezeichnung!
    private class ActivityWatcher extends IActivityWatcher.Stub {
	@Override
        public boolean activityStarting(Intent intent, String pkg) {
               System.out.println(intent + " in package " + pkg);
               return true;
        }

        @Override
	public boolean activityResuming(String arg0) throws RemoteException {
		// TODO Auto-generated method stub
		return true;
	}

        @Override
	public boolean appCrashed(String arg0, int arg1, String arg2,
			String arg3, byte[] arg4) throws RemoteException {
		// TODO Auto-generated method stub
		return true;
	}

        Override
	public int appNotResponding(String arg0, int arg1, String arg2)
			throws RemoteException {
		// TODO Auto-generated method stub
		return 0;
	}
    }

    void run() {
        IActivityManager aM = ActivityManagerNative.getDefault();
 
        aM.setActivityController(new ActivityWatcher());       
    }

Die Klassen "ActivityManagerNative", "IActivityManager" und insbesondere "IActivityController" möchte ich nun aber per Reflection laden. Das ist mein derzeitiger Code:

ActivityWatcher.java hier gehen die @Override Annotiations und das "extend IActivityWatcher.Stub" nicht mehr....

public class ActivityWatcher {
	public boolean activityStarting(Intent intent, String pkg) {
        System.out.println(intent + " in package " + pkg);
        return true;
    }

	public boolean activityResuming(String arg0) throws RemoteException {
		// TODO Auto-generated method stub
		return true;
	}

	public boolean appCrashed(String arg0, int arg1, String arg2,
			String arg3, byte[] arg4) throws RemoteException {
		// TODO Auto-generated method stub
		return true;
	}

	public int appNotResponding(String arg0, int arg1, String arg2)
			throws RemoteException {
		// TODO Auto-generated method stub
		return 0;
	}
}

Watcher.java

public class Watcher {
    void run() {
      // Access our class loader
      ClassLoader classLoader = Watcher.class.getClassLoader();  
        
      try {
       Class<?> classIActivityController = classLoader.loadClass("android.app.IActivityController");
       System.out.println(classIActivityController.getName());
            
       Class<?> classActivityManagerNative = classLoader.loadClass("android.app.ActivityManagerNative");
       System.out.println(classActivityManagerNative.getName());
            
       Class<?> classIActivityManager = classLoader.loadClass("android.app.IActivityManager");
       System.out.println(classIActivityManager.getName());
            

       // "ActivityManagerNative.getDefault"
       java.lang.Class<?>[] parameterType = null; 
       Method methGetDefault = classActivityManagerNative.getMethod("getDefault", parameterType);

       // "IActivityManager.setActivityController"
       Method methSetActivityController = classIActivityManager.getMethod("setActivityController", 
                    	classIActivityController);
           
         
       // Call "ActivityManagerNative.getDefault", function is static -> pass null as instance
       java.lang.Object[] argument = null;
       Object oIActivityManagerInst = methGetDefault.invoke(null, argument);
            
       
       // Class<?> subclass = Class.forName("com.systemapp.ActivityWatcher").asSubclass(classIActivityController); <-- Wirft eine ClassCastException
            
       //  methSetActivityController.invoke(oIActivityManagerInst, subclass);
            
    } catch(ClassNotFoundException e) {
       Log.e("Watcher", "ClassNotFoundException!");
       e.printStackTrace();
     } catch(NoSuchMethodException e) {
       Log.e("Watcher", "NoSuchMethodException!");
       e.printStackTrace();
     } catch(InvocationTargetException e) {
       Log.e("Watcher", "InvocationTargetException!");
       e.printStackTrace();
     } catch(IllegalAccessException e) {
       Log.e("Watcher", "IllegalAccessException!");
       e.printStackTrace();
     }
}

Kann mir jemand sagen wie ich mit "setActivityController" meine eigene Klasse registriere um, später für bei "activityStarting" aufgerufen werden zu können?

Gruß
yogle

 

[Landei]

Ich verstehe nicht ganz, was du erreichen willst, und ob du überhaupt Reflection brauchst. Wahrscheinlich lässt sich dein Problem bereits so lösen:
- ein Interface Bla schreiben, das deine dynamische Klasse implementiert
- Bla bla = (Bla) Class.forName("my.ultra.cool.DynamicClass").newInstance(); //wenn es einen Defaultkonstruktor gibt
- danach lassen sich an bla ganz normal Methoden aufrufen

Method.invoke ist nur dann nötig, wenn deine Klasse keinerlei Interface entspricht (etwa Tools wie Objekt-Inspektoren). Da es sich um deine eigenen Klassen handelt, sollte es kein Problem sein, ein Interface anzugeben.

Übrigens solltest du dir mal SPI (service provider interface) angucken, vielleicht ist das schon das, was du brauchst. Damit kann man ein Interface vorgeben, und passende Klassen aus Packages, die im Classpath liegen und eine entsprechende Definition in META-INF mitliefern, zur Laufzeit "entdecken".

 

[yogle]

Die Klassen die ich dynamisch laden möchte sind nicht von mir und ich kann sie auch nicht ändern!

 

[Landei]

Die Frage ist nicht, ob sie von dir sind, sondern ob sie ein vernünftiges Interface implementieren, dass du verwenden könntest. Dann ginge der von mir beschriebene Weg. Ansonsten musst du wirklich mit Method.invoke rumhantieren.

Was mich stutzig macht ist der Satz "Stecken bleibe ich aber wenn ich meine eigene Klasse, welche eine Subklasse für eine der dynamisch geladenen ist...". Von dynamischen geladenen Klassen kannst du nicht einfach eigene Klassen ableiten. Ist auch logisch: Der Compiler muss die Superklassen deiner Klasse zur Compilezeit kennen, woher soll er sonst die Informationen nehmen, was reingehört und was nicht? Natürlich gibt es Mittel und Wege (spontan fällt mir DynamicProxy ein), aber um da zu helfen müsstest du die Situation etwas ausführlicher erklären...