see 03/26 log

Author: Blankj

buildSrc/src/main/groovy/Config.groovy

@@ -53,10 +53,10 @@ class Config {
             // 本地第一次上传插件新的版本需设置 isApply = false, useLocal = true
             // 本地上传成功之后 isApply = true 即可应用插件来调试，后续版本更新无需设置 isApply = false
             // 发布版本的话把 isApply = false, useLocal = false，更新版本号，发布成功后 isApply = true 即可使用远程库版本
-            plugin_api                 : new DepConfig(isApply: false, useLocal: true, pluginPath: "com.blankj:api-gradle-plugin:1.4-r1", pluginId: "com.blankj.api"),
+            plugin_api                 : new DepConfig(isApply: true, useLocal: false, pluginPath: "com.blankj:api-gradle-plugin:1.2", pluginId: "com.blankj.api"),
             //./gradlew plugin:api-gradle-plugin:uploadArchives // 上传到本地 maven
             //./gradlew plugin:api-gradle-plugin:bintrayUpload  // 上传到 jcenter
-            plugin_bus                 : new DepConfig(isApply: true, useLocal: false, pluginPath: "com.blankj:bus-gradle-plugin:2.6-r2", pluginId: "com.blankj.bus"),
+            plugin_bus                 : new DepConfig(isApply: true, useLocal: false, pluginPath: "com.blankj:bus-gradle-plugin:2.4", pluginId: "com.blankj.bus"),
             //./gradlew plugin:bus-gradle-plugin:uploadArchives // 上传到本地 maven
             //./gradlew plugin:bus-gradle-plugin:bintrayUpload  // 上传到 jcenter
 

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.0-all.zip

lib/utilcode/src/main/java/com/blankj/utilcode/util/ApiUtils.java

@@ -1,10 +1,8 @@
 package com.blankj.utilcode.util;
 
 import android.support.annotation.NonNull;
-import android.text.TextUtils;
 import android.util.Log;
 
-import java.io.IOException;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -25,12 +23,21 @@ public final class ApiUtils {
 
     private static final String TAG = "ApiUtils";
 
-    private static final String PREFIX = "blankj.api/";
-
-    private Map<Class, Object> apiClass_apiInstance_map  = new ConcurrentHashMap<>();
-    private Map<Class, Class>  apiClass_apiImplClass_map = new HashMap<>();
+    private Map<Class, BaseApi> mApiMap           = new ConcurrentHashMap<>();
+    private Map<Class, Class>   mInjectApiImplMap = new HashMap<>();
 
     private ApiUtils() {
+        init();
+    }
+
+    /**
+     * It'll be injected the implClasses who have {@link ApiUtils.Api} annotation
+     * by function of {@link ApiUtils#registerImpl} when execute transform task.
+     */
+    private void init() {/*inject*/}
+
+    private void registerImpl(Class implClass) {
+        mInjectApiImplMap.put(implClass.getSuperclass(), implClass);
     }
 
     /**
@@ -44,132 +51,47 @@ public static <T extends BaseApi> T getApi(@NonNull final Class<T> apiClass) {
         return getInstance().getApiInner(apiClass);
     }
 
+    public static void register(Class<? extends BaseApi> implClass) {
+        getInstance().registerImpl(implClass);
+    }
+
     public static String toString_() {
         return getInstance().toString();
     }
 
     @Override
     public String toString() {
-        getAllApis();
-        StringBuilder sb = new StringBuilder();
-        sb.append("ApiUtils {");
-        for (Map.Entry<Class, Class> entry : apiClass_apiImplClass_map.entrySet()) {
-            sb.append("\n    ")
-                    .append(entry.getKey().getName())
-                    .append(": ")
-                    .append(entry.getValue().getName());
-        }
-        sb.append("\n}");
-        return sb.toString();
+        return "ApiUtils: " + mInjectApiImplMap;
     }
 
     private static ApiUtils getInstance() {
         return LazyHolder.INSTANCE;
     }
 
     private <Result> Result getApiInner(Class apiClass) {
-        Object apiInstance = apiClass_apiInstance_map.get(apiClass);
-        if (apiInstance == null) {
-            synchronized (this) {
-                apiInstance = apiClass_apiInstance_map.get(apiClass);
-                if (apiInstance == null) {
-                    Class implClass = getApiImplClass(apiClass);
-                    if (implClass != null) {
-                        try {
-                            apiInstance = implClass.newInstance();
-                            apiClass_apiInstance_map.put(apiClass, apiInstance);
-                        } catch (Exception ignore) {
-                            Log.e(TAG, "The api of <" + implClass + "> has no parameterless constructor.");
-                            return null;
-                        }
-                    } else {
-                        Log.e(TAG, "The api of <" + apiClass + "> doesn't implement.");
-                        return null;
-                    }
-                }
-            }
+        BaseApi api = mApiMap.get(apiClass);
+        if (api != null) {
+            return (Result) api;
         }
-        //noinspection unchecked
-        return (Result) apiInstance;
-    }
-
-    private Class getApiImplClass(Class apiClass) {
-        Class apiImplClass = apiClass_apiImplClass_map.get(apiClass);
-        if (apiImplClass != null) return apiImplClass;
-        try {
-            String[] apiImpls = Utils.getApp().getAssets().list(PREFIX + apiClass.getName());
-            if (apiImpls == null) {
-                return null;
-            }
-            if (apiImpls.length != 1) {
-                Log.e(TAG, "The api of <" + apiClass + "> has more than one implement.");
-                return null;
-            }
-            String apiImpl = apiImpls[0];
-            if (TextUtils.isEmpty(apiImpl)) {
-                Log.e(TAG, "The api of <" + apiClass + ">'s name is empty.");
-                return null;
+        synchronized (this) {
+            api = mApiMap.get(apiClass);
+            if (api != null) {
+                return (Result) api;
             }
-            String[] apiImpl_isMock = apiImpl.split("-");
-            if (apiImpl_isMock.length != 2) {
-                Log.e(TAG, "The api of <" + apiClass + ">'s implement <" + apiImpl
-                        + "> which format of name is wrong.");
-                return null;
-            }
-            String className = apiImpl_isMock[0];
-            boolean isMock = Boolean.parseBoolean(apiImpl_isMock[1]);
-            if (TextUtils.isEmpty(className)) {
-                return null;
-            }
-            apiImplClass = Class.forName(className);
-            return registerApiInner(apiClass, apiImplClass);
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    private Class registerApiInner(Class apiClass, Class apiImplClass) {
-        if (apiImplClass == null) return null;
-        if (apiClass == null) {
-            Class superclass = apiImplClass.getSuperclass();
-            if (superclass == null) {
-                Log.e(TAG, "<" + apiImplClass.getName() + ">'s superClass is null");
-                return null;
-            }
-            apiClass = superclass;
-        }
-        //noinspection unchecked
-        if (apiClass.isAssignableFrom(apiImplClass)) {
-            apiClass_apiImplClass_map.put(apiClass, apiImplClass);
-            return apiImplClass;
-        } else {
-            Log.e(TAG, "<" + apiImplClass.getName() + ">'s superClass is <"
-                    + apiClass.getName() + ">, not <" + apiClass.getName() + ">");
-            return null;
-        }
-
-    }
-
-    static void registerApi(Class<? extends BaseApi> implClass) {
-        getInstance().registerApiInner(null, implClass);
-    }
-
-    private void getAllApis() {
-        try {
-            String[] apis = Utils.getApp().getAssets().list(PREFIX);
-            if (apis == null) return;
-            for (String api : apis) {
+            Class implClass = mInjectApiImplMap.get(apiClass);
+            if (implClass != null) {
                 try {
-                    getApiImplClass(Class.forName(api));
-                } catch (ClassNotFoundException e) {
-                    e.printStackTrace();
+                    api = (BaseApi) implClass.newInstance();
+                    mApiMap.put(apiClass, api);
+                    return (Result) api;
+                } catch (Exception ignore) {
+                    Log.e(TAG, "The <" + implClass + "> has no parameterless constructor.");
+                    return null;
                 }
+            } else {
+                Log.e(TAG, "The <" + apiClass + "> doesn't implement.");
+                return null;
             }
-        } catch (IOException e) {
-            e.printStackTrace();
         }
     }
 
@@ -183,6 +105,6 @@ private static class LazyHolder {
         boolean isMock() default false;
     }
 
-    public abstract static class BaseApi {
+    public static class BaseApi {
     }
 }

lib/utilcode/src/main/java/com/blankj/utilcode/util/BusUtils.java

@@ -2,16 +2,13 @@
 
 import android.util.Log;
 
-import java.io.IOException;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -31,9 +28,8 @@
  */
 public final class BusUtils {
 
-    private static final Object NULL   = "nULl";
-    private static final String TAG    = "BusUtils";
-    private static final String PREFIX = "blankj.bus/";
+    private static final Object NULL = "nULl";
+    private static final String TAG  = "BusUtils";
 
     private final Map<String, List<BusInfo>> mTag_BusInfoListMap = new HashMap<>();
 
@@ -42,65 +38,24 @@ public final class BusUtils {
     private final Map<String, Map<String, Object>> mClassName_Tag_Arg4StickyMap = new ConcurrentHashMap<>();
 
     private BusUtils() {
-        try {
-            String[] tags = Utils.getApp().getAssets().list(PREFIX);
-            if (tags == null || tags.length == 0) {
-                Log.w(TAG, "no bus");
-                return;
-            }
-            for (String tag : tags) {
-                String[] busInfos = Utils.getApp().getAssets().list(PREFIX + tag);
-                if (busInfos == null || busInfos.length == 0) {
-                    Log.w(TAG, "The tag of <" + tag + "> no bus.");
-                    continue;
-                }
-                for (String busInfo : busInfos) {
-                    parseBusInfo(tag, busInfo);
-                }
-                sortBusByPriority(tag);
-            }
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
+        init();
     }
 
-    private void parseBusInfo(String tag, String busInfo) {
-        String[] split = busInfo.split("-");
-        if (split.length != 7) {
-            Log.e(TAG, "The tag of <" + tag + ">'s bus <" + busInfo + "> which format is wrong.");
-            return;
-        }
-        String className = split[0];
-        String funName = split[1];
-        String paramType = split[2];
-        String paramName = split[3];
-        boolean sticky = Boolean.parseBoolean(split[4]);
-        String threadMode = split[5];
-        int priority;
-        try {
-            priority = Integer.parseInt(split[6]);
-        } catch (NumberFormatException e) {
-            Log.e(TAG, "The tag of <" + tag + ">'s bus <" + busInfo + "> which format is wrong.");
-            return;
-        }
-        registerBusInner(tag, className, funName, paramType, paramName, sticky, threadMode, priority);
-    }
+    /**
+     * It'll be injected the bus who have {@link Bus} annotation
+     * by function of {@link BusUtils#registerBus} when execute transform task.
+     */
+    private void init() {/*inject*/}
 
-    private void sortBusByPriority(String tag) {
-        List<BusInfo> busInfoList = mTag_BusInfoListMap.get(tag);
-        if (busInfoList != null && busInfoList.size() > 1) {
-            Collections.sort(busInfoList, new Comparator<BusInfo>() {
-                @Override
-                public int compare(BusInfo o0, BusInfo o1) {
-                    return o1.priority - o0.priority;
-                }
-            });
-        }
+    private void registerBus(String tag,
+                             String className, String funName, String paramType, String paramName,
+                             boolean sticky, String threadMode) {
+        registerBus(tag, className, funName, paramType, paramName, sticky, threadMode, 0);
     }
 
-    private void registerBusInner(String tag,
-                                  String className, String funName, String paramType, String paramName,
-                                  boolean sticky, String threadMode, int priority) {
+    private void registerBus(String tag,
+                             String className, String funName, String paramType, String paramName,
+                             boolean sticky, String threadMode, int priority) {
         List<BusInfo> busInfoList = mTag_BusInfoListMap.get(tag);
         if (busInfoList == null) {
             busInfoList = new ArrayList<>();
@@ -109,12 +64,6 @@ private void registerBusInner(String tag,
         busInfoList.add(new BusInfo(className, funName, paramType, paramName, sticky, threadMode, priority));
     }
 
-    public static void registerBus(String tag,
-                                   String className, String funName, String paramType, String paramName,
-                                   boolean sticky, String threadMode, int priority) {
-        getInstance().registerBusInner(tag, className, funName, paramType, paramName, sticky, threadMode, priority);
-    }
-
     public static void register(final Object bus) {
         getInstance().registerInner(bus);
     }
@@ -152,20 +101,6 @@ public String toString() {
         return "BusUtils: " + mTag_BusInfoListMap;
     }
 
-    static Runnable getPreLoadRunnable() {
-        return new Runnable() {
-            @Override
-            public void run() {
-                preLoad();
-            }
-        };
-    }
-
-    private static void preLoad() {
-        //noinspection ResultOfMethodCallIgnored
-        getInstance();
-    }
-
     private static BusUtils getInstance() {
         return LazyHolder.INSTANCE;
     }
@@ -244,9 +179,6 @@ private void postInner(final String tag, final Object arg, final boolean sticky)
             if (busInfo.method == null) {
                 Method method = getMethodByBusInfo(busInfo);
                 if (method == null) {
-                    Log.e(TAG, "The bus of tag <" + tag + ">'s method <" + busInfo.funName +
-                            ("".equals(busInfo.paramType) ? "()" : ("(" + busInfo.paramType + " " + busInfo.paramName + ")"))
-                            + "> is not exists.");
                     return;
                 }
                 busInfo.method = method;
@@ -302,7 +234,7 @@ public void run() {
         };
         switch (busInfo.threadMode) {
             case "MAIN":
-                UtilsBridge.runOnUiThread(runnable);
+                ThreadUtils.runOnUiThread(runnable);
                 return;
             case "IO":
                 ThreadUtils.getIoPool().execute(runnable);
@@ -399,6 +331,12 @@ private void removeStickyInner(final String tag) {
         }
     }
 
+    static void registerBus4Test(String tag,
+                                 String className, String funName, String paramType, String paramName,
+                                 boolean sticky, String threadMode, int priority) {
+        getInstance().registerBus(tag, className, funName, paramType, paramName, sticky, threadMode, priority);
+    }
+
     private static final class BusInfo {
 
         String       className;