@quicktvui/ai 1.0.7 → 1.0.9

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/jsview/JsSlotView.java

@@ -0,0 +1,353 @@
+package com.quicktvui.sdk.core.jsview;
+
+import static android.view.ViewGroup.LayoutParams.MATCH_PARENT;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.RoundRectShape;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.widget.FrameLayout;
+
+import com.extscreen.runtime.api.ability.slotview.RecyclerViewEventHandler;
+import com.sunrain.toolkit.utils.log.L;
+import com.sunrain.toolkit.utils.observer.BaseObserver;
+import com.tencent.mtt.hippy.utils.PixelUtil;
+
+import java.lang.ref.SoftReference;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Observable;
+import java.util.Set;
+
+import com.quicktvui.sdk.core.internal.Constants;
+import com.quicktvui.sdk.core.internal.IEsAppLoadHandler;
+import com.quicktvui.sdk.core.jsview.slot.SlotView;
+import com.quicktvui.sdk.core.utils.SlotUtils;
+import com.quicktvui.sdk.base.args.EsMap;
+
+/**
+ * <br>
+ *
+ * <br>
+ */
+public class JsSlotView extends FrameLayout {
+
+    private String mName;
+    private String mSid;
+    private EsMap mLoadData;
+    private volatile int mSlotViewId;
+
+    private FrameLayout mHolderViewContainer;
+
+    private boolean mSlotViewNeedFocus = false;
+
+    private final Map<String, Object> mCacheEventMap = new HashMap<>(5);
+
+    private SoftReference<RecyclerViewEventHandler> mJsRecyclerViewHandler;
+
+    private boolean mFistAttachToWindow = true;
+
+    private SlotView currentSlotView;
+
+    public JsSlotView(Context context, String name, EsMap params) {
+        super(context);
+        init(context);
+        mName = name;
+        mLoadData = new EsMap();
+        mLoadData.pushString("name", mName);
+        mLoadData.pushString("key", mSid);
+        mLoadData.pushObject("params", params);
+    }
+
+    public void setNeedFocus(boolean needFocus) {
+        mSlotViewNeedFocus = needFocus;
+    }
+
+    public String getName() {
+        return mName;
+    }
+
+    // --------------------------------------------------------
+
+    private void init(Context context) {
+        mSid = String.valueOf(hashCode());
+        setFocusable(false);
+        setClipChildren(false);
+        setClipToPadding(false);
+    }
+
+    void addSlotView(SlotView view) {
+        currentSlotView = view;
+        L.logDF("add SlotView " + mName + ",id: " + view.getId());
+        addView(view, new FrameLayout.LayoutParams(-1, -1));
+
+//        view.addOnAttachStateChangeListener(this);
+
+        view.observe(new BaseObserver<Boolean>() {
+            @Override
+            public void onUpdate(Observable o, Boolean suspend) {
+                if (!suspend) {
+                    L.logD("do unsuspend");
+                    clearHolderView(500);
+                }
+            }
+        });
+    }
+
+    @Override
+    public void addView(View child, int index, ViewGroup.LayoutParams params) {
+        // 将SlotView放在占位View的底下
+        if (child instanceof SlotView) {
+            index = 0;
+        }
+        super.addView(child, index, params);
+        if (child instanceof SlotView) {
+            mSlotViewId = child.getId();
+            fireCacheEvents();
+            updateSlotFocus(child);
+        }
+    }
+
+    //region 1. 占位View
+
+    public void showDefaultPlaceHolderView() {
+        Context context = getContext();
+        mHolderViewContainer = new FrameLayout(context);
+        mHolderViewContainer.setFocusable(true);
+        mHolderViewContainer.setBackgroundDrawable(generatePlaceHolderDrawable());
+        addView(mHolderViewContainer, new LayoutParams(MATCH_PARENT, MATCH_PARENT));
+    }
+
+    public void setPlaceHolderView(int viewResId) {
+        View view = LayoutInflater.from(getContext()).inflate(viewResId, this, false);
+        setPlaceHolderView(view);
+    }
+
+    public void setPlaceHolderView(View view) {
+        replaceHolderView(view);
+    }
+
+    private Drawable generatePlaceHolderDrawable() {
+        float cornerRadius = PixelUtil.dp2px(20);
+        float[] outerRadii = {cornerRadius, cornerRadius, cornerRadius, cornerRadius, cornerRadius, cornerRadius, cornerRadius, cornerRadius};
+        ShapeDrawable drawable = new ShapeDrawable(new RoundRectShape(outerRadii, null, null));
+        drawable.getPaint().setColor(Color.parseColor("#16264D"));
+        return drawable;
+    }
+
+    private void replaceHolderView(View view) {
+        if (mHolderViewContainer == null) return;
+        mHolderViewContainer.setBackground(null);
+        mHolderViewContainer.addView(view);
+    }
+
+    private void clearHolderView(int delay) {
+        // 说明可能使用了宿主的PlaceHolderView
+        // 约定宿主的placeholder放在JsSlotView的parent的背景上，JsSlotView来清除
+        if (mHolderViewContainer == null) {
+            findAndHidePlaceHolderView();
+            return;
+        }
+        Runnable task = () -> {
+            removeView(mHolderViewContainer);
+            mHolderViewContainer = null;
+        };
+        if (delay == 0) {
+            task.run();
+        } else {
+            postDelayed(task, delay);
+        }
+    }
+
+    private void findAndHidePlaceHolderView() {
+        ViewParent parent = getParent();
+        int level = 3;
+        do {
+            if (parent instanceof ViewGroup) {
+                Object tag = ((ViewGroup) parent).getTag();
+                if (Objects.equals(tag, mName)) {
+                    ((ViewGroup) parent).setBackground(null);
+                    break;
+                }
+                parent = getParent();
+                continue;
+            }
+            break;
+        } while (parent != null && level-- > 0);
+    }
+
+    //endregion
+
+    //region 2. 焦点处理
+
+    @Override
+    public void setFocusable(boolean focusable) {
+        super.setFocusable(focusable);
+        L.logDF("setFocusable " + focusable);
+    }
+
+    /**
+     * 更新焦点逻辑
+     **/
+    public void updateSlotFocus(View child) {
+        setFocusable(!mSlotViewNeedFocus);
+        if (!mSlotViewNeedFocus) {
+            setDescendantFocusability(FOCUS_BLOCK_DESCENDANTS);
+            L.logDF("block child focus");
+        } else if (hasFocus()) {
+            child.requestFocus();
+            L.logDF("child request focus");
+        }
+    }
+
+    @Override
+    protected void onFocusChanged(boolean gainFocus, int direction, @Nullable Rect previouslyFocusedRect) {
+        super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
+        sendFocusChangeEvent(gainFocus, direction);
+    }
+
+    public void sendFocusChangeEvent(boolean gainFocus) {
+        sendFocusChangeEvent(gainFocus, -1);
+    }
+
+    public void sendFocusChangeEvent(boolean gainFocus, int direction) {
+        sendFocusChangeEvent(gainFocus, direction, null);
+    }
+
+    public void sendFocusChangeEvent(boolean gainFocus, int direction, @Nullable Rect previouslyFocusedRect) {
+
+        EsMap data = new EsMap();
+        data.pushBoolean("gainFocus", gainFocus);
+        data.pushInt("direction", direction);
+
+        if (previouslyFocusedRect != null) {
+            EsMap rect = new EsMap();
+            rect.pushInt("left", previouslyFocusedRect.left);
+            rect.pushInt("top", previouslyFocusedRect.top);
+            rect.pushInt("right", previouslyFocusedRect.right);
+            rect.pushInt("bottom", previouslyFocusedRect.bottom);
+            data.pushObject("previouslyFocusedRect", rect);
+        }
+
+//        sendEvent("onFocusChanged", data);
+        JsSlotViewManager.get().sendEvent(this, "onFocusChanged", data);
+    }
+
+    //endregion
+
+    //region 3. 发送事件
+
+    void sendCustomEvent(final String eventName, final Object data) {
+        EsMap map = new EsMap();
+        map.pushString("eventName", eventName);
+        map.pushObject("eventData", data);
+        sendEvent(Constants.GLOBAL_EVENT.EVT_ON_SLOT_CUSTOM, map);
+    }
+
+    void sendEvent(final String eventName, final Object data) {
+        if (mSlotViewId == 0) {
+            cacheEvent(eventName, data);
+            return;
+        }
+        IEsAppLoadHandler loadHandler = SlotUtils.getAppLoaderHandler(getContext());
+        if (loadHandler == null) return;
+        Object params = data;
+        if (data instanceof Bundle) {
+            EsMap map = new EsMap();
+            map.pushBundle((Bundle) data);
+            params = map;
+        }
+        mLoadData.pushObject("params", params);
+        loadHandler.sendEvent(eventName, mLoadData);
+    }
+
+    /**
+     * SlotView没加载之前缓存事件
+     **/
+    private synchronized void cacheEvent(String eventName, Object data) {
+        mCacheEventMap.put(eventName, data);
+    }
+
+    /**
+     * 执行view没加载之前缓存的事件
+     **/
+    private synchronized void fireCacheEvents() {
+        Map<String, Object> events = new HashMap<>(mCacheEventMap);
+        Set<String> keys = events.keySet();
+        for (String key : keys) {
+            sendEvent(key, events.get(key));
+        }
+    }
+
+    //endregion
+
+    //region 4. attachedToWindow/detachedFromWindow
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        if(mFistAttachToWindow) {
+            mFistAttachToWindow = false;
+            return;
+        }
+        findAndHidePlaceHolderView();
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+    }
+
+    //endregion
+
+    //region 5. RecyclerView接口封装
+
+    public RecyclerViewEventHandler getRecyclerViewEventHandler() {
+        RecyclerViewEventHandler handler;
+        if (mJsRecyclerViewHandler == null || (handler = mJsRecyclerViewHandler.get()) == null) {
+            handler = new RecyclerViewHandlerImpl(this);
+            mJsRecyclerViewHandler = new SoftReference<>(handler);
+        }
+        return handler;
+    }
+
+    //endregion
+
+    //region 设置激活鼠标事件
+    public void setEnableMouse() {
+        if (currentSlotView != null) {
+            currentSlotView.setMouseEnable();
+            L.logDF("setEnableMouse " + currentSlotView.getId());
+        }
+    }
+    //endregion
+
+    //region 数据获取
+
+    public String getSid() {
+        return mSid;
+    }
+
+    public EsMap getLoadData() {
+        return mLoadData;
+    }
+
+    //endregion
+
+    @Override
+    public String toString() {
+        return "JsView{" +
+                "name='" + mName + '\'' +
+                ", sid='" + mSid + '\'' +
+                '}';
+    }
+}

package/rules/.source/sdk/core/sdk-core/src/main/java/com/quicktvui/sdk/core/jsview/JsSlotViewManager.java

@@ -0,0 +1,363 @@
+package com.quicktvui.sdk.core.jsview;
+
+import static com.quicktvui.sdk.core.utils.SlotUtils.waitPhoneWindowAdded;
+
+import android.content.Context;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.extscreen.runtime.api.ability.slotview.AttachStateCallback;
+import com.sunrain.toolkit.bolts.tasks.TaskCompletionSource;
+import com.sunrain.toolkit.utils.log.L;
+import com.tencent.mtt.hippy.HippyRootView;
+import com.tencent.mtt.hippy.utils.ExtendUtil;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import com.quicktvui.sdk.core.EsData;
+import com.quicktvui.sdk.core.EsManager;
+import com.quicktvui.sdk.core.R;
+import com.quicktvui.sdk.core.internal.Constants;
+import com.quicktvui.sdk.core.internal.IEsAppLoadCallback;
+import com.quicktvui.sdk.core.internal.IEsAppLoadHandler;
+import com.quicktvui.sdk.core.jsview.slot.SlotView;
+import com.quicktvui.sdk.core.utils.ESExecutors;
+import com.quicktvui.sdk.core.utils.EskitLazyInitHelper;
+import com.quicktvui.sdk.core.utils.PluginUtils;
+import com.quicktvui.sdk.core.utils.SlotUtils;
+import com.quicktvui.sdk.base.EsEventPacket;
+import com.quicktvui.sdk.base.EsException;
+import com.quicktvui.sdk.base.args.EsMap;
+
+/**
+ * JSView管理类
+ * <br>
+ */
+public class JsSlotViewManager {
+
+    private final ExecutorService mExecutor = ESExecutors.createExecutor("js-slot-view", 1, 1);
+
+    //region 1. 加载快应用
+
+    public void attachToActivity(Context context, EsData data) {
+        attachToActivity(context, data, null);
+    }
+
+    public void attachToActivity(Context context, EsData data, AttachStateCallback callback) {
+        if (data == null) return;
+        EskitLazyInitHelper.initIfNeed();
+        L.logDF("req load SlotView app");
+        PluginUtils.assertIsInstanceOfActivity(context);
+        mExecutor.execute(new LoadSlotViewAppJob(context, data, callback));
+    }
+
+    private static final class LoadSlotViewAppJob implements Runnable {
+
+        private Context context;
+        private EsData data;
+        private AttachStateCallback callback;
+
+        public LoadSlotViewAppJob(Context context, EsData data, AttachStateCallback callback) {
+            this.context = context;
+            this.data = data;
+            this.callback = callback;
+        }
+
+        @Override
+        public void run() {
+            try {
+                L.logDF("load SlotView app");
+                waitPhoneWindowAdded(context);
+                View decorView = SlotUtils.getDecorView(context);
+                if (decorView != null) {
+                    IEsAppLoadHandler loadHandler = loadRpk(context, data);
+                    decorView.setTag(R.id.es_js_view_tag1, loadHandler);
+                    notifyCallback(AttachStateCallback.STATE_SUCCESS, "");
+                } else {
+                    notifyCallback(AttachStateCallback.STATE_ERR_WINDOW, "get window DecorView failed");
+                }
+            } catch (Exception e) {
+                L.logEF("load SlotView", e);
+                byte errorCode = e instanceof TimeoutException ? AttachStateCallback.STATE_ERR_TIMEOUT : AttachStateCallback.STATE_ERR_OTHER;
+                notifyCallback(errorCode, e.getMessage());
+            } finally {
+                this.context = null;
+                this.data = null;
+                this.callback = null;
+            }
+        }
+
+        private IEsAppLoadHandler loadRpk(Context context, EsData data) throws Exception {
+            TaskCompletionSource<Void> wait = new TaskCompletionSource<>();
+
+            final IEsAppLoadHandler[] loadHandler = new IEsAppLoadHandler[1];
+
+            EsManager.get().load(context, data, new IEsAppLoadCallback() {
+                @Override
+                public void onStartLoad(IEsAppLoadHandler handler) {
+                    loadHandler[0] = handler;
+                }
+
+                @Override
+                public void onViewLoaded(HippyRootView view) {
+                    L.logDF("load SlotView ok");
+                    // 不add HippyRootView 也能显示JsView
+//                    FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(1, 1);
+//                    SlotUtils.addContentView(context, view, layoutParams);
+
+                    wait.setResult(null);
+                }
+
+                @Override
+                public void onLoadError(EsException e) {
+                    e.printStackTrace();
+                    wait.setError(e);
+                }
+
+                @Override
+                public void onEsAppEvent(EsEventPacket packet) {
+                    if (L.DEBUG) L.logD("onEsAppEvent packet: " + packet);
+                }
+
+                @Override
+                public void requestFinish() {
+                    if (L.DEBUG) L.logD("requestFinish");
+                }
+            });
+
+            boolean success = wait.getTask().waitForCompletion(1, TimeUnit.MINUTES);
+            if (!success) { // 超时
+                throw new TimeoutException("load rpk timeout");
+            }
+
+            return loadHandler[0];
+        }
+
+        private void notifyCallback(byte state, String message) {
+            if (callback != null) {
+                callback.onResult(state, message);
+            }
+        }
+
+    }
+
+    //endregion
+
+    //region 2. 创建JsSlotView
+
+    public JsSlotView createJSView(Context context, String name) {
+        return createJSView(context, name, new EsMap());
+    }
+
+    public JsSlotView createJSView(Context context, String name, EsMap params) {
+        JsSlotView jsView = new JsSlotView(context, name, params);
+        L.logIF("req create SlotView " + name + ", sid:" + jsView.getSid());
+        SlotUtils.setJSViewContainer(jsView);
+        mExecutor.execute(new CreateSlotViewJob(jsView));
+        return jsView;
+    }
+
+    private static final class CreateSlotViewJob implements Runnable {
+
+        private JsSlotView jsView;
+
+        public CreateSlotViewJob(JsSlotView jsView) {
+            this.jsView = jsView;
+        }
+
+        @Override
+        public void run() {
+            try {
+                IEsAppLoadHandler loadHandler = SlotUtils.getAppLoaderHandler(jsView.getContext());
+                L.logIF("create SlotView " + (loadHandler != null) + ", sid:" + jsView.getSid());
+                if (loadHandler == null) return;
+                loadHandler.sendEvent(Constants.GLOBAL_EVENT.EVT_ON_REQ_SLOT_CREATE, jsView.getLoadData());
+            } finally {
+                jsView = null;
+            }
+        }
+    }
+
+    //endregion
+
+    //region 3. 发送事件
+
+    public void dispatchKeyEvent(JsSlotView jsView, KeyEvent event) {
+        if (L.DEBUG) L.logD("req dispatchKeyEvent jsView: " + jsView + ", event: " + event);
+        EsMap data = new EsMap();
+        data.pushInt("action", event.getAction());
+        data.pushInt("keyCode", event.getKeyCode());
+        data.pushInt("keyRepeat", event.getRepeatCount());
+        sendEvent(jsView, Constants.GLOBAL_EVENT.EVT_ON_SLOT_DISPATCH_KEY, data);
+    }
+
+    public void onBackPressed(JsSlotView jsView, Runnable callback) {
+        if (L.DEBUG) L.logD("req onBackPressed jsView: " + jsView);
+        SlotModule.sBackPressCallback = callback;
+        mExecutor.execute(new SendEventJob(jsView, Constants.GLOBAL_EVENT.EVT_ON_SLOT_BACK_PRESSED, null));
+    }
+
+    public void sendEvent(JsSlotView jsView, String eventName, @Nullable Object data) {
+        if (L.DEBUG)
+            L.logD("req send SlotView event, eventName: " + eventName + (data == null ? "" : ",data: " + data));
+        mExecutor.execute(new SendEventJob(jsView, eventName, data));
+    }
+
+    public void sendCustomEvent(JsSlotView jsView, String eventName, @Nullable Object data) {
+        if (L.DEBUG)
+            L.logD("req send SlotView custom event, eventName: " + eventName + (data == null ? "" : ",data: " + data));
+        mExecutor.execute(new SendEventJob(jsView, eventName, data, true));
+    }
+
+    private static final class SendEventJob implements Runnable {
+
+        private JsSlotView jsView;
+        private String eventName;
+        private Object data;
+        private final boolean isCustomEvent;
+
+        public SendEventJob(JsSlotView jsView, String eventName, @Nullable Object data) {
+            this(jsView, eventName, data, false);
+        }
+
+        public SendEventJob(JsSlotView jsView, String eventName, @Nullable Object data, boolean isCustomEvent) {
+            this.jsView = jsView;
+            this.eventName = eventName;
+            this.data = data;
+            this.isCustomEvent = isCustomEvent;
+        }
+
+        @Override
+        public void run() {
+            try {
+                if (isCustomEvent) {
+                    if (L.DEBUG) L.logD("send custom event to SlotView: " + eventName);
+                    jsView.sendCustomEvent(eventName, data);
+                } else {
+                    if (L.DEBUG) L.logD("send event to SlotView: " + eventName);
+                    jsView.sendEvent(eventName, data);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            } finally {
+                this.jsView = null;
+                this.eventName = null;
+                this.data = null;
+            }
+        }
+
+    }
+
+    //endregion
+
+    //region 4. 销毁JsSlotView
+
+    public void deleteJSView(JsSlotView jsView) {
+        L.logIF("req delete SlotView");
+        SlotModule.sBackPressCallback = null;
+        removeFromParent(jsView);
+        mExecutor.execute(new DeleteJSViewJob(jsView));
+    }
+
+    private void removeFromParent(JsSlotView view) {
+        if (view.getParent() != null) {
+            ((ViewGroup) view.getParent()).removeView(view);
+        }
+    }
+
+    private static final class DeleteJSViewJob implements Runnable {
+
+        private JsSlotView jsView;
+
+        public DeleteJSViewJob(JsSlotView jsView) {
+            this.jsView = jsView;
+        }
+
+        @Override
+        public void run() {
+            try {
+                IEsAppLoadHandler loadHandler = SlotUtils.getAppLoaderHandler(jsView.getContext());
+                L.logIF("delete SlotView " + (loadHandler != null));
+                if (loadHandler == null) return;
+                loadHandler.sendEvent(Constants.GLOBAL_EVENT.EVT_ON_REQ_SLOT_DESTROY, jsView.getLoadData());
+            } finally {
+                jsView = null;
+            }
+        }
+    }
+
+    //endregion
+
+    //region 5. 销毁快应用
+
+    public void detachFromActivity(Context context) {
+        L.logDF("req destroy SlotView app");
+        PluginUtils.assertIsInstanceOfActivity(context);
+        mExecutor.execute(new DestroySlotViewAppJob(context));
+    }
+
+    private static final class DestroySlotViewAppJob implements Runnable {
+
+        private final Context context;
+
+        public DestroySlotViewAppJob(Context context) {
+            this.context = context;
+        }
+
+        @Override
+        public void run() {
+            IEsAppLoadHandler loadHandler = SlotUtils.getAppLoaderHandler(context);
+            SlotUtils.clearTags(context);
+            L.logDF("destroy SlotView app " + (loadHandler != null));
+            if (loadHandler == null) return;
+            loadHandler.onDestroy();
+        }
+
+    }
+
+    //endregion
+
+    //region Controller回调
+
+    public void onViewCreated(SlotView view) {
+        if (L.DEBUG) L.logD("on SlotView create");
+        String sid = ExtendUtil.getViewSID(view);
+        JsSlotView jsView = SlotUtils.getSViewContainer(view.getContext(), sid);
+        if (jsView != null) {
+            if (L.DEBUG) L.logD("on SlotView create " + jsView.getName() + ", sid:" + sid);
+            jsView.addSlotView(view);
+        }
+    }
+
+    public void onViewDelete(SlotView view) {
+        if (L.DEBUG) L.logD("on SlotView delete");
+        view.release();
+    }
+
+    //endregion
+
+    public void setEnableMouse(JsSlotView view) {
+        String sid = ExtendUtil.getViewSID(view);
+        JsSlotView jsView = SlotUtils.getSViewContainer(view.getContext(), sid);
+        if (jsView != null) {
+            jsView.setEnableMouse();
+        }
+    }
+
+    private static final class JSViewManagerHolder {
+        private static final JsSlotViewManager INSTANCE = new JsSlotViewManager();
+    }
+
+    public static JsSlotViewManager get() {
+        return JSViewManagerHolder.INSTANCE;
+    }
+
+    private JsSlotViewManager() {
+    }
+
+}