@quicktvui/ai 1.0.7 → 1.0.9

package/rules/.source/sdk/base/sdk-base/src/main/java/com/quicktvui/sdk/base/PromiseHolder.java

@@ -0,0 +1,66 @@
+package com.quicktvui.sdk.base;
+
+import com.quicktvui.sdk.base.args.EsMap;
+
+/**
+ * Create by weipeng on 2021/12/28 11:32
+ */
+public class PromiseHolder {
+
+    private final EsMap data = new EsMap();
+    private EsPromise promise;
+
+    public PromiseHolder() {
+    }
+
+    public PromiseHolder(EsPromise promise) {
+        this.promise = promise;
+    }
+
+    public static PromiseHolder create(EsPromise promise){
+        return new PromiseHolder(promise);
+    }
+
+    public static PromiseHolder create(){
+        return new PromiseHolder();
+    }
+
+    public PromiseHolder put(EsMap v){
+        data.pushAll(v);
+        return this;
+    }
+
+    public PromiseHolder put(String k, Object v){
+        try {
+            data.pushObject(k,v);
+        } catch (Exception e) {
+           data.pushObject(k, e.getMessage());
+        }
+        return this;
+    }
+
+    public PromiseHolder singleData(Object v) {
+        put("data", v);
+        return this;
+    }
+
+    public PromiseHolder message(Object v){
+        put("msg", v);
+        return this;
+    }
+
+    public EsMap getData(){
+        return data;
+    }
+
+    public void sendSuccess() {
+        if(promise == null) return;
+        promise.resolve(data);
+    }
+
+    public void sendFailed() {
+        if(promise == null) return;
+        promise.reject(data);
+    }
+
+}

package/rules/.source/sdk/base/sdk-base/src/main/java/com/quicktvui/sdk/base/args/EsArray.java

@@ -0,0 +1,215 @@
+package com.quicktvui.sdk.base.args;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * Create by weipeng on 2022/03/03 15:34
+ */
+public class EsArray implements Serializable {
+    
+    private final ArrayList<Object> mDatas;
+
+    public EsArray() {
+        mDatas = new ArrayList<>();
+    }
+
+    public int size() {
+        return mDatas.size();
+    }
+
+    public Object get(int index) {
+        return mDatas.get(index);
+    }
+
+    public void pushObject(Object obj) {
+        mDatas.add(obj);
+    }
+
+    public void setObject(int index, Object obj) {
+        mDatas.set(index, obj);
+    }
+
+    public int getInt(int index) {
+        if (mDatas.size() > index) {
+            Object value = mDatas.get(index);
+            return value instanceof Number ? ((Number) value).intValue() : 0;
+        }
+        return 0;
+    }
+
+    public long getLong(int index) {
+        if (mDatas.size() > index) {
+            Object value = mDatas.get(index);
+            return value instanceof Number ? ((Number) value).longValue() : 0;
+        }
+        return 0;
+    }
+
+    public double getDouble(int index) {
+        if (mDatas.size() > index) {
+            Object value = mDatas.get(index);
+            return value instanceof Number ? ((Number) value).doubleValue() : 0;
+        }
+        return 0;
+    }
+
+    public String getString(int index) {
+        if (mDatas.size() > index) {
+            return String.valueOf(mDatas.get(index));
+        }
+        return null;
+    }
+
+    public boolean getBoolean(int index) {
+        if (mDatas.size() > index) {
+            Object value = mDatas.get(index);
+            return (value instanceof Boolean) && (boolean) value;
+        }
+        return false;
+    }
+
+    public EsArray getArray(int index) {
+        if (mDatas.size() > index) {
+            Object value = mDatas.get(index);
+            return value instanceof EsArray ? (EsArray) value : null;
+        }
+        return null;
+    }
+
+    public EsMap getMap(int index) {
+        if (mDatas.size() > index) {
+            Object value = mDatas.get(index);
+            return value instanceof EsMap ? (EsMap) value : null;
+        }
+        return null;
+    }
+
+    public Object getObject(int index) {
+        if (mDatas.size() > index) {
+            return mDatas.get(index);
+        }
+        return null;
+    }
+
+    public void pushInt(int value) {
+        mDatas.add(value);
+    }
+
+    public void pushLong(long value) {
+        mDatas.add(value);
+    }
+
+    public void pushDouble(double value) {
+        mDatas.add(value);
+    }
+
+    public void pushBoolean(boolean value) {
+        mDatas.add(value);
+    }
+
+    public void pushString(String value) {
+        mDatas.add(value);
+    }
+
+    public void pushArray(EsArray array) {
+        mDatas.add(array);
+    }
+
+    public void pushMap(EsMap map) {
+        mDatas.add(map);
+    }
+
+    public void pushNull() {
+        mDatas.add(null);
+    }
+
+    @SuppressWarnings("unused")
+    public void clear() {
+        mDatas.clear();
+    }
+
+    public EsArray copy() {
+        EsArray newArray = new EsArray();
+        Iterator<Object> it = mDatas.iterator();
+        Object value;
+        Object newValue;
+        while (it.hasNext()) {
+            value = it.next();
+            if (value instanceof EsMap) {
+                newValue = ((EsMap) value).copy();
+            } else if (value instanceof EsArray) {
+                newValue = ((EsArray) value).copy();
+            } else {
+                newValue = value;
+            }
+            newArray.pushObject(newValue);
+        }
+
+        return newArray;
+    }
+
+    @Override
+    public String toString() {
+        return mDatas.toString();
+    }
+
+    public void pushJSONArray(JSONArray jArray) {
+        if (jArray == null || jArray.length() <= 0) {
+            return;
+        }
+
+        try {
+            for (int i = 0; i < jArray.length(); i++) {
+                Object obj = jArray.opt(i);
+                if (obj == null) {
+                    pushNull();
+                } else if (obj instanceof JSONObject) {
+                    EsMap EsMap = new EsMap();
+                    EsMap.pushJSONObject((JSONObject) obj);
+                    pushMap(EsMap);
+                } else if (obj instanceof JSONArray) {
+                    EsArray EsArray = new EsArray();
+                    EsArray.pushJSONArray((JSONArray) obj);
+                    pushArray(EsArray);
+                } else {
+                    pushObject(obj);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public JSONArray toJSONArray() {
+        JSONArray jArray = new JSONArray();
+        if (size() <= 0) {
+            return jArray;
+        }
+
+        try {
+            Iterator<Object> it = mDatas.iterator();
+            Object value;
+            while (it.hasNext()) {
+                value = it.next();
+                if (value instanceof EsMap) {
+                    JSONObject jObjectMap = ((EsMap) value).toJSONObject();
+                    jArray.put(jObjectMap);
+                } else if (value instanceof EsArray) {
+                    JSONArray jObjectArray = ((EsArray) value).toJSONArray();
+                    jArray.put(jObjectArray);
+                } else {
+                    jArray.put(value);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return jArray;
+    }
+}

package/rules/.source/sdk/base/sdk-base/src/main/java/com/quicktvui/sdk/base/args/EsMap.java

@@ -0,0 +1,287 @@
+package com.quicktvui.sdk.base.args;
+
+/**
+ * Create by weipeng on 2022/03/03 15:32
+ */
+
+import android.os.Bundle;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+public class EsMap implements Serializable {
+
+    private final HashMap<String, Object> mDatas;
+
+    @Override
+    public String toString() {
+        return mDatas.toString();
+    }
+
+    public EsMap() {
+        mDatas = new HashMap<>(5);
+    }
+
+    public boolean containsKey(String key) {
+        return mDatas.containsKey(key);
+    }
+
+    public int size() {
+        return mDatas.size();
+    }
+
+    public Set<String> keySet() {
+        return mDatas.keySet();
+    }
+
+    public Set<Map.Entry<String, Object>> entrySet() {
+        return mDatas.entrySet();
+    }
+
+    public Object get(String key) {
+        return mDatas.get(key);
+    }
+
+    public String getString(String key) {
+        Object value = mDatas.get(key);
+        return value == null ? null : String.valueOf(value);
+    }
+
+    public void remove(String key) {
+        mDatas.remove(key);
+    }
+
+    public double getDouble(String key) {
+        Object value = mDatas.get(key);
+        return value instanceof Number ? ((Number) value).doubleValue() : 0;
+    }
+
+    public float getFloat(String key) {
+        Object value = mDatas.get(key);
+        return value instanceof Number ? ((Number) value).floatValue() : 0;
+    }
+
+    public int getInt(String key) {
+        Object value = mDatas.get(key);
+        return value instanceof Number ? ((Number) value).intValue() : 0;
+    }
+
+    public boolean getBoolean(String key) {
+        Object value = mDatas.get(key);
+        return value != null && (boolean) value;
+    }
+
+    public long getLong(String key) {
+        Object value = mDatas.get(key);
+        return value instanceof Number ? ((Number) value).longValue() : 0;
+    }
+
+    public EsMap getMap(String key) {
+        Object value = mDatas.get(key);
+        if (value instanceof EsMap) {
+            return (EsMap) value;
+        }
+        return null;
+    }
+
+    public EsArray getArray(String key) {
+        Object value = mDatas.get(key);
+        if (value instanceof EsArray) {
+            return (EsArray) value;
+        }
+        return null;
+    }
+
+    public boolean isNull(String key) {
+        return mDatas.get(key) == null;
+    }
+
+    public void pushNull(String key) {
+        mDatas.put(key, null);
+    }
+
+    public void pushInt(String key, int value) {
+        mDatas.put(key, value);
+    }
+
+    public void pushString(String key, String value) {
+        mDatas.put(key, value);
+    }
+
+    public void pushBoolean(String key, boolean value) {
+        mDatas.put(key, value);
+    }
+
+    public void pushDouble(String key, double value) {
+        mDatas.put(key, value);
+    }
+
+    public void pushLong(String key, long value) {
+        mDatas.put(key, value);
+    }
+
+    public void pushArray(String key, EsArray array) {
+        mDatas.put(key, array);
+    }
+
+    public void pushMap(String key, EsMap map) {
+        if (map == null) map = new EsMap();
+        mDatas.put(key, map);
+    }
+
+    public void pushAll(EsMap map) {
+        if (null != map) {
+            mDatas.putAll(map.mDatas);
+        }
+    }
+
+    public void pushObject(String key, Object obj) {
+        if (obj == null) {
+            pushNull(key);
+        } else if (obj instanceof String) {
+            pushString(key, (String) obj);
+        } else if (obj instanceof EsMap) {
+            pushMap(key, (EsMap) obj);
+        } else if (obj instanceof EsArray) {
+            pushArray(key, (EsArray) obj);
+        } else if (obj instanceof Integer) {
+            pushInt(key, (Integer) obj);
+        } else if (obj instanceof Boolean) {
+            pushBoolean(key, (Boolean) obj);
+        } else if (obj instanceof Double) {
+            pushDouble(key, (Double) obj);
+        } else if (obj instanceof Float) {
+            pushDouble(key, ((Number) obj).doubleValue());
+        } else if (obj instanceof Long) {
+            pushLong(key, (Long) obj);
+        } else if (obj instanceof Byte) {
+            int iObj = ((Byte) obj).intValue();
+            pushInt(key, iObj);
+        } else {
+            Class<?> clazz = obj.getClass();
+            if (clazz.isAssignableFrom(int.class)) {
+                //noinspection ConstantConditions
+                pushInt(key, (Integer) obj);
+            } else if (clazz.isAssignableFrom(boolean.class)) {
+                //noinspection ConstantConditions
+                pushBoolean(key, (Boolean) obj);
+            } else if (clazz.isAssignableFrom(double.class)) {
+                //noinspection ConstantConditions
+                pushDouble(key, (Double) obj);
+            } else if (clazz.isAssignableFrom(float.class)) {
+                pushDouble(key, ((Number) obj).doubleValue());
+            } else if (clazz.isAssignableFrom(long.class)) {
+                //noinspection ConstantConditions
+                pushLong(key, (Long) obj);
+            } else {
+                throw new RuntimeException("push unsupported object into EsMap [" + key + "," + obj + "] " + obj.getClass());
+            }
+        }
+    }
+
+    public void clear() {
+        mDatas.clear();
+    }
+
+    public EsMap copy() {
+        EsMap newMap = new EsMap();
+        Iterator<Map.Entry<String, Object>> it = mDatas.entrySet().iterator();
+        Map.Entry<String, Object> entry;
+        Object value;
+        Object newValue;
+        while (it.hasNext()) {
+            entry = it.next();
+            value = entry.getValue();
+
+            if (value instanceof EsMap) {
+                newValue = ((EsMap) value).copy();
+            } else if (value instanceof EsArray) {
+                newValue = ((EsArray) value).copy();
+            } else {
+                newValue = value;
+            }
+            newMap.pushObject(entry.getKey(), newValue);
+        }
+
+        return newMap;
+    }
+
+    public void pushJSONObject(JSONObject jObject) {
+        if (jObject == null) {
+            return;
+        }
+
+        try {
+            Iterator<?> it = jObject.keys();
+            while (it.hasNext()) {
+                String key = it.next().toString();
+                Object obj = jObject.opt(key);
+                if (jObject.isNull(key)) {
+                    pushNull(key);
+                } else if (obj instanceof JSONObject) {
+                    EsMap hippyMap = new EsMap();
+                    hippyMap.pushJSONObject((JSONObject) obj);
+                    pushMap(key, hippyMap);
+                } else if (obj instanceof JSONArray) {
+                    EsArray EsArray = new EsArray();
+                    EsArray.pushJSONArray((JSONArray) obj);
+                    pushArray(key, EsArray);
+                } else {
+                    pushObject(key, obj);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void pushBundle(Bundle bundle) {
+        if (bundle == null) return;
+        Set<String> keys = bundle.keySet();
+        for (String key : keys) {
+            Object obj = bundle.get(key);
+            if (obj instanceof Bundle) {
+                EsMap map = new EsMap();
+                map.pushBundle((Bundle) obj);
+                pushMap(key, map);
+            } else {
+                pushObject(key, obj);
+            }
+        }
+    }
+
+    public JSONObject toJSONObject() {
+        JSONObject jObject = new JSONObject();
+        if (size() <= 0) {
+            return jObject;
+        }
+
+        Iterator<?> var2 = entrySet().iterator();
+        try {
+            while (var2.hasNext()) {
+                @SuppressWarnings({"unchecked",
+                        "rawtypes"}) Map.Entry<String, Object> entry = (Map.Entry) var2.next();
+                String key = entry.getKey();
+                if (entry.getValue() instanceof EsMap) {
+                    JSONObject jObjectMap = ((EsMap) entry.getValue()).toJSONObject();
+                    jObject.put(key, jObjectMap);
+                } else if (entry.getValue() instanceof EsArray) {
+                    JSONArray jObjectArray = ((EsArray) entry.getValue()).toJSONArray();
+                    jObject.put(key, jObjectArray);
+                } else {
+                    jObject.put(key, entry.getValue());
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return jObject;
+    }
+}

package/rules/.source/sdk/base/sdk-base/src/main/java/com/quicktvui/sdk/base/component/EsComponent.java

@@ -0,0 +1,14 @@
+package com.quicktvui.sdk.base.component;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Create by weipeng on 2022/04/11 19:57
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.SOURCE)
+public @interface EsComponent {
+}

package/rules/.source/sdk/base/sdk-base/src/main/java/com/quicktvui/sdk/base/component/EsComponentAttribute.java

@@ -0,0 +1,15 @@
+package com.quicktvui.sdk.base.component;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Create by weipeng on 2022/04/11 19:57
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface EsComponentAttribute {
+    int index() default 100;
+}

package/rules/.source/sdk/base/sdk-base/src/main/java/com/quicktvui/sdk/base/component/IEsComponent.java

@@ -0,0 +1,21 @@
+package com.quicktvui.sdk.base.component;
+
+import android.content.Context;
+import android.view.View;
+
+import com.quicktvui.sdk.base.EsPromise;
+import com.quicktvui.sdk.base.IEsTraceable;
+import com.quicktvui.sdk.base.args.EsArray;
+import com.quicktvui.sdk.base.args.EsMap;
+
+/**
+ * Create by weipeng on 2022/02/24 17:48
+ */
+public interface IEsComponent<V extends View & IEsComponentView> extends IEsTraceable {
+
+    V createView(Context context, EsMap params);
+
+    void dispatchFunction(V view, String eventName, EsArray params, EsPromise promise);
+
+    void destroy(V view);
+}

package/rules/.source/sdk/base/sdk-base/src/main/java/com/quicktvui/sdk/base/component/IEsComponentView.java

@@ -0,0 +1,8 @@
+package com.quicktvui.sdk.base.component;
+
+/**
+ * Create by weipeng on 2022/03/02 15:18
+ */
+public interface IEsComponentView {
+
+}