设为首页收藏一下又不会死！新人公告
切换到窄版

 找回密码
 立即注册→加入我们

QQ登录

只需一步，快速开始

搜索
热搜: 下载 VB C 实现 编写
技术宅的结界»论坛 › 计算机技术 › 源码分享 › 豌豆荚基础库
返回列表 发新帖
查看: 2495|回复: 1

豌豆荚基础库

[复制链接]
元始天尊
发表于 2016-3-20 17:21:57 | 显示全部楼层 |阅读模式

欢迎访问技术宅的结界，请注册或者登录吧。

您需要 登录 才可以下载或查看，没有账号？立即注册→加入我们

×
  1. package base.dexs;

  3. import android.content.Context;
  4. import android.os.Build;
  5. import base.reflect.JavaCalls;
  6. import base.utils.ArrayUtil;
  7. import dalvik.system.DexFile;
  8. import java.io.File;
  9. import java.io.IOException;
  10. import java.util.Set;
  11. import java.util.zip.ZipFile;

  13. public class ContextClassLoaderUtility {
  14.     private static final String LOG_TAG = "ContextClassLoaderUtility";
  15.     private ContextClassLoaderUtility() {
  16.         super();
  17.     }

  19.     static class Element {
  20.         public final File file;
  21.         public final ZipFile zipFile;
  22.         public final DexFile dexFile;

  24.         public Element(File file, ZipFile zipFile, DexFile dexFile) {
  25.             this.file = file;
  26.             this.zipFile = zipFile;
  27.             this.dexFile = dexFile;
  28.         }
  29.     }

  31.     private static DexFile createDexFile(File file, File optimizedDirectory) {
  32.         if(Build.VERSION.SDK_INT >= 14) {
  33.             return (DexFile) JavaCalls.callStaticMethod("dalvik.system.DexPathList", "loadDexFile",
  34.                     new Object[]{file, optimizedDirectory});
  35.         }
  36.         else{
  37.             String outputName = (String) JavaCalls.callStaticMethod("dalvik.system.DexClassLoader", "generateOutputName",
  38.                     new Object[]{file.getAbsolutePath(), optimizedDirectory.getAbsolutePath()});
  39.             try {
  40.                 return DexFile.loadDex(file.getAbsolutePath(), outputName, 0);
  41.             }
  42.             catch(IOException e) {
  43.             }
  44.         }
  45.         return null;
  46.     }

  48.     private static Element createElement(File file, File optimizedDirectory) {
  49.         String fileName = file.getName();
  50.         ZipFile zipfile = null;
  51.         DexFile dexfile = null;
  52.         if(!fileName.endsWith(".dex")) {
  53.             if(!fileName.endsWith(".apk") && !fileName.endsWith(".jar") && !fileName.endsWith(".zip") && !fileName.endsWith(".so")) {
  54.                 throw new IllegalArgumentException("Unknown file type for: " + file);
  55.             }
  56.             try {
  57.                 zipfile = new ZipFile(file);
  58.             }
  59.             catch(IOException e) {

  61.             }
  62.         }
  63.         dexfile = ContextClassLoaderUtility.createDexFile(file, optimizedDirectory);
  64.         return new Element(file, zipfile, dexfile);
  65.     }

  67.     private static Object[] createEmptyDexElements(int num) {
  68.         Class cls = null;
  69.         try {
  70.             cls = Class.forName("dalvik.system.DexPathList$Element");
  71.         }
  72.         catch(ClassNotFoundException v0) {
  73.             throw new IllegalArgumentException("Can't find class: dalvik.system.DexPathList$Element");
  74.         }
  75.         Object[] obj = new Object[num];
  76.         for(int i = 0; i < num; ++i) {
  77.             obj[i] = JavaCalls.newEmptyInstance(cls);
  78.         }
  79.         return obj;
  80.     }

  82.     private static Object[] getDexElements(ClassLoader clsloader) {
  83.         return (Object[]) JavaCalls.getField(JavaCalls.getField(clsloader, "pathList"), "dexElements");
  84.     }

  86.     private static File getOptDir(Context context) {
  87.         File dir = new File(context.getFilesDir(), "opt");
  88.         if(!dir.exists()) {
  89.             if(!dir.mkdirs()) {
  90.                 return null;//create opt dir meet ex.
  91.             }
  92.             return dir;
  93.         }
  94.         else if(dir.isFile()) {
  95.             if((dir.delete()) && (dir.mkdirs())) {
  96.                 return dir;
  97.             }
  98.         }
  99.         else if(dir.isDirectory()) {
  100.             return dir;
  101.         }
  102.         return null;//create opt dir meet ex.
  103.     }

  105.     public static void inject(Context context, Set<String> pathset) {
  106.         if(pathset != null && !pathset.isEmpty()) {
  107.             String[] patharr = pathset.toArray(new String[pathset.size()]);
  108.             if(Build.VERSION.SDK_INT >= 14) {
  109.                 ContextClassLoaderUtility.injectV14(context, patharr);
  110.             }
  111.             else {
  112.                 ContextClassLoaderUtility.injectBelowV14(context, patharr);
  113.             }
  114.         }
  115.     }

  117.     private static void injectBelowV14(Context context, String[] patharr) {
  118.         File dir = ContextClassLoaderUtility.getOptDir(context);
  119.         File[] files = new File[patharr.length];
  120.         ZipFile[] zfiles = new ZipFile[patharr.length];
  121.         DexFile[] dfiles = new DexFile[patharr.length];
  122.         for(int i = 0; i < patharr.length; ++i) {
  123.             ContextClassLoaderUtility.resetValueBelowV14(new File(patharr[i]), dir, files, zfiles, dfiles, i);
  124.         }
  125.         ClassLoader loader = context.getClassLoader();
  126.         Object mFiles = JavaCalls.getField(loader, "mFiles");
  127.         Object mPaths = JavaCalls.getField(loader, "mPaths");
  128.         Object mZips = JavaCalls.getField(loader, "mZips");
  129.         Object mDexs = JavaCalls.getField(loader, "mDexs");
  130.         JavaCalls.setField(loader, "mPaths", ArrayUtil.combineArray((Object[])mPaths, patharr));
  131.         JavaCalls.setField(loader, "mFiles", ArrayUtil.combineArray((Object[])mFiles, files));
  132.         JavaCalls.setField(loader, "mZips", ArrayUtil.combineArray((Object[])mZips, zfiles));
  133.         JavaCalls.setField(loader, "mDexs", ArrayUtil.combineArray((Object[])mDexs, dfiles));
  134.     }

  136.     private static void injectV14(Context context, String[] file) {
  137.         File dir = ContextClassLoaderUtility.getOptDir(context);
  138.         Object[] objarr = ContextClassLoaderUtility.createEmptyDexElements(file.length);
  139.         for(int i = 0; i < file.length; ++i) {
  140.             ContextClassLoaderUtility.resetValueV14(new File(file[i]), dir, objarr[i]);
  141.         }
  142.         ClassLoader loader = context.getClassLoader();
  143.         ContextClassLoaderUtility.setDexElements(loader, ArrayUtil.combineArray(ContextClassLoaderUtility.getDexElements(loader), objarr));
  144.     }

  146.     private static void resetValueBelowV14(File file, File optimizedDirectory, Object[] files, Object[] zfiles, Object[] dfiles, int index) {
  147.         Element ele = createElement(file, optimizedDirectory);
  148.         if(ele != null) {
  149.             if(index < files.length) {
  150.                 files[index] = ele.file;
  151.             }
  152.             if(index < zfiles.length) {
  153.                 zfiles[index] = ele.zipFile;
  154.             }
  155.             if(index < dfiles.length) {
  156.                 dfiles[index] = ele.dexFile;
  157.             }
  158.         }
  159.     }

  161.     private static void resetValueV14(File file, File optimizedDirectory, Object clsobj) {
  162.         Element ele = createElement(file, optimizedDirectory);
  163.         if(ele != null) {
  164.             JavaCalls.setField(clsobj, "file", ele.file);
  165.             JavaCalls.setField(clsobj, "zipFile", ele.zipFile);
  166.             JavaCalls.setField(clsobj, "dexFile", ele.dexFile);
  167.         }
  168.     }

  170.     private static void setDexElements(ClassLoader loader, Object[] elements) {
  171.         JavaCalls.setField(JavaCalls.getField(loader, "pathList"), "dexElements", elements);
  172.     }
  173. }
  174. package base.dexs;

  176. import android.content.Context;
  177. import android.os.Build;

  179. import java.io.File;
  180. import java.util.List;

  182. import base.reflect.JavaCalls;
  183. import base.utils.ArrayUtil;

  185. public class ContextLibraryUtility {
  186.     private ContextLibraryUtility() {
  187.         super();
  188.     }

  190.     public static void inject(Context context, File file) {
  191.         if(Build.VERSION.SDK_INT >= 14) {
  192.             ContextLibraryUtility.injectV14(context, file);
  193.         }
  194.         else if(Build.VERSION.SDK_INT >= 9) {
  195.             injectV9(context, file);
  196.         }
  197.         else {
  198.            injectBelowV9(context, file);
  199.         }
  200.     }

  202.     private static void injectBelowV9(Context context, File libdir) {
  203.         String[] v0_2;
  204.         ClassLoader loader = context.getClassLoader();
  205.         Object[] mLibPathsOld = (Object[]) JavaCalls.getField(loader, "mLibPaths");
  206.         Object[] mLibPathsNew = null;
  207.         String libdirslash = libdir.getAbsolutePath() + "/";
  208.         if(mLibPathsOld.length > 0) {
  209.             mLibPathsNew = ArrayUtil.insert(mLibPathsOld, 1, libdirslash);
  210.         }
  211.         else {
  212.             mLibPathsNew = new String[]{libdirslash};
  213.         }

  215.         JavaCalls.setField(loader, "mLibPaths", mLibPathsNew);
  216.     }

  218.     private static void injectV14(Context context, File libdir) {
  219.         Object pathList = JavaCalls.getField(context.getClassLoader(), "pathList");
  220.         Object[] nativeLibraryDirectoriesOld = (Object[]) JavaCalls.getField(pathList, "nativeLibraryDirectories");
  221.         Object[] nativeLibraryDirectoriesNew = null;
  222.         if(nativeLibraryDirectoriesOld.length > 0) {
  223.             nativeLibraryDirectoriesNew = ArrayUtil.insert(nativeLibraryDirectoriesOld, 1, libdir);
  224.         }
  225.         else {
  226.             nativeLibraryDirectoriesNew = new File[]{libdir};
  227.         }
  228.         JavaCalls.setField(pathList, "nativeLibraryDirectories", nativeLibraryDirectoriesNew);
  229.     }

  231.     private static void injectV9(Context context, File libdir) {
  232.         List libraryPathElements = (List) JavaCalls.getField(context.getClassLoader(), "libraryPathElements");
  233.         String libdirslash = libdir.getAbsolutePath() + "/";
  234.         if((libraryPathElements).size() > 0) {
  235.             libraryPathElements.add(1, libdirslash);
  236.         }
  237.         else {
  238.             libraryPathElements.add(libdirslash);
  239.         }
  240.     }
  241. }
复制代码

  1. package base.reflect;

  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.InvocationTargetException;
  6. import java.lang.reflect.Method;
  7. import java.util.HashMap;
  8. import java.util.Map;

  10. @SuppressWarnings("unchecked")
  11. public class JavaCalls {
  12.     private static final String LOG_TAG = "JavaCalls";
  13.     private static Map<Class<?>,Class<?>> PRIMITIVE_MAP = null;
  14.    
  15.     public class JavaParam{
  16.             Class clazz;
  17.             Object obj;
  18.             public JavaParam(Class cls,Object o){
  19.                     clazz = cls;
  20.                     obj = o;
  21.             }
  22.     }

  24.     static  {
  25.         JavaCalls.PRIMITIVE_MAP = new HashMap<Class<?>,Class<?>>();
  26.         JavaCalls.PRIMITIVE_MAP.put(Boolean.class, Boolean.TYPE);
  27.         JavaCalls.PRIMITIVE_MAP.put(Byte.class, Byte.TYPE);
  28.         JavaCalls.PRIMITIVE_MAP.put(Character.class, Character.TYPE);
  29.         JavaCalls.PRIMITIVE_MAP.put(Short.class, Short.TYPE);
  30.         JavaCalls.PRIMITIVE_MAP.put(Integer.class, Integer.TYPE);
  31.         JavaCalls.PRIMITIVE_MAP.put(Float.class, Float.TYPE);
  32.         JavaCalls.PRIMITIVE_MAP.put(Long.class, Long.TYPE);
  33.         JavaCalls.PRIMITIVE_MAP.put(Double.class, Double.TYPE);
  34.         JavaCalls.PRIMITIVE_MAP.put(Boolean.TYPE, Boolean.TYPE);
  35.         JavaCalls.PRIMITIVE_MAP.put(Byte.TYPE, Byte.TYPE);
  36.         JavaCalls.PRIMITIVE_MAP.put(Character.TYPE, Character.TYPE);
  37.         JavaCalls.PRIMITIVE_MAP.put(Short.TYPE, Short.TYPE);
  38.         JavaCalls.PRIMITIVE_MAP.put(Integer.TYPE, Integer.TYPE);
  39.         JavaCalls.PRIMITIVE_MAP.put(Float.TYPE, Float.TYPE);
  40.         JavaCalls.PRIMITIVE_MAP.put(Long.TYPE, Long.TYPE);
  41.         JavaCalls.PRIMITIVE_MAP.put(Double.TYPE, Double.TYPE);
  42.     }

  44.     public JavaCalls() {
  45.         super();
  46.     }

  48.     public static Object callMethod(Object clsObject, String methodName, Object[] params) {
  49.         Object result;
  50.         try {
  51.             result = JavaCalls.callMethodOrThrow(clsObject,methodName,params);
  52.         }
  53.         catch(Exception v0) {
  54.             result = null;
  55.         }

  57.         return result;
  58.     }

  60.     public static Object callMethodOrThrow(Object clsObject, String methodName, Object[] params)
  61.                     throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
  62.         return JavaCalls.getDeclaredMethod(clsObject.getClass(), methodName, JavaCalls.getParameterTypes(params))
  63.                 .invoke(clsObject, JavaCalls.getParameters(params));
  64.     }

  66.     public static Object callStaticMethod(String clsName, String method, Object[] params) {
  67.         Object obj = null;
  68.         try {
  69.             obj = JavaCalls.callStaticMethodOrThrow(Class.forName(clsName), method, params);
  70.         }
  71.         catch(Exception v0) {
  72.         }
  73.         return obj;
  74.     }

  76.     public static Object callStaticMethodOrThrow(Class cls, String method, Object[] params)
  77.                     throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
  78.         return JavaCalls.getDeclaredMethod(cls, method, JavaCalls.getParameterTypes(params)).invoke(null
  79.                 , JavaCalls.getParameters(params));
  80.     }

  82.     public static Object callStaticMethodOrThrow(String clsName, String method, Object[] params)
  83.                     throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, ClassNotFoundException {
  84.         return JavaCalls.getDeclaredMethod(Class.forName(clsName), method, JavaCalls.getParameterTypes(params
  85.                 )).invoke(null, JavaCalls.getParameters(params));
  86.     }

  88.     /*
  89.      * �Ƚ��෽����������
  90.      */
  91.     private static boolean compareClassLists(Class[] paramTypes1, Class[] paramTypes2) {
  92.         if(paramTypes1 == null || paramTypes1.length == 0) {
  93.             if(paramTypes2 == null || paramTypes2.length == 0) {
  94.                 return true;
  95.             }
  96.                         else{
  97.                                 return false;
  98.                         }
  99.         }
  100.         else {
  101.                 if(paramTypes2 == null || paramTypes2.length == 0){
  102.                         return false;
  103.                 }
  104.                 if(paramTypes1.length != paramTypes2.length){
  105.                         return false;
  106.                 }
  107.                 for(int i=0;i<paramTypes1.length;i++){
  108.                         if(!paramTypes1[i].isAssignableFrom(paramTypes2[i])) {
  109.                     if(JavaCalls.PRIMITIVE_MAP.containsKey(paramTypes1[i])) {
  110.                         if(!JavaCalls.PRIMITIVE_MAP.get(paramTypes1[i]).equals(JavaCalls.PRIMITIVE_MAP.get(
  111.                                 paramTypes2[i]))) {
  112.                                 return false;
  113.                         }
  114.                     }
  115.                 }
  116.                 }
  117.                 return true;
  118.         }
  119.     }

  121.     private static Method findMethodByName(Method[] methodArr, String methodName, Class[] methodParamCls) {
  122.         Method method = null;
  123.         if(methodName == null) {
  124.             throw new NullPointerException("Method name must not be null.");
  125.         }
  126.         for(int i = 0; i < methodArr.length; ++i) {
  127.             method = methodArr[i];
  128.             if((method.getName().equals(methodName)) && (JavaCalls.compareClassLists(method.getParameterTypes(), methodParamCls
  129.                     ))) {
  130.                 return method;
  131.             }
  132.         }
  133.         return null;
  134.     }

  136.     private static Method getDeclaredMethod(Class cls, String methodName, Class[] methodParamCls) {
  137.         Method method = null;
  138.         try{
  139.             while(method == null) {
  140.                 method = JavaCalls.findMethodByName(cls.getDeclaredMethods(), methodName, methodParamCls);
  141.                 if(method == null) {
  142.                     if(cls.getSuperclass() == null) {
  143.                             throw new NoSuchMethodException();
  144.                     }
  145.                     cls = cls.getSuperclass();
  146.                 }
  147.             }
  148.             method.setAccessible(true);       
  149.         }
  150.         catch(Exception e){
  151.                
  152.         }
  153.         return method;
  154.     }

  156.     private static Object getDefaultValue(Class cls) {
  157.         if((Integer.TYPE.equals(cls)) || (Integer.class.equals(cls)) || (Byte.TYPE.equals(cls)) ||
  158.                 (Byte.class.equals(cls)) || (Short.TYPE.equals(cls)) || (Short.class.equals(cls))
  159.                  || (Long.TYPE.equals(cls)) || (Long.class.equals(cls)) || (Double.TYPE.equals(cls
  160.                 )) || (Double.class.equals(cls)) || (Float.TYPE.equals(cls)) || (Float.class.equals
  161.                 (cls))) {
  162.             return Integer.valueOf(0);
  163.         }
  164.         else {
  165.             if(!Boolean.TYPE.equals(cls) && !Boolean.class.equals(cls)) {
  166.                 if(!Character.TYPE.equals(cls) && !Character.class.equals(cls)) {
  167.                     return null;
  168.                 }
  169.                 return Character.valueOf('\u0000');
  170.             }
  171.             return Boolean.valueOf(false);
  172.         }
  173.     }

  175.     public static Object getField(Object clsObject, String fieldName) {
  176.         try {
  177.                         return JavaCalls.getFieldOrThrow(clsObject, fieldName);
  178.                 }
  179.                 catch (IllegalArgumentException e) {
  180.                
  181.                 }
  182.                 catch (IllegalAccessException e) {
  183.                
  184.                 }
  185.                 catch (NoSuchFieldException e) {
  186.                
  187.                 }
  188.                 return null;
  189.     }

  191.     public static Object getFieldOrThrow(Object clsObj, String fieldName)
  192.     throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException {
  193.         Class cls = clsObj.getClass();
  194.         Field field = null;
  195.         do {
  196.             if(field != null) {
  197.                     field.setAccessible(true);
  198.                         return field.get(clsObj);
  199.             }

  201.             try {
  202.                 field = cls.getDeclaredField(fieldName);
  203.                 field.setAccessible(true);
  204.             }
  205.             catch(NoSuchFieldException v2) {
  206.                 cls = cls.getSuperclass();
  207.             }
  208.         }
  209.         while(cls != null);

  211.         throw new NoSuchFieldException();
  212.     }

  214.     private static Class[] getParameterTypes(Object[] clsObject) {
  215.         Class[] cls = null;
  216.         if(clsObject != null && clsObject.length > 0) {
  217.             cls = new Class[clsObject.length];
  218.             for(int i = 0; i < clsObject.length; ++i) {
  219.                 Object cur = clsObject[i];
  220.                 if(cur != null && ((cur instanceof JavaParam))) {
  221.                     cls[i] = ((JavaParam)cur).clazz;
  222.                 }
  223.                 else if(cur == null) {
  224.                     cls[i] = null;
  225.                 }
  226.                 else {
  227.                         cls[i] = cur.getClass();
  228.                 }
  229.             }
  230.         }
  231.         return cls;
  232.     }

  234.     private static Object[] getParameters(Object[] params) {
  235.         Object[] objs = null;
  236.         if(params != null && params.length > 0) {
  237.             objs = new Object[params.length];
  238.             for(int i = 0; i < params.length; ++i) {
  239.                 Object cur = params[i];
  240.                 if(cur == null || !(cur instanceof JavaParam)) {
  241.                     objs[i] = cur;
  242.                 }
  243.                 else {
  244.                     objs[i] = ((JavaParam)cur).obj;
  245.                 }
  246.             }
  247.         }
  248.         return objs;
  249.     }

  251.     public static Object newEmptyInstance(Class cls) {
  252.         Object o = null;
  253.         try {
  254.             o = JavaCalls.newEmptyInstanceOrThrow(cls);
  255.         }
  256.         catch(Exception v0) {
  257.         }
  258.         return o;
  259.     }

  261.     public static Object newEmptyInstanceOrThrow(Class cls)
  262.             throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
  263.         Object o;
  264.         Constructor[] cons = cls.getDeclaredConstructors();
  265.         if(cons != null && cons.length != 0) {
  266.             Constructor cur = cons[0];
  267.             cur.setAccessible(true);
  268.             Class[] paramcls = cur.getParameterTypes();
  269.             if(paramcls == null || paramcls.length == 0) {
  270.                 o = cur.newInstance();
  271.             }
  272.             else {
  273.                 Object[] tmp = new Object[paramcls.length];
  274.                 for(int i=0;i<paramcls.length;i++){
  275.                         tmp[i] = JavaCalls.getDefaultValue(paramcls[i]);
  276.                 }
  277.                 o = cur.newInstance(tmp);
  278.             }
  279.             return o;
  280.         }

  282.         throw new IllegalArgumentException("Can\'t get even one available constructor for " + cls);
  283.     }

  285.     public static Object newInstance(Class cls, Object[] params) {
  286.         Object o = null;
  287.         try {
  288.             o = JavaCalls.newInstanceOrThrow(cls, params);
  289.         }
  290.         catch(Exception v0) {
  291.         }
  292.         return o;
  293.     }

  295.     public static Object newInstance(String clsName, Object[] params) {
  296.         Object o = null;
  297.         try {
  298.             o = JavaCalls.newInstanceOrThrow(clsName, params);
  299.         }
  300.         catch(Exception v0) {

  302.         }
  303.         return o;
  304.     }

  306.     public static Object newInstanceOrThrow(Class cls, Object[] params)
  307.     throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
  308.         return cls.getConstructor(JavaCalls.getParameterTypes(params)).newInstance(JavaCalls.getParameters
  309.                 (params));
  310.     }

  312.     public static Object newInstanceOrThrow(String clsName, Object[] params)
  313.     throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
  314.         return JavaCalls.newInstanceOrThrow(Class.forName(clsName), JavaCalls.getParameters(params));
  315.     }

  317.     public static void setField(Object clsObj, String fieldName, Object dataToset) {
  318.         try {
  319.             JavaCalls.setFieldOrThrow(clsObj, fieldName, dataToset);
  320.         }
  321.         catch(IllegalAccessException v0) {
  322.         }
  323.         catch(NoSuchFieldException v0_1) {
  324.         }
  325.     }

  327.     public static void setFieldOrThrow(Object clsObj, String fieldName, Object dataToset) throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
  328.         Class cls = clsObj.getClass();
  329.         Field field = null;
  330.         do {
  331.             if(field != null) {
  332.                 field.setAccessible(true);
  333.                 field.set(clsObj, dataToset);
  334.                 return;
  335.             }
  336.             try {
  337.                 field = cls.getDeclaredField(fieldName);
  338.             }
  339.             catch(NoSuchFieldException v2) {
  340.                 cls = cls.getSuperclass();
  341.             }
  342.         }
  343.         while(cls != null);

  345.         throw new NoSuchFieldException();
  346.     }
  347. }
复制代码

  1. package base.storage;

  3. import android.content.Context;
  4. import android.content.IntentFilter;
  5. import android.content.SharedPreferences;
  6. import android.content.SharedPreferences$Editor;
  7. import android.os.Build;
  8. import android.os.Build$VERSION;
  9. import android.os.Environment;
  10. import android.os.Handler;
  11. import android.os.Looper;
  12. import android.text.TextUtils;
  13. import com.wandoujia.base.config.GlobalConfig;
  14. import com.wandoujia.base.utils.FileUtil;
  15. import com.wandoujia.base.utils.SharePrefSubmitor;
  16. import java.io.BufferedReader;
  17. import java.io.File;
  18. import java.io.FileInputStream;
  19. import java.io.FileNotFoundException;
  20. import java.io.IOException;
  21. import java.io.InputStreamReader;
  22. import java.lang.reflect.InvocationTargetException;
  23. import java.lang.reflect.Method;
  24. import java.nio.Buffer;
  25. import java.util.ArrayList;
  26. import java.util.HashMap;
  27. import java.util.Iterator;
  28. import java.util.List;

  30. public class StorageManager {
  31.     private static final int FORTH_LINE = 4;
  32.     private static final String GENERIC_CONFIG_PREFERENCE_NAME = "com.wandoujia.phoenix2";
  33.     private static final String KEY_LAST_USED_DIRECTORY = "key_last_used_directory";
  34.     private static final long LIMIT_SIZE = 52428800;
  35.     private static final int MIN_SDK = 14;
  36.     private static final String ROOT_DIR = "/wandoujia/";
  37.     private List availableStoragesPathList;
  38.     private String defaultExternalStorageDirectory;
  39.     private SharedPreferences genericSharedPrefs;
  40.     private static StorageManager instance;
  41.     private final List rdcListeners;

  43.     private StorageManager() {
  44.         super();
  45.         this.genericSharedPrefs = GlobalConfig.getAppContext().getSharedPreferences("com.wandoujia.phoenix2"
  46.                 , 0);
  47.         this.registerReceiver();
  48.         this.rdcListeners = new ArrayList();
  49.         this.availableStoragesPathList = this.getAvailableStorages();
  50.         this.defaultExternalStorageDirectory = this.genericSharedPrefs.getString("key_last_used_directory"
  51.                 , null);
  52.         this.checkDefaultPathAvailable();
  53.     }

  55.     public HashMap getAvailableDirectories(long arg10) {
  56.         HashMap v1 = new HashMap();
  57.         Iterator v2 = this.availableStoragesPathList.iterator();
  58.         while(v2.hasNext()) {
  59.             Object v0 = v2.next();
  60.             long v4 = FileUtil.getAvailableBytes(((String)v0));
  61.             if(v4 <= 52428800 + arg10) {
  62.                 continue;
  63.             }

  65.             v1.put(v0, Long.valueOf(v4));
  66.         }

  68.         return v1;
  69.     }

  71.     public String getAvailableDirectory(List arg13, long arg14) {
  72.         Object v1_1;
  73.         long v0_1;
  74.         Object v2_1;
  75.         String v1 = null;
  76.         long v4 = -1;
  77.         Iterator v6 = arg13.iterator();
  78.         while(v6.hasNext()) {
  79.             Object v0 = v6.next();
  80.             long v2 = FileUtil.getAvailableBytes(((String)v0));
  81.             if(v2 <= v4 || FileUtil.getAvailableBytes(((String)v0)) <= arg14) {
  82.                 v2_1 = v1;
  83.                 v0_1 = v4;
  84.             }
  85.             else {
  86.                 long v10 = v2;
  87.                 v2_1 = v0;
  88.                 v0_1 = v10;
  89.             }

  91.             v4 = v0_1;
  92.             v1_1 = v2_1;
  93.         }

  95.         return ((String)v1_1);
  96.     }



  100.     public List getExternalStorageDirectories() {
  101.         return this.availableStoragesPathList;
  102.     }

  104.     public String getExternalStorageDirectory() {
  105.         return this.getExternalStorageDirectory(0);
  106.     }

  108.     public String getExternalStorageDirectory(long arg10) {
  109.         String v0_1;
  110.         if(FileUtil.getAvailableBytes(this.defaultExternalStorageDirectory) < 52428800 + arg10) {
  111.             String v1 = this.defaultExternalStorageDirectory;
  112.             ArrayList v2 = new ArrayList();
  113.             ArrayList v3 = new ArrayList();
  114.             Iterator v4 = this.availableStoragesPathList.iterator();
  115.             while(v4.hasNext()) {
  116.                 Object v0 = v4.next();
  117.                 if(!TextUtils.isEmpty(this.defaultExternalStorageDirectory) && (this.defaultExternalStorageDirectory
  118.                         .equals(v0))) {
  119.                     continue;
  120.                 }

  122.                 if(!new File((((String)v0)) + "/wandoujia/").exists()) {
  123.                     goto label_29;
  124.                 }

  126.                 ((List)v3).add(v0);
  127.                 continue;
  128.             label_29:
  129.                 ((List)v2).add(v0);
  130.             }

  132.             v0_1 = this.getAvailableDirectory(((List)v3), arg10);
  133.             if(TextUtils.isEmpty(((CharSequence)v0_1))) {
  134.                 v0_1 = this.getAvailableDirectory(((List)v2), arg10);
  135.                 if(TextUtils.isEmpty(((CharSequence)v0_1))) {
  136.                     v0_1 = this.defaultExternalStorageDirectory;
  137.                     goto label_38;
  138.                 }
  139.                 else {
  140.                     this.defaultExternalStorageDirectory = v0_1;
  141.                 }
  142.             }
  143.             else {
  144.                 this.defaultExternalStorageDirectory = v0_1;
  145.             }

  147.             this.saveAndNotifyDefaultExternalStorageDiretory(v1, this.defaultExternalStorageDirectory
  148.                     );
  149.             goto label_42;
  150.         }
  151.         else {
  152.         label_42:
  153.             v0_1 = this.defaultExternalStorageDirectory;
  154.         }

  156.     label_38:
  157.         return v0_1;
  158.     }

  160.     public static StorageManager getInstance() {
  161.         if(StorageManager.instance == null) {
  162.             Class v1 = StorageManager.class;
  163.             __monitor_enter(v1);
  164.             try {
  165.                 if(StorageManager.instance == null) {
  166.                     StorageManager.instance = new StorageManager();
  167.                 }

  169.                 __monitor_exit(v1);
  170.             }
  171.             catch(Throwable v0) {
  172.                 try {
  173.                 label_12:
  174.                     __monitor_exit(v1);
  175.                 }
  176.                 catch(Throwable v0) {
  177.                     goto label_12;
  178.                 }

  180.                 throw v0;
  181.             }
  182.         }

  184.         return StorageManager.instance;
  185.     }

  187.     public boolean isStorageMounted() {
  188.         boolean v0_1;
  189.         List v0 = this.getExternalStorageDirectories();
  190.         if(v0 == null || v0.size() == 0) {
  191.             v0_1 = false;
  192.         }
  193.         else {
  194.             v0_1 = true;
  195.         }

  197.         return v0_1;
  198.     }

  200.     private void notifyPathChange(String arg5, String arg6) {
  201.         ArrayList v1 = new ArrayList();
  202.         List v2 = this.rdcListeners;
  203.         __monitor_enter(v2);
  204.         try {
  205.             Iterator v3 = this.rdcListeners.iterator();
  206.             while(v3.hasNext()) {
  207.                 Object v0_1 = v3.next().get();
  208.                 if(v0_1 == null) {
  209.                     goto label_15;
  210.                 }

  212.                 ((List)v1).add(v0_1);
  213.                 continue;
  214.             label_15:
  215.                 v3.remove();
  216.             }

  218.             __monitor_exit(v2);
  219.         }
  220.         catch(Throwable v0) {
  221.             goto label_13;
  222.         }

  224.         new Handler(Looper.getMainLooper()).post(new a(((List) v1), arg5, arg6));
  225.         return;
  226.         try {
  227.         label_13:
  228.             __monitor_exit(v2);
  229.         }
  230.         catch(Throwable v0) {
  231.             goto label_13;
  232.         }

  234.         throw v0;
  235.     }

  237.     private void registerReceiver() {
  238.         IntentFilter v0 = new IntentFilter();
  239.         v0.addAction("android.intent.action.MEDIA_MOUNTED");
  240.         v0.addAction("android.intent.action.MEDIA_UNMOUNTED");
  241.         v0.addDataScheme("file");
  242.         GlobalConfig.getAppContext().registerReceiver(new StorageManager$MediaReceiver(this, 0), v0)
  243.                 ;
  244.     }
  245. }
复制代码

  1. package base.utils;

  3. import java.lang.reflect.Field;

  5. import android.content.Context;
  6. import android.view.View;

  8. /*
  9. * ��ֹ���뷨���о����app�޷��ر�
  10. */
  11. public class ActivityLeakUtil {
  12.     public ActivityLeakUtil() {
  13.         super();
  14.     }

  16.     public static void fixInputMethodManagerLeak(Context context) {
  17.         if(context == null) {
  18.             return;
  19.         }

  21.         Object clsObj = context.getSystemService(Context.INPUT_METHOD_SERVICE);
  22.         if(clsObj == null) {
  23.             return;
  24.         }

  26.         String[] viewName = {
  27.                 "mCurRootView",
  28.                 "mServedView",
  29.                 "mNextServedView",
  30.         };

  32.         for(int i = 0; i < viewName.length; i++) {
  33.             try {
  34.                 Field field = clsObj.getClass().getDeclaredField(viewName[i]);
  35.                 if(!field.isAccessible()) {
  36.                     field.setAccessible(true);
  37.                 }

  39.                 Object fieldData = field.get(clsObj);
  40.                 if(fieldData == null || !(fieldData instanceof View) || ((View)fieldData).getContext() != context) {
  41.                     continue;
  42.                 }
  43.                 field.set(clsObj, null);
  44.             }
  45.             catch(Throwable t) {
  46.             }
  47.         }
  48.     }
  49. }

  51. package base.utils;

  53. import android.os.Build;
  54. import java.util.ArrayList;
  55. import java.util.List;

  57. public class AppKillBlacklistUtil {
  58.     private static List<String> appKillWhiteList = null;

  60.     static  {
  61.         AppKillBlacklistUtil.appKillWhiteList = new ArrayList<String>();
  62.         AppKillBlacklistUtil.appKillWhiteList.add("com.wandoujia.phoenix2");
  63.         AppKillBlacklistUtil.appKillWhiteList.add("com.wandoujia.roshan");
  64.         AppKillBlacklistUtil.appKillWhiteList.add("com.wandoujia.eyepetizer");
  65.         AppKillBlacklistUtil.appKillWhiteList.add("com.wandoujia");
  66.         AppKillBlacklistUtil.appKillWhiteList.add("android");
  67.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.phone");
  68.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.mms");
  69.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.systemui");
  70.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.settings");
  71.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.applications");
  72.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.contacts");
  73.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.userdictionary");
  74.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.telephony");
  75.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.drm");
  76.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.downloads");
  77.         AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.media");

  79.         if(Build.MANUFACTURER.equalsIgnoreCase("HTC")) {
  80.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.htccontacts");
  81.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.htcdialer");
  82.             AppKillBlacklistUtil.appKillWhiteList.add("com.htc.messagecs");
  83.             AppKillBlacklistUtil.appKillWhiteList.add("com.htc.idlescreen.shortcut");
  84.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.htcCheckin");
  85.         }
  86.         else if(Build.MANUFACTURER.equalsIgnoreCase("ZTE")) {
  87.             AppKillBlacklistUtil.appKillWhiteList.add("zte.com.cn.alarmclock");
  88.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.utk");
  89.         }
  90.         else if(Build.MANUFACTURER.equalsIgnoreCase("huawei")) {
  91.             AppKillBlacklistUtil.appKillWhiteList.add("com.huawei.widget.localcityweatherclock");
  92.         }
  93.         else if(Build.MANUFACTURER.equalsIgnoreCase("Sony Ericsson")) {
  94.             AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.provider.useragent");
  95.             AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.provider.customization");
  96.             AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.secureclockservice");
  97.             AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.widget.digitalclock");
  98.             AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.digitalclockwidget");
  99.         }
  100.         else if(Build.MANUFACTURER.equalsIgnoreCase("samsung")) {
  101.             AppKillBlacklistUtil.appKillWhiteList.add("com.samsung.inputmethod");
  102.             AppKillBlacklistUtil.appKillWhiteList.add("com.sec.android.app.controlpanel");
  103.             AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.provider.customization");
  104.         }
  105.         else if(Build.MANUFACTURER.equalsIgnoreCase("motorola")) {
  106.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.numberlocation");
  107.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.android.fota");
  108.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.atcmd");
  109.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.locationsensor");
  110.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.blur.conversations");
  111.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.blur.alarmclock");
  112.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.blur.providers.contacts");
  113.         }
  114.         else if(Build.MANUFACTURER.equalsIgnoreCase("LGE")) {
  115.             AppKillBlacklistUtil.appKillWhiteList.add("com.lge.clock");
  116.         }
  117.         else if(Build.MANUFACTURER.equalsIgnoreCase("magnum2x")) {
  118.             AppKillBlacklistUtil.appKillWhiteList.add("ty.com.android.TYProfileSetting");
  119.         }

  121.         if((Build.MODEL.equalsIgnoreCase("HTC Sensation Z710e")) ||
  122.                         (Build.MODEL.equalsIgnoreCase("HTC Sensation G14")) ||
  123.                         (Build.MODEL.equalsIgnoreCase("HTC Z710e"))) {
  124.             AppKillBlacklistUtil.appKillWhiteList.add("android.process.acore");
  125.         }
  126.         else if(Build.MODEL.equalsIgnoreCase("LT18i")) {
  127.             AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.provider.customization");
  128.             AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.provider.useragent");
  129.         }
  130.         else if(Build.MODEL.equalsIgnoreCase("U8500") ||
  131.                         Build.MODEL.equalsIgnoreCase("U8500 HiQQ")){
  132.             AppKillBlacklistUtil.appKillWhiteList.add("android.process.launcherdb");
  133.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.process.system");
  134.             AppKillBlacklistUtil.appKillWhiteList.add("com.nd.assistance.ServerService");
  135.         }
  136.         else if(Build.MODEL.equalsIgnoreCase("MT15I")){
  137.                 AppKillBlacklistUtil.appKillWhiteList.add("com.sonyericsson.eventstream.calllogplugin");
  138.         }       
  139.         else if(Build.MODEL.equalsIgnoreCase("GT-I9100") ||
  140.                         Build.MODEL.equalsIgnoreCase("GT-I9100G")){
  141.             AppKillBlacklistUtil.appKillWhiteList.add("com.samsung.inputmethod");
  142.             AppKillBlacklistUtil.appKillWhiteList.add("com.sec.android.app.controlpanel");
  143.             AppKillBlacklistUtil.appKillWhiteList.add("com.sec.android.app.FileTransferManager");
  144.             AppKillBlacklistUtil.appKillWhiteList.add("com.sec.android.providers.downloads");
  145.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.downloads.ui");
  146.         }
  147.         else if(Build.MODEL.equalsIgnoreCase("DROIDX")) {
  148.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.blur.contacts.data");
  149.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.blur.contacts");
  150.         }
  151.         else if(Build.MODEL.equalsIgnoreCase("DROID2") ||
  152.                         Build.MODEL.equalsIgnoreCase("DROID2 GLOBA")){
  153.                 AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.blur.contacts");
  154.         }
  155.         else if(Build.MODEL.startsWith("U8800")) {
  156.             AppKillBlacklistUtil.appKillWhiteList.add("com.huawei.android.gpms");
  157.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.hwdrm");
  158.             AppKillBlacklistUtil.appKillWhiteList.add("com.huawei.omadownload");
  159.         }
  160.         else if(Build.MODEL.equalsIgnoreCase("LG-P503")) {
  161.             AppKillBlacklistUtil.appKillWhiteList.add("com.lge.simcontacts");
  162.         }
  163.         else if(Build.MODEL.equalsIgnoreCase("XT702")) {
  164.             AppKillBlacklistUtil.appKillWhiteList.add("com.motorola.usb");
  165.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.alarmclock");
  166.         }
  167.         else if(Build.MODEL.equalsIgnoreCase("e15i")) {
  168.             AppKillBlacklistUtil.appKillWhiteList.add("com.sec.ccl.csp.app.secretwallpaper.themetwo");
  169.         }
  170.         else if(Build.MODEL.equalsIgnoreCase("zte-c n600")) {
  171.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.wallpaper");
  172.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.musicvis");
  173.             AppKillBlacklistUtil.appKillWhiteList.add("com.android.magicsmoke");
  174.         }
  175.         else if(Build.MODEL.startsWith("GT-5830") ||
  176.                         Build.MODEL.startsWith("HTC Velocity 4G")){
  177.                 AppKillBlacklistUtil.appKillWhiteList.add("com.android.providers.downloads.ui");
  178.         }
  179.     }

  181.     public AppKillBlacklistUtil() {
  182.         super();
  183.     }

  185.     public static boolean isAppInWhiteList(String packageName) {
  186.         return AppKillBlacklistUtil.appKillWhiteList.contains(packageName);
  187.     }
  188. }
  189. package base.utils;

  191. import android.content.Context;
  192. import android.content.pm.ApplicationInfo;
  193. import android.content.pm.PackageInfo;
  194. import android.content.pm.PackageManager;
  195. import android.content.pm.PackageManager.NameNotFoundException;
  196. import android.graphics.Bitmap;
  197. import android.graphics.Bitmap.CompressFormat;
  198. import android.graphics.Bitmap.Config;
  199. import android.graphics.drawable.Drawable;
  200. import android.text.TextUtils;
  201. import java.io.BufferedInputStream;
  202. import java.io.ByteArrayOutputStream;
  203. import java.io.File;
  204. import java.io.FileInputStream;
  205. import java.io.FileNotFoundException;
  206. import java.io.IOException;
  207. import java.io.InputStream;
  208. import java.io.OutputStream;

  210. public class AppUtils {
  211.     private static final int BUFFER_SIZE = 0x20000;
  212.     private static final int MAX_ICON_SIZE = 300;

  214.     public AppUtils() {
  215.         super();
  216.     }

  218.     private static byte[] bitmapToPNGBytes(Bitmap bitmap) {
  219.         if(bitmap != null) {
  220.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
  221.             bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
  222.             return baos.toByteArray();
  223.         }
  224.         return null;
  225.     }

  227.     public static String convertFirstCharToPinyin(String str, Context context) {
  228.         if(TextUtils.isEmpty(((CharSequence)str))) {
  229.             return null;
  230.         }
  231.         else {
  232.             String tmp = str.trim();
  233.             if(TextUtils.isEmpty(((CharSequence)tmp))) {
  234.                     return null;
  235.             }
  236.             else {
  237.                 if(TextUtil.isChinese(tmp.charAt(0))) {
  238.                     tmp = TextUtil.convert2Pinyin(context, tmp.substring(0, 1)).trim().toUpperCase() + tmp.substring(1);
  239.                 }
  240.                 tmp = tmp.trim().replaceAll("^[\\s ]*|[\\s ]*$", "").toUpperCase();
  241.             }
  242.         }
  243.         return null;
  244.     }

  246.     public static byte[] drawableToBytes(Drawable drawable) {
  247.         byte[] data = null;
  248.         Bitmap bitmap = ImageUtil.drawableToBitmap(drawable, new Bitmap.Config[0]);
  249.         if(bitmap != null) {
  250.             data = AppUtils.bitmapToPNGBytes(bitmap);
  251.         }
  252.         return data;
  253.     }

  255.     public static byte[] getIconBytesFromPkgInfo(ApplicationInfo info, PackageManager manager) {
  256.         byte[] data = null;
  257.         int threshold = 300;
  258.         if(info == null) {
  259.             return null;
  260.         }
  261.         try {
  262.             Drawable drawable = info.loadIcon(manager);
  263.             if(drawable == null) {
  264.                 return null;
  265.             }
  266.             if(drawable.getIntrinsicHeight() > threshold || drawable.getIntrinsicWidth() > threshold) {
  267.                 return null;
  268.             }
  269.             data = AppUtils.drawableToBytes(drawable);
  270.         }
  271.         catch(OutOfMemoryError v1) {
  272.         }
  273.         return data;
  274.     }

  276.     public static PackageInfo getPackageInfo(Context context, String info, int flag) {
  277.         try {
  278.             return context.getPackageManager().getPackageInfo(info, flag);
  279.         }
  280.         catch(RuntimeException v1_1) {
  281.         }
  282.         catch(PackageManager.NameNotFoundException v1_2) {
  283.         }
  284.         return null;
  285.     }

  287.     public static boolean isAppInstalled(Context context, String packageName) {
  288.         try {
  289.             if(context.getPackageManager().getPackageInfo(packageName, 0) != null) {
  290.                 return true;
  291.             }
  292.         }
  293.         catch(PackageManager.NameNotFoundException v1) {
  294.         }
  295.         return false;
  296.     }
  297. }
  298. package base.utils;

  300. import java.lang.reflect.Array;
  301. import java.util.ArrayList;
  302. import java.util.List;

  304. public class ArrayUtil {
  305.     public ArrayUtil() {
  306.         super();
  307.     }

  309.     public static Object[] combineArray(Object[] arr1, Object[] arr2) {
  310.         Object[] newarr = copyOfRange(arr1, 0, arr1.length + arr2.length);
  311.         System.arraycopy(arr2, 0, newarr, arr1.length, arr2.length);
  312.         return newarr;
  313.     }

  315.     public static Object[] copyOfRange(Object[] src, int srcbegin, int dstlen) {
  316.         int srcend = src.length;
  317.         if(srcbegin > dstlen) {
  318.             throw new IllegalArgumentException();
  319.         }

  321.         if(srcbegin >= 0 && srcbegin <= srcend) {
  322.             int dstsize = dstlen - srcbegin;
  323.             int copylen = Math.min(dstsize, srcend - srcbegin);
  324.             Object[] dst = (Object[]) Array.newInstance(src.getClass().getComponentType(), dstsize);
  325.             System.arraycopy(src, srcbegin, dst, 0, copylen);
  326.             return ((Object[])dst);
  327.         }

  329.         throw new ArrayIndexOutOfBoundsException();
  330.     }

  332.     public static Object[] insert(Object[] objArr, int insertPos, Object newone) {
  333.         Object[] dst = (Object[]) Array.newInstance(objArr.getClass().getComponentType(), objArr.length + 1);
  334.         for(int i = 0; i < dst.length; ++i) {
  335.             if(i < insertPos) {
  336.                 dst[i] = objArr[i];
  337.             }
  338.             else if(i == insertPos) {
  339.                 dst[i] = newone;
  340.             }
  341.             else {
  342.                 dst[i] = objArr[i - 1];
  343.             }
  344.         }
  345.         return dst;
  346.     }
  347. }

  349. package base.utils;

  351. import android.content.BroadcastReceiver;
  352. import android.content.Context;
  353. import android.content.Intent;

  355. public class BatteryUtils extends BroadcastReceiver {
  356.     private int current;
  357.     private static BatteryUtils instance;
  358.     private boolean isCharging;
  359.     private int total;

  361.     static  {
  362.         BatteryUtils.instance = null;
  363.     }

  365.     private BatteryUtils() {
  366.         super();
  367.         this.current = 100;
  368.         this.total = 100;
  369.         this.isCharging = false;
  370.     }

  372.     public static BatteryUtils getInstance() {
  373.         if(BatteryUtils.instance == null) {
  374.             BatteryUtils.instance = new BatteryUtils();
  375.         }

  377.         return BatteryUtils.instance;
  378.     }

  380.     public void onReceive(Context context, Intent intent) {
  381.         int isplugged;
  382.         if(intent.getAction().equals(Intent.ACTION_BATTERY_CHANGED)) {
  383.             this.current = intent.getExtras().getInt("level");
  384.             this.total = intent.getExtras().getInt("scale");
  385.             if(intent.getExtras().getInt("plugged", 0) != 0) {
  386.                 isplugged = 1;
  387.             }
  388.             else {
  389.                 isplugged = 0;
  390.             }

  392.             if((this.isCharging) && isplugged == 0) {
  393.                 this.isCharging = false;
  394.                 return;
  395.             }

  397.             if(this.isCharging) {
  398.                 return;
  399.             }

  401.             if(isplugged == 0) {
  402.                 return;
  403.             }

  405.             this.isCharging = true;
  406.         }
  407.     }
  408. }

  410. package base.utils;

  412. import android.content.ClipData;
  413. import android.content.ClipboardManager;
  414. import android.content.Context;

  416. public class ClipboardUtil {
  417.     public ClipboardUtil() {
  418.         super();
  419.     }

  421.     public static void copyText(String text, Context context) {
  422.         if(SystemUtil.aboveApiLevel(11)) {
  423.                 if(context == null)
  424.                         return;
  425.                 ClipboardManager manager = (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
  426.             if(manager != null)
  427.                 manager.setPrimaryClip(ClipData.newPlainText("phoenix", text));
  428.         }
  429.         else {
  430.             ClipboardManager manager = (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
  431.             if(manager != null)
  432.                 manager.setText(text);
  433.         }
  434.     }
  435. }

  437. package base.utils;

  439. import java.util.ArrayList;
  440. import java.util.Collection;
  441. import java.util.Collections;
  442. import java.util.List;

  444. public class CollectionUtils {
  445.     public CollectionUtils() {
  446.         super();
  447.     }

  449.     /*
  450.      * 将src2插入src1的index位置
  451.      */
  452.     public static List<Collection> appendFromPosition(List<Collection> src1, List<Collection> src2, int index) {
  453.         ArrayList<Collection> out = new ArrayList<Collection>();
  454.         if(src1 == null || src1.isEmpty()) {
  455.             if(src2 == null || src2.isEmpty())
  456.                 return out;
  457.             out.addAll(src2);
  458.         }
  459.         else if(src2 == null || src2.isEmpty()) {
  460.         }
  461.         else {
  462.             if(index > src1.size())
  463.                 index = src1.size();
  464.             out = new ArrayList<Collection>(src1);
  465.             out.addAll(index, src2);
  466.         }
  467.         return out;
  468.     }

  470.     public static ArrayList copyFrom(List<Collection> src) {
  471.         if(src == null) {
  472.             return null;
  473.         }
  474.         else {
  475.             return new ArrayList(src);
  476.         }
  477.     }

  479.     public static boolean isEmpty(Collection src) {
  480.         if(src == null || (src.isEmpty())) {
  481.             return true;
  482.         }
  483.         else {
  484.             return false;
  485.         }
  486.     }

  488.     public static List<Collection> notNull(List<Collection> src) {
  489.         if(src == null) {
  490.             src = Collections.emptyList();
  491.         }
  492.         return src;
  493.     }

  495.     public static List<Collection> replaceFromPosition(List<Collection> src1, List<Collection> src2, int index) {
  496.         ArrayList<Collection> out = new ArrayList<Collection>();
  497.         if(src1 == null || src1.isEmpty()) {
  498.             return out;
  499.         }
  500.         else if(src2 == null || src2.isEmpty()) {
  501.         }
  502.         else{
  503.             if(index > src1.size()) {
  504.                 index = src1.size();
  505.             }
  506.             out = new ArrayList<Collection>(src1);
  507.             out.addAll(index, src2);
  508.             while(out.size() > src2.size() + index) {
  509.                 out.remove(out.size() - 1);
  510.             }
  511.         }
  512.         return out;
  513.     }
  514. }



复制代码


回复

使用道具 举报

元始天尊
 楼主| 发表于 2016-3-20 18:16:36 | 显示全部楼层
不保证正确性，拿去耍吧 base.rar (50.14 KB, 下载次数: 0)
回复 赞！ 靠！

使用道具 举报

返回列表 发新帖

本版积分规则

QQ|Archiver|小黑屋|技术宅的结界 ( 滇ICP备16008837号 )|网站地图

GMT+8, 2024-12-22 21:34 , Processed in 0.040156 second(s), 24 queries , Gzip On.

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表