app_process 自定义类似am pm命令

/*
**
** Copyright 2007, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the “License”);
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an “AS IS” BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/

package com.android.commands.tm;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import com.helloworld.android.tvapi.common.TvManager;
import com.helloworld.android.tvapi.common.PictureManager;
import com.helloworld.android.tvapi.common.AudioManager;
import com.helloworld.android.tvapi.common.CecManager;
import com.helloworld.android.tvapi.common.ChannelManager;
import com.helloworld.android.tvapi.common.DatabaseManager;
import com.helloworld.android.tvapi.common.LogoManager;
import com.helloworld.android.tvapi.common.MhlManager;
import com.helloworld.android.tvapi.common.ParentalcontrolManager;
import com.helloworld.android.tvapi.common.PipManager;
import com.helloworld.android.tvapi.common.PvrManager;
import com.helloworld.android.tvapi.common.TimerManager;
import com.helloworld.android.tvapi.factory.FactoryManager;

public class Tm {

private static final String CLASSNAME = "--class=";

private static final String METHOD = "--method=";

private static final String STATIC_METHOD = "--static=";

private static final String ARGS_INT = "-i";

private static final String ARGS_CHAR = "-c";

private static final String ARGS_SHORT = "-s";

private static final String ARGS_DOUBLE = "-d";

private static final String ARGS_STRING = "-S";

private static final String ARGS_BOOLEAN = "-b";

private static final String ARGS_ENUM = "-e";

private static final String ARGS_LONG = "-l";

private static final String CLASS_NAME_TVMANAGER = "com.helloworld.android.tvapi.common.TvManager";

private static final String CLASS_NAME_PICTUREMANAGER = "com.helloworld.android.tvapi.common.PictureManager";

private static final String CLASS_NAME_AUDIOMANAGER = "com.helloworld.android.tvapi.common.AudioManager";

private static final String CLASS_NAME_CECMANAGER = "com.helloworld.android.tvapi.common.CecManager";

private static final String CLASS_NAME_ChannelManager = "com.helloworld.android.tvapi.common.ChannelManager";

private static final String CLASS_NAME_DatabaseManager = "com.helloworld.android.tvapi.common.DatabaseManager";

private static final String CLASS_NAME_MhlManager = "com.helloworld.android.tvapi.common.MhlManager";

private static final String CLASS_NAME_ParentalcontrolManager = "com.helloworld.android.tvapi.common.ParentalcontrolManager";

private static final String CLASS_NAME_PipManager = "com.helloworld.android.tvapi.common.PipManager";

private static final String CLASS_NAME_PvrManager = "com.helloworld.android.tvapi.common.PvrManager";

private static final String CLASS_NAME_TimerManager = "com.helloworld.android.tvapi.common.TimerManager";

private static final String CLASS_NAME_FactoryManager = "com.helloworld.android.tvapi.factory.FactoryManager";


private HashMap<String, Object> allObjs = new HashMap<String, Object>();

public Tm() {
    allObjs.put(CLASS_NAME_TVMANAGER, TvManager.getInstance());
    allObjs.put(CLASS_NAME_PICTUREMANAGER, PictureManager.getInstance());
    allObjs.put(CLASS_NAME_AUDIOMANAGER, TvManager.getInstance()
            .getAudioManager());
    allObjs.put(CLASS_NAME_CECMANAGER, TvManager.getInstance()
            .getCecManager());
    allObjs.put(CLASS_NAME_ChannelManager, TvManager.getInstance()
            .getChannelManager());
    allObjs.put(CLASS_NAME_DatabaseManager, TvManager.getInstance()
            .getDatabaseManager());
    allObjs.put(CLASS_NAME_MhlManager, TvManager.getInstance()
            .getMhlManager());
    allObjs.put(CLASS_NAME_ParentalcontrolManager, TvManager.getInstance()
            .getParentalcontrolManager());
    allObjs.put(CLASS_NAME_PipManager, TvManager.getInstance()
            .getPipManager());
    allObjs.put(CLASS_NAME_PvrManager, TvManager.getInstance()
            .getPvrManager());
    allObjs.put(CLASS_NAME_TimerManager, TvManager.getInstance()
            .getTimerManager());
    allObjs.put(CLASS_NAME_FactoryManager,TvManager.getInstance().getFactoryManager());

}

public static void main(String[] args) {
    try {
        (new Tm()).run(args);
    } catch (Exception e) {
        e.printStackTrace();
    }

}


private void run(String[] args) throws Exception {
    dumpArgs(args);
    if (args.length < 2) {
        showUsage();
        return;

    }
    int index = 0;
    String command = args[index];
    String hasClassName = null;
    String hasMethodName = null;
    String hasStaticMethod = null;
    boolean hasArgs = false;
    String[] argsArray = null;
    int argsCount = 0;
    if (args.length > 2) {
        hasArgs = true;
        argsArray = new String[args.length - 2];
    }

    for (int i = 0; i < args.length; i++) {
        if (args[i].startsWith(CLASSNAME)) {
            hasClassName = args[i].substring(CLASSNAME.length());
        } else if (args[i].startsWith(METHOD)) {
            hasMethodName = args[i].substring(METHOD.length());
        } else if (args[i].startsWith(STATIC_METHOD)) {
            hasStaticMethod = args[i].substring(STATIC_METHOD.length());
        } else {
            if (argsArray != null) {
                argsArray[argsCount++] = args[i];
            }
        }
    }
    System.out.println("ClassName : " + hasClassName + "Method : "
            + hasMethodName + " StaticMethod : " + hasStaticMethod);
    System.out.println("dump Args :");
    dumpArgs(argsArray);

    if ((hasClassName == null)
            || ((hasClassName != null) && (hasMethodName == null) && (hasStaticMethod == null))) {
        System.out.println("Error ClassName : " + hasClassName
                + "Method : " + hasMethodName + " StaticMethod : "
                + hasStaticMethod);
    }
    Object[] argsObjArray = null;
    Class[] argsClassArray = null;
    if (hasArgs) {
        argsObjArray = getObjectArrayForString(argsArray);
        argsClassArray = getClassArrayForString(argsArray);
        if (argsObjArray.length != argsClassArray.length) {
            System.out.println("dismatched args");
        }
    }
    dumpArgs(argsObjArray);
    dumpArgs(argsClassArray);
    Class cls = null;
    try {
        cls = Class.forName(hasClassName);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
        cls = null;
        System.out.println(hasClassName + " not found");
    }
    if (cls == null) {
        return;
    }
    Constructor[] constructors = cls.getDeclaredConstructors();
    if (constructors == null || constructors.length == 0)
        return;
    Method[] allMethod = null;
    try {
        allMethod = cls.getDeclaredMethods();
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("this object has no method");
    }
    setAllMethodAccessible(allMethod);
    Field[] allField = null;
    try {
        allField = cls.getDeclaredFields();
    } catch (Exception e) {
        e.printStackTrace();
        System.out.println("this object has no field");
    }
    setAllFieldAccessible(allField);

    Object obj = getObjectForClassName(hasClassName);

    Method method = cls.getDeclaredMethod(hasMethodName, argsClassArray);
    Object result = method.invoke(obj, argsObjArray);
    System.out.println(hasClassName + "." + hasMethodName + " return "
            + result);

}

private Object getObjectForClassName(String classname) {
    return allObjs.get(classname);
}

private void setAllMethodAccessible(Method[] methods) {

    if (methods == null || methods.length <= 0)
        return;
    for (Method method : methods) {
        method.setAccessible(true);
    }
}

private void setAllFieldAccessible(Field[] fields) {

    if (fields == null || fields.length <= 0)
        return;
    for (Field field : fields) {
        field.setAccessible(true);
    }
}

private Object[] getObjectArrayForString(String args[]) throws Exception {

    if (args == null || args.length < 1)
        return (Object[]) null;
    Object[] tmp = new Object[args.length];
    for (int i = 0; i < args.length; i++) {
        String arg = args[i];
        if ((arg == null) || (arg.length() <= 2) || (!arg.startsWith("-"))
                || (!isObjectTypeLegal(arg.charAt(1)))) {
            throw (new Exception("args nor right"));
        } else {
            Object obj = getObjectForString(arg);
            if (obj == null)
                throw (new Exception("args nor right"));
            tmp[i] = obj;
        }

    }
    return tmp;

}

private Class[] getClassArrayForString(String[] args) throws Exception {
    if (args == null || args.length < 1)
        return (Class[]) null;
    Class[] tmp = new Class[args.length];
    for (int i = 0; i < args.length; i++) {
        tmp[i] = getClassForString(args[i]);
        if(tmp[i] == null){
            throw (new Exception("args nor right,can't find class"));
        }
    }
    return tmp;
}

private boolean isObjectTypeLegal(char type) {
    if (type == 'i' || type == 'c' || type == 's' || type == 'd'
            || type == 'S' || type == 'b' || type == 'e')
        return true;
    return false;
}

private Class getClassForString(String arg) {

    if ((arg == null) || (arg.length() <= 2))
        return null;

    if (arg.startsWith(ARGS_BOOLEAN)) {

        return boolean.class;
    }

    if (arg.startsWith(ARGS_CHAR)) {

        return char.class;
    }

    if (arg.startsWith(ARGS_DOUBLE)) {

        return double.class;
    }

    if (arg.startsWith(ARGS_INT)) {
        return int.class;
    }

    if (arg.startsWith(ARGS_SHORT)) {
        return short.class;
    }

    if (arg.startsWith(ARGS_STRING)) {
        return String.class;
    }

    if (arg.startsWith(ARGS_LONG)) {
        return long.class;
    }

    if(arg.startsWith(ARGS_ENUM)){
        String tmp = convertString(arg.substring(2));
        String enumClassName = tmp.substring(0, tmp.lastIndexOf("."));
        Class cls =null;
        try {
            cls = Class.forName(enumClassName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            cls= null;
        }
        return cls;
    }
    return null;

}

private String convertString(String source){

    if(source != null)
    return source.replace("*", "$");
    return null;
}

private Object getObjectForString(String arg) {

    if ((arg == null) || (arg.length() <= 2))
        return null;

    if (arg.startsWith(ARGS_BOOLEAN)) {
        String tmp = arg.substring(2);
        if ("true".equals(tmp) || "1".equals(tmp)) {
            return true;
        }
        if ("false".equals(tmp) || "0".equals(tmp)) {
            return false;
        }
        return null;
    }

    if (arg.startsWith(ARGS_CHAR)) {
        char tmp = arg.charAt(2);
        return tmp;
    }

    if (arg.startsWith(ARGS_DOUBLE)) {
        String tmp = arg.substring(2);
        return new Double(tmp);
    }

    if (arg.startsWith(ARGS_INT)) {
        String tmp = arg.substring(2);
        return Integer.parseInt(tmp);
    }

    if (arg.startsWith(ARGS_SHORT)) {
        String tmp = arg.substring(2);
        return Short.parseShort(tmp);
    }

    if (arg.startsWith(ARGS_STRING)) {
        String tmp = arg.substring(2);
        return tmp;
    }

    if (arg.startsWith(ARGS_LONG)) {
        String tmp = arg.substring(2);
        return Long.parseLong(tmp);
    }

    if (arg.startsWith(ARGS_ENUM)) {
        String tmp = convertString(arg.substring(2));
        String enumClassName = tmp.substring(0, tmp.lastIndexOf("."));
        String enumName = tmp.substring(tmp.lastIndexOf(".") + 1);
        Class cls =null;
        try {
            cls = Class.forName(enumClassName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            cls= null;
        }
        if(cls == null) return null;
        System.out.println("enumClassName="+enumClassName + " enumName="+enumName);
        return Enum.valueOf(cls, enumName);

    }
    return null;

}

private void dumpArgs(Object[] args) {
    if (args != null) {
        for (Object tmp : args) {
            System.out.print(tmp + "|");
        }
    }
    System.out.println();

}

private void showUsage() {
    //tm --class=com.helloworld.android.tvapi.common.PictureManager --method=setBacklight -i10 
    //tm --class=com.helloworld.android.tvapi.common.PictureManager --method=setMfc -ecom.helloworld.android.tvapi.common.vo.EnumMfcMode.E_OFF
    System.out.println("tm --class=com.helloworld.xxx --method=xxx [-iXXX -cXXX -sXXX -dXXX -SXXX -bXXX -eXXX -lXXX]");
    System.out.println("--method you can append your class argument after --class,such as --class=com.helloworld.android.tvapi.common.PictureManager");
    System.out.println("--method you can append your method argument after --method,such as --method=setBacklight");
    System.out.println("-iXXX you can append an int argument after -i,such as -i10");
    System.out.println("-cXXX you can append an char argument after -c,such as -ic");
    System.out.println("i represents integer, c represents char, s represents shot, S represents String, d represent double, b reprents bool , e reprements enum, l represents long");
    System.out.println("-e is a little complex, for example public final void setMfc(EnumMfcMode mfcMode), you should use like follow");
    System.out.println("tm --class=com.helloworld.android.tvapi.common.PictureManager --method=setMfc -ecom.helloworld.android.tvapi.common.vo.EnumMfcMode.E_OFF");
    System.err.println();
}

}