Android高级 InstrumentationProxy使用

weishu

替换Activity 中的 mInstrumentation 实现代理，从而拿到Activity生命周期的CallBack

 public void replaceActivityInstrumentationService(Activity activity) {
    try {
        if (activity == null) {
            return;
        }
        Class activityClass = Activity.class;
        if (activityClass != null) {
            Field mInstrumentationField = activityClass.getDeclaredField("mInstrumentation");
            mInstrumentationField.setAccessible(true);
            Instrumentation mInstrumentation = (Instrumentation) mInstrumentationField.get(activity);
            if (mInstrumentation != null) {
                if (mInstrumentation.getClass().getName().indexOf("com.gameassist.plugin") < 0) {
                    InstrumentationDelegate evilInstrumentation = new InstrumentationDelegate(mInstrumentation, activityCallback);
                    mInstrumentationField.set(activity, evilInstrumentation);
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

InstrumentationProxy：

import android.app.Activity;
import android.app.Application;
import android.app.Instrumentation;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.WindowManager;

import com.gameassist.plugin.ActivityCallback;

public class InstrumentationDelegate extends Instrumentation {

private Instrumentation mProxy;
private ActivityCallback activityCallback;
public InstrumentationDelegate(Instrumentation proxy, ActivityCallback activityCallback) {
    this.activityCallback = activityCallback;
    mProxy = proxy;
}


@Override
public void addMonitor(ActivityMonitor monitor) {
    mProxy.addMonitor(monitor);
}

@Override
public ActivityMonitor addMonitor(IntentFilter filter, ActivityResult result, boolean block) {
    return mProxy.addMonitor(filter, result, block);
}

@Override
public ActivityMonitor addMonitor(String cls, ActivityResult result, boolean block) {
    return mProxy.addMonitor(cls, result, block);
}

@Override
public void callActivityOnCreate(Activity activity, Bundle icicle) {
//        Log.e("pluginDemoN","InstrumentationDelegate <callActivityOnCreate> "+activity.getClass().getName());
    mProxy.callActivityOnCreate(activity, icicle);

}

@Override
public void callActivityOnDestroy(Activity activity) {
//        Log.e("pluginDemoN","InstrumentationDelegate <callActivityOnDestroy> "+activity.getClass().getName());
    activityCallback.OnActivityDestroy(activity);
    mProxy.callActivityOnDestroy(activity);

}

@Override
public void callActivityOnNewIntent(Activity activity, Intent intent) {
    mProxy.callActivityOnNewIntent(activity, intent);

}

@Override
public void callActivityOnPause(Activity activity) {
//        Log.e("pluginDemoN","InstrumentationDelegate <callActivityOnPause> "+activity.getClass().getName());
    activityCallback.OnActivityPause(activity);
    mProxy.callActivityOnPause(activity);

}

@Override
public void callActivityOnPostCreate(Activity activity, Bundle icicle) {
    mProxy.callActivityOnPostCreate(activity, icicle);
}

@Override
public void callActivityOnRestart(Activity activity) {
    mProxy.callActivityOnRestart(activity);
}

@Override
public void callActivityOnRestoreInstanceState(Activity activity, Bundle savedInstanceState) {
    mProxy.callActivityOnRestoreInstanceState(activity, savedInstanceState);
}
static WindowManager.LayoutParams layoutParams;
@Override
public void callActivityOnResume(Activity activity) {
    activityCallback.OnActivityResume(activity);
//        Log.e("pluginDemoN"," InstrumentationDelegate <callActivityOnResume> "+activity.getClass().getName());
    mProxy.callActivityOnResume(activity);

}

@Override
public void callActivityOnSaveInstanceState(Activity activity, Bundle outState) {
    mProxy.callActivityOnSaveInstanceState(activity, outState);
}

@Override
public void callActivityOnStart(Activity activity) {
    mProxy.callActivityOnStart(activity);

}

@Override
public void callActivityOnStop(Activity activity) {
    mProxy.callActivityOnStop(activity);

}

@Override
public void callActivityOnUserLeaving(Activity activity) {
    mProxy.callActivityOnUserLeaving(activity);
}

@Override
public void callApplicationOnCreate(Application app) {
    mProxy.callApplicationOnCreate(app);
}

@Override
public boolean checkMonitorHit(ActivityMonitor monitor, int minHits) {
    return mProxy.checkMonitorHit(monitor, minHits);
}

@Override
public void endPerformanceSnapshot() {
    mProxy.endPerformanceSnapshot();
}

@Override
public void finish(int resultCode, Bundle results) {
    mProxy.finish(resultCode, results);
}

@Override
public Bundle getAllocCounts() {
    return mProxy.getAllocCounts();
}

@Override
public Bundle getBinderCounts() {
    return mProxy.getBinderCounts();
}

@Override
public ComponentName getComponentName() {
    return mProxy.getComponentName();
}

@Override
public Context getContext() {
    return mProxy.getContext();
}

@Override
public Context getTargetContext() {
    return mProxy.getTargetContext();
}

@Override
public boolean invokeContextMenuAction(Activity targetActivity, int id, int flag) {
    return mProxy.invokeContextMenuAction(targetActivity, id, flag);
}

@Override
public boolean invokeMenuActionSync(Activity targetActivity, int id, int flag) {
    return mProxy.invokeMenuActionSync(targetActivity, id, flag);
}

@Override
public boolean isProfiling() {
    return mProxy.isProfiling();
}

@Override
public Activity newActivity(Class<?> clazz, Context context, IBinder token, Application application, Intent intent, ActivityInfo info, CharSequence title, Activity parent, String id, Object lastNonConfigurationInstance)
        throws InstantiationException, IllegalAccessException {
    return mProxy.newActivity(clazz, context, token, application, intent, info, title, parent, id, lastNonConfigurationInstance);
}

@Override
public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {


    return mProxy.newActivity(cl, className, intent);
}

@Override
public Application newApplication(ClassLoader cl, String className, Context context) throws InstantiationException, IllegalAccessException, ClassNotFoundException {


    Application application = mProxy.newApplication(cl, className, context);

    return application;
}

@Override
public void onCreate(Bundle arguments) {
    mProxy.onCreate(arguments);
}

@Override
public void onDestroy() {
    mProxy.onDestroy();
}

@Override
public boolean onException(Object obj, Throwable e) {
    e.printStackTrace();
    return mProxy.onException(obj, e);
}

@Override
public void onStart() {
    mProxy.onStart();
}

@Override
public void removeMonitor(ActivityMonitor monitor) {
    mProxy.removeMonitor(monitor);
}

@Override
public void runOnMainSync(Runnable runner) {
    mProxy.runOnMainSync(runner);
}

@Override
public void sendCharacterSync(int keyCode) {
    mProxy.sendCharacterSync(keyCode);
}

@Override
public void sendKeyDownUpSync(int key) {
    mProxy.sendKeyDownUpSync(key);
}

@Override
public void sendKeySync(KeyEvent event) {
    mProxy.sendKeySync(event);
}

@Override
public void sendPointerSync(MotionEvent event) {
    mProxy.sendPointerSync(event);
}

@Override
public void sendStatus(int resultCode, Bundle results) {
    mProxy.sendStatus(resultCode, results);
}

@Override
public void sendStringSync(String text) {
    mProxy.sendStringSync(text);
}

@Override
public void sendTrackballEventSync(MotionEvent event) {
    mProxy.sendTrackballEventSync(event);
}

@Override
public void setAutomaticPerformanceSnapshots() {
    mProxy.setAutomaticPerformanceSnapshots();
}

@Override
public void setInTouchMode(boolean inTouch) {
    mProxy.setInTouchMode(inTouch);
}

@Override
public void start() {
    mProxy.start();
}

@Override
public Activity startActivitySync(Intent intent) {
    return mProxy.startActivitySync(intent);
}

@Override
public void startAllocCounting() {
    mProxy.startAllocCounting();
}

@Override
public void startPerformanceSnapshot() {
    mProxy.startPerformanceSnapshot();
}

@Override
public void startProfiling() {
    mProxy.startProfiling();
}

@Override
public void stopAllocCounting() {
    mProxy.stopAllocCounting();
}

@Override
public void stopProfiling() {
    mProxy.stopProfiling();
}

@Override
public void waitForIdle(Runnable recipient) {
    mProxy.waitForIdle(recipient);
}

@Override
public void waitForIdleSync() {
    mProxy.waitForIdleSync();
}

@Override
public Activity waitForMonitor(ActivityMonitor monitor) {
    return mProxy.waitForMonitor(monitor);
}

@Override
public Activity waitForMonitorWithTimeout(ActivityMonitor monitor, long timeOut) {
    return mProxy.waitForMonitorWithTimeout(monitor, timeOut);
}
}