@quicktvui/ai 1.0.8 → 1.0.9

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/card/ESCardViewComponent.java

@@ -0,0 +1,190 @@
+package com.quicktvui.sdk.core.card;
+
+import android.content.Context;
+
+import com.quicktvui.sdk.annotations.ESKitAutoRegister;
+import com.quicktvui.sdk.base.EsPromise;
+import com.quicktvui.sdk.base.args.EsArray;
+import com.quicktvui.sdk.base.args.EsMap;
+import com.quicktvui.sdk.base.component.EsComponentAttribute;
+import com.quicktvui.sdk.base.component.IEsComponent;
+import com.quicktvui.sdk.base.core.EsProxy;
+import com.quicktvui.sdk.core.internal.IEsAppLoadHandler;
+
+
+/** 卡片 **/
+@ESKitAutoRegister
+public class ESCardViewComponent implements IEsComponent<WebFrameView> {
+    private ESESCardCallBackIml esEsCardCallBackIml;
+
+    @Override
+    public WebFrameView createView(Context context, EsMap params) {
+        this.esEsCardCallBackIml = new ESESCardCallBackIml();
+        return new WebFrameView(context, params);
+    }
+
+    @EsComponentAttribute
+    public void usePlaceHolder(WebFrameView view, boolean usePlaceHolder) {
+        view.setUsePlaceHolder(usePlaceHolder);
+    }
+
+    @EsComponentAttribute
+    public void contentPadding(WebFrameView view, EsArray esArray) {
+        if (esArray != null && esArray.size() > 0) {
+            view.setContentPadding(esArray.getInt(0), esArray.getInt(1), esArray.getInt(2), esArray.getInt(3));
+        }
+    }
+
+    @EsComponentAttribute
+    public void useDefaultUI(WebFrameView view, boolean useDefaultUI) {
+        view.setUseDefaultUI(useDefaultUI);
+    }
+
+    @EsComponentAttribute
+    public void cardId(WebFrameView view, String cardId) {
+        view.load(cardId, true, esEsCardCallBackIml);
+    }
+
+    @EsComponentAttribute
+    public void cardIdNoCache(WebFrameView view, String cardId) {
+        view.load(cardId, false, esEsCardCallBackIml);
+    }
+
+    @EsComponentAttribute
+    public void autoRecycle(WebFrameView view, boolean autoRecycle) {
+        view.setAutoRecycle(autoRecycle);
+    }
+
+    @EsComponentAttribute
+    public void useESEvent(WebFrameView view, boolean useESEvent) {
+        view.setUseESEvent(useESEvent);
+    }
+
+    @EsComponentAttribute
+    public void showPlaceHolder(WebFrameView view, boolean showPlaceHolder) {
+        if (view != null) {
+            view.showPlaceHolder(showPlaceHolder);
+        }
+    }
+
+    @EsComponentAttribute
+    public void placeHolderRect(WebFrameView view, EsArray esArray) {
+        if (esArray != null && esArray.size() > 0) {
+            int left = esArray.getInt(0);
+            int top = esArray.getInt(1);
+            int right = esArray.getInt(2);
+            int bottom = esArray.getInt(3);
+            view.setPlaceHolder(left, top, right, bottom);
+        }
+    }
+
+    @EsComponentAttribute
+    public void placeHolderRadius(WebFrameView view, int radius) {
+        if (view != null) {
+            view.setPlaceHolderRadius(radius);
+        }
+    }
+
+    @EsComponentAttribute
+    public void focusScale(WebFrameView view, float scale) {
+        if (view != null) {
+            view.setFocusScale(scale);
+        }
+    }
+
+    @Override
+    public void dispatchFunction(WebFrameView view, String eventName, EsArray params, EsPromise promise) {
+        switch (eventName) {
+            case "load":
+                String cardId = params.getString(0);
+                view.load(cardId, true, esEsCardCallBackIml);
+                break;
+            case "loadWithoutCache":
+                String cardId2 = params.getString(0);
+                view.load(cardId2, false, esEsCardCallBackIml);
+                break;
+            case "getLoadingStatus":
+                EsMap esMap = new EsMap();
+                esMap.pushInt("loadingStatus", view.getLoadingStatus());
+                promise.resolve(esMap);
+                break;
+            case "sendEvent2Vue":
+                String name = params.getString(0);
+                EsMap eventMap = params.getMap(1);
+                view.sendEvent2Vue(name, eventMap);
+                break;
+            case "autoRecycle":
+                boolean autoRecycle = params.getBoolean(0);
+                view.setAutoRecycle(autoRecycle);
+                break;
+            case "reload":
+                view.reload();
+                break;
+            case "reset":
+                view.reset();
+                break;
+            case "recycle":
+                view.recycle();
+                break;
+            case "removeCache":
+                view.removeCache();
+                break;
+            case "resizeCacheSize":
+                view.resizeCacheSize(params.getInt(0));
+                break;
+            case "clearAllCache":
+                view.clearAllCache();
+                break;
+        }
+    }
+
+    private class ESESCardCallBackIml extends ESCardCallBackImpl {
+
+        public ESESCardCallBackIml() {
+
+        }
+
+        @Override
+        public void onStartLoad(String cardId, IEsAppLoadHandler iEsAppLoadHandler) {
+            super.onStartLoad(cardId, iEsAppLoadHandler);
+        }
+
+        @Override
+        public void onLoadSuccess(ESCardBean esCardBean) {
+            super.onLoadSuccess(esCardBean);
+            EsMap esMap = new EsMap();
+            esMap.pushInt("result", 1);
+            esMap.pushString("cardId", esCardBean.getCardId());
+            sendNativeCardEvent(esMap);
+        }
+
+        @Override
+        public void onLoadFailed(ESCardBean esCardBean) {
+            super.onLoadFailed(esCardBean);
+            EsMap esMap = new EsMap();
+            esMap.pushInt("result", 0);
+            esMap.pushString("cardId", esCardBean.getCardId());
+            sendNativeCardEvent(esMap);
+        }
+
+        @Override
+        public void onResume() {
+            super.onResume();
+        }
+
+        @Override
+        public void onDestroy() {
+            super.onDestroy();
+        }
+    }
+
+    private void sendNativeCardEvent(EsMap esMap) {
+        EsProxy.get().sendNativeEventTraceable(this, "onCardEvent", esMap);
+    }
+
+    @Override
+    public void destroy(WebFrameView view) {
+        view.destroy();
+    }
+
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/card/WebFrameView.java

@@ -0,0 +1,125 @@
+package com.quicktvui.sdk.core.card;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.support.annotation.NonNull;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.quicktvui.base.ui.IRecyclerItemView;
+import com.quicktvui.sdk.base.args.EsMap;
+import com.quicktvui.sdk.core.R;
+import com.tencent.mtt.hippy.HippyInstanceContext;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.uimanager.HippyViewEvent;
+
+
+public class WebFrameView extends ESCardView implements IRecyclerItemView {
+    private HippyViewEvent cardViewEvent;
+    private boolean tag = false;
+
+    public WebFrameView(@NonNull Context context, EsMap params) {
+        super(context);
+        this.init(((HippyInstanceContext) context).getBaseContext());
+        //设置默认状态ui
+        setDefaultUI(context);
+        //
+        if (params != null && params.containsKey("focusable")) {
+            Object focusable = params.get("focusable");
+            if (focusable instanceof Boolean) {
+                defaultFocusable = params.getBoolean("focusable");
+            }
+        } else {
+            defaultFocusable = false;
+        }
+        setClipChildren(false);
+        setClipToPadding(false);
+    }
+
+    @Override
+    public void setFocusable(boolean focusable) {
+        super.setFocusable(focusable);
+        if (!tag) {
+            defaultFocusable = focusable;
+            tag = true;
+        }
+    }
+
+    @Override
+    public void onCreate(View view) {
+        getCardViewEvent().send(JSEventViewID, ((HippyInstanceContext) getContext()).getEngineContext(), getItemEventMap("create", -1, null));
+    }
+
+    @Override
+    public void onBind(View view, int position, Object item) {
+        getCardViewEvent().send(JSEventViewID, ((HippyInstanceContext) getContext()).getEngineContext(), getItemEventMap("bind", position, item));
+    }
+
+    @Override
+    public void onAttachToWindow(View view, int position, Object item) {
+        getCardViewEvent().send(JSEventViewID, ((HippyInstanceContext) getContext()).getEngineContext(), getItemEventMap("attach", position, item));
+    }
+
+    @Override
+    public void onDetachFromWindow(View view, int position, Object item) {
+        getCardViewEvent().send(JSEventViewID, ((HippyInstanceContext) getContext()).getEngineContext(), getItemEventMap("detach", position, item));
+    }
+
+    @Override
+    public void onUnBind(View view, int position, Object item) {
+        getCardViewEvent().send(JSEventViewID, ((HippyInstanceContext) getContext()).getEngineContext(), getItemEventMap("unBind", position, item));
+    }
+
+    @Override
+    public void setJSEventViewID(int JSEventViewID) {
+        this.JSEventViewID = JSEventViewID;
+    }
+
+    private HippyViewEvent getCardViewEvent() {
+        if (cardViewEvent == null) {
+            cardViewEvent = new HippyViewEvent("onCardBind");
+        }
+        return cardViewEvent;
+    }
+
+    private HippyMap getItemEventMap(String eventName, int position, Object item) {
+        HippyMap hm = new HippyMap();
+        hm.pushString("eventName", eventName);
+        hm.pushInt("position", position);
+        hm.pushObject("itemData", item);
+        return hm;
+    }
+
+    private void setDefaultUI(Context context) {
+        ImageView imageView = new ImageView(context);
+        imageView.setBackgroundResource(R.drawable.eskit_card_loading_bg);
+        setLoadingView(imageView);
+        LinearLayout linearLayout = new LinearLayout(context);
+        linearLayout.setOrientation(LinearLayout.VERTICAL);
+        linearLayout.setGravity(Gravity.CENTER);
+        linearLayout.setBackgroundResource(R.drawable.eskit_card_loading_bg);
+        TextView textView = new TextView(context);
+        textView.setText("加载失败，请重试");
+        textView.setTextColor(Color.WHITE);
+        textView.setTextSize(18);
+        Button button = new Button(context);
+        button.setBackgroundResource(R.drawable.eskit_card_load_fail_btn_bg);
+        button.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                reloadByClick();
+            }
+        });
+        linearLayout.addView(textView, new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.CENTER_HORIZONTAL));
+        FrameLayout.LayoutParams lp = new LayoutParams(130, 40, Gravity.CENTER_HORIZONTAL);
+        lp.topMargin = 40;
+        linearLayout.addView(button, lp);
+        setLoadFailView(linearLayout);
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/component/BaseHippyViewController.java

@@ -0,0 +1,30 @@
+package com.quicktvui.sdk.core.component;
+
+import android.content.Context;
+import android.view.View;
+
+import com.tencent.mtt.hippy.HippyInstanceContext;
+import com.tencent.mtt.hippy.uimanager.HippyViewBase;
+import com.tencent.mtt.hippy.uimanager.HippyViewController;
+
+import com.quicktvui.sdk.core.internal.EsViewManager;
+
+/**
+ * <br>
+ * 注释
+ * <br>
+ * <br>
+ * Created by WeiPeng on 2023-10-30 16:09
+ */
+public abstract class BaseHippyViewController<T extends View & HippyViewBase> extends HippyViewController<T> {
+
+    protected void markObject2Engine(Context context) {
+        EsViewManager.get().markObject2Engine(this, ((HippyInstanceContext) context).getEngineContext());
+    }
+
+    @Override
+    public void onViewDestroy(T t) {
+        super.onViewDestroy(t);
+        EsViewManager.get().unMarkObject2Engine(this);
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/component/CommonViewController.java

@@ -0,0 +1,290 @@
+package com.quicktvui.sdk.core.component;
+
+import android.content.Context;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.quicktvui.hippyext.IEsComponentTag;
+import com.quicktvui.sdk.base.args.EsMap;
+import com.quicktvui.sdk.base.component.EsComponentAttribute;
+import com.quicktvui.sdk.base.component.IEsComponent;
+import com.quicktvui.sdk.core.internal.EsPromiseProxy;
+import com.quicktvui.sdk.core.internal.EsViewManager;
+import com.quicktvui.sdk.core.utils.MapperUtils;
+import com.sunrain.toolkit.utils.log.L;
+import com.quicktvui.hippyext.views.fastlist.TemplateCodeParser;
+import com.tencent.mtt.hippy.HippyInstanceContext;
+import com.tencent.mtt.hippy.HippyRootView;
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.dom.node.StyleNode;
+import com.tencent.mtt.hippy.modules.Promise;
+import com.tencent.mtt.hippy.uimanager.ControllerManager;
+import com.tencent.mtt.hippy.uimanager.ControllerRegistry;
+import com.tencent.mtt.hippy.uimanager.HippyViewController;
+import com.tencent.mtt.hippy.uimanager.RenderNode;
+import com.tencent.mtt.hippy.utils.ArgumentUtils;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+
+/**
+ * Create by weipeng on 2022/02/24 17:55
+ * 提供覆写更多方法
+ */
+public class CommonViewController extends HippyViewController implements IEsComponentTag {
+
+    private IEsComponent mComponent;
+    private List<Method> mMethods;
+
+    public CommonViewController(IEsComponent component) {
+        this.mComponent = component;
+    }
+
+    @Override
+    protected View createViewImpl(Context context) {
+        return createViewImpl(context, null);
+    }
+
+    @Override
+    protected View createViewImpl(Context context, HippyMap iniProps) {
+        if (L.DEBUG) L.logI("--------------------------------------------------");
+        if (L.DEBUG) L.logI("createViewImpl:" + mComponent.getClass().getSimpleName());
+        if (L.DEBUG) L.logI("createViewImpl:" + (iniProps == null ? null : iniProps.toString()));
+        EsViewManager.get().markObject2Engine(mComponent, ((HippyInstanceContext) context).getEngineContext());
+        View view = mComponent.createView(context, MapperUtils.hpMap2EsMap(iniProps));
+        findAllAttributeMethod();
+        // tmp: 屏蔽首次舒适化的属性调用
+        fillAttribute(view, iniProps);
+        return view;
+    }
+
+    @Override
+    public void setCustomProp(View view, String methodName, Object props) {
+        if(mMethods == null) return;
+        for (Method method : mMethods) {
+            if (method.getName().equals(methodName)) {
+                Type type = method.getGenericParameterTypes()[1];
+                fillAttribute(method, type, view, MapperUtils.tryMapperHpData2EsData(props));
+                return;
+            }
+        }
+    }
+
+    @Override
+    public void dispatchFunction(View view, String functionName, HippyArray var) {
+        this.dispatchFunction(view, functionName, var, null);
+    }
+
+    @Override
+    public void dispatchFunction(View view, String functionName, HippyArray params, Promise promise) {
+        if(L.DEBUG) {
+            L.logD(mComponent.getClass().getSimpleName());
+            L.logD("dispatchFunction view: " + view + ", functionName: " + functionName + ", params: " + params + ", promise: " + promise);
+        }
+        super.dispatchFunction(view, functionName, params, promise);
+        mComponent.dispatchFunction(view, functionName,
+                MapperUtils.hpArray2EsArray(params), promise == null ? null : new EsPromiseProxy(promise));
+    }
+
+    public IEsComponent getComponent() {
+        return mComponent;
+    }
+
+    private void findAllAttributeMethod() {
+        if (mMethods == null) {
+            mMethods = new ArrayList<>();
+            //Fixme weipeng 这里getDeclaredMethods方法会导致继承父类的属性无法被发现，这里暂时改成getMethods，但需要优化性能
+            // ---> 排查发现是从mComponent反射方法，性能影响小，先不优化 add by weipeng
+//            Method[] methods = mComponent.getClass().getDeclaredMethods();
+            Method[] methods = mComponent.getClass().getMethods();
+            for (Method method : methods) {
+                EsComponentAttribute ann = method.getAnnotation(EsComponentAttribute.class);
+                if (ann != null){
+                    Type[] types = method.getGenericParameterTypes();
+                    if(types != null && types.length == 2){
+                        mMethods.add(method);
+                    }
+                }
+            }
+            Collections.sort(mMethods, (o1, o2) -> {
+                EsComponentAttribute a1 = o1.getAnnotation(EsComponentAttribute.class);
+                EsComponentAttribute a2 = o2.getAnnotation(EsComponentAttribute.class);
+                assert a1 != null;
+                assert a2 != null;
+                return a1.index() - a2.index();
+            });
+        }
+    }
+
+    private void fillAttribute(View view, HippyMap props) {
+        if(mMethods == null || mMethods.size() == 0) return;
+        if (props == null) return;
+        EsMap data = MapperUtils.hpMap2EsMap(props);
+        for (Method method : mMethods) {
+            Type type = method.getGenericParameterTypes()[1];
+            fillAttribute(method, type, view, data.get(method.getName()));
+        }
+    }
+
+    private void fillAttribute(Method method, Type type, View view, Object obj) {
+        if (view == null) {
+            L.logEF("view is NULL");
+            return;
+        }
+        if (obj == null) return;
+        if (TemplateCodeParser.isPendingPro(obj)) {
+            return;
+        }
+        Object params;
+        try {
+            if (type == obj.getClass()) {
+                params = obj;
+            } else {
+                params = ArgumentUtils.parseArgument(type, obj);
+            }
+        } catch (Exception e) {
+            L.logEF(String.format("方法参数类型不对应: %s %s(%s)",
+                    getComponent().getClass().getSimpleName(),
+                    method.getName(),
+                    type.getClass().getSimpleName()
+            ));
+            return;
+        }
+        try {
+            method.invoke(getComponent(), view, params);
+        } catch (Exception e) {
+            L.logW("fill attribute", e);
+        }
+    }
+
+    @Override
+    public boolean invokePropMethodForPending(View view, String prop, Object data) {
+        if (view == null) return false;
+        for (Method method : mMethods) {
+            if (method.getName().equals(prop)) {
+                Type type = method.getGenericParameterTypes()[1];
+                fillAttribute(method, type, view, MapperUtils.tryMapperHpData2EsData(data));
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void onViewDestroy(View view) {
+        EsViewManager.get().unMarkObject2Engine(mComponent);
+        if (mComponent != null) {
+            mComponent.destroy(view);
+//            mComponent = null;
+        }
+        super.onViewDestroy(view);
+    }
+
+    // ---------------------------------- NEW --------------------------------------//
+
+    @Override
+    protected void onCreateViewByCache(View view, String type, HippyMap props) {
+        super.onCreateViewByCache(view, type, props);
+    }
+
+    @Override
+    public void onAfterCreateView(View view, HippyMap initialProps) {
+        super.onAfterCreateView(view, initialProps);
+    }
+
+    @Override
+    public void onAfterUpdateProps(View v) {
+        super.onAfterUpdateProps(v);
+    }
+
+    @Override
+    protected void updateExtra(View view, Object object) {
+        super.updateExtra(view, object);
+    }
+
+    @Override
+    protected StyleNode createNode(boolean isVirtual, int rootId) {
+        return super.createNode(isVirtual, rootId);
+    }
+
+    @Override
+    protected StyleNode createNode(boolean isVirtual) {
+        return super.createNode(isVirtual);
+    }
+
+    @Override
+    public void updateLayout(int id, int x, int y, int width, int height, ControllerRegistry componentHolder) {
+        super.updateLayout(id, x, y, width, height, componentHolder);
+    }
+
+    @Override
+    protected boolean shouldInterceptLayout(View view, int x, int y, int width, int height) {
+        return super.shouldInterceptLayout(view, x, y, width, height);
+    }
+
+    @Override
+    protected boolean handleGestureBySelf() {
+        return super.handleGestureBySelf();
+    }
+
+    @Override
+    public void onFocusChange(View v, boolean hasFocus) {
+        super.onFocusChange(v, hasFocus);
+    }
+
+    @Override
+    protected void setGestureType(View view, String type, boolean flag) {
+        super.setGestureType(view, type, flag);
+    }
+
+    @Override
+    public RenderNode createRenderNode(int id, HippyMap props, String className, HippyRootView hippyRootView, ControllerManager controllerManager, boolean lazy) {
+        return super.createRenderNode(id, props, className, hippyRootView, controllerManager, lazy);
+    }
+
+    @Override
+    public void onBatchComplete(View view) {
+        super.onBatchComplete(view);
+    }
+
+    @Override
+    protected void deleteChild(ViewGroup parentView, View childView) {
+        super.deleteChild(parentView, childView);
+    }
+
+    @Override
+    protected void deleteChild(ViewGroup parentView, View childView, int childIndex) {
+        super.deleteChild(parentView, childView, childIndex);
+    }
+
+    @Override
+    public void onBeforeViewDestroy(View view) {
+        super.onBeforeViewDestroy(view);
+    }
+
+    @Override
+    protected void addView(ViewGroup parentView, View view, int index) {
+        super.addView(parentView, view, index);
+    }
+
+    @Override
+    protected void onManageChildComplete(View view) {
+        super.onManageChildComplete(view);
+    }
+
+    @Override
+    public View getChildAt(View viewGroup, int i) {
+        return super.getChildAt(viewGroup, i);
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+        mComponent = null;
+    }
+}