@quicktvui/ai 1.0.7 → 1.0.8

package/rules/.source/hippy/extend_views/CoverFlowViewController.java

@@ -0,0 +1,195 @@
+package com.tencent.extend.views;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.tencent.extend.ICoverFlow;
+import com.tencent.mtt.hippy.annotation.HippyController;
+import com.tencent.mtt.hippy.annotation.HippyControllerProps;
+import com.tencent.mtt.hippy.common.HippyArray;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.modules.Promise;
+import com.tencent.mtt.hippy.uimanager.HippyGroupController;
+import com.tencent.mtt.hippy.utils.PixelUtil;
+import com.tencent.mtt.hippy.views.scroll.HippyScrollView;
+
+/**
+ * @Description: TODO
+ * @author: edsheng
+ * @date: 2018/8/27 9:55
+ * @version: V1.0
+ */
+@HippyController(name = CoverFlowViewController.CLASS_NAME)
+public class CoverFlowViewController<T extends ViewGroup & HippyScrollView> extends HippyGroupController
+{
+  protected static final String	SCROLL_TO	= "scrollTo";
+	private static final String	SCROLL_TO_WITHOPTIONS	= "scrollToWithOptions";
+
+	public static final String	CLASS_NAME	= "CoverFlow";
+
+	@Override
+	protected View createViewImpl(Context context, HippyMap iniProps)
+	{
+    if (iniProps.getBoolean("isVertical")) {
+      return new CoverFlowVerticalView(context);
+    }
+    return new CoverFlowHorizontalView(context);
+	}
+
+	@Override
+	protected View createViewImpl(Context context)
+	{
+		return null;
+		//        return new HippyScrollView(context);
+	}
+
+	@HippyControllerProps(name = "scrollEnabled", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = true)
+	public void setScrollEnabled(HippyScrollView view, boolean flag)
+	{
+		view.setScrollEnabled(flag);
+	}
+
+	@HippyControllerProps(name = "showScrollIndicator", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+	public void setShowScrollIndicator(HippyScrollView view, boolean flag)
+	{
+		view.showScrollIndicator(flag);
+	}
+
+	@HippyControllerProps(name = "onScrollEnable", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+	public void setScrollEventEnable(HippyScrollView view, boolean flag)
+	{
+		view.setScrollEventEnable(flag);
+	}
+
+	@HippyControllerProps(name = "onScrollBeginDrag", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+	public void setScrollBeginDragEventEnable(HippyScrollView view, boolean flag)
+	{
+		view.setScrollBeginDragEventEnable(flag);
+	}
+
+	@HippyControllerProps(name = "onScrollEndDrag", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+	public void setScrollEndDragEventEnable(HippyScrollView view, boolean flag)
+	{
+		view.setScrollEndDragEventEnable(flag);
+	}
+
+	@HippyControllerProps(name = "onMomentumScrollBegin", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+	public void setMomentumScrollBeginEventEnable(HippyScrollView view, boolean flag)
+	{
+		view.setMomentumScrollBeginEventEnable(flag);
+	}
+
+	@HippyControllerProps(name = "onMomentumScrollEnd", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+	public void setMomentumScrollEndEventEnable(HippyScrollView view, boolean flag)
+	{
+		view.setMomentumScrollEndEventEnable(flag);
+	}
+
+	@HippyControllerProps(name = "onScrollAnimationEnd", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+	public void setScrollAnimationEndEventEnable(HippyScrollView view, boolean flag)
+	{
+//		view.setScrollAnimationEndEventEnable(flag);
+	}
+
+	@HippyControllerProps(name = "flingEnabled", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = true)
+	public void setFlingEnabled(HippyScrollView view, boolean flag)
+	{
+		view.setFlingEnabled(flag);
+	}
+
+	@HippyControllerProps(name = "contentOffset4Reuse")
+	public void setContentOffset4Reuse(HippyScrollView view, HippyMap offsetMap)
+	{
+		view.setContentOffset4Reuse(offsetMap);
+	}
+
+	@HippyControllerProps(name = "pagingEnabled", defaultType = HippyControllerProps.BOOLEAN, defaultBoolean = false)
+	public void setPagingEnabled(HippyScrollView view, boolean pagingEnabled)
+	{
+		view.setPagingEnabled(pagingEnabled);
+	}
+
+	@HippyControllerProps(name = "scrollEventThrottle", defaultType = HippyControllerProps.NUMBER, defaultNumber = 30.0D)
+	public void setScrollEventThrottle(HippyScrollView view, int scrollEventThrottle)
+	{
+		view.setScrollEventThrottle(scrollEventThrottle);
+	}
+
+	@HippyControllerProps(name = "scrollMinOffset", defaultType = HippyControllerProps.NUMBER, defaultNumber = 5)
+	public void setScrollMinOffset(HippyScrollView view, int scrollMinOffset)
+	{
+		view.setScrollMinOffset(scrollMinOffset);
+	}
+
+	@Override
+	public void dispatchFunction(View view, String functionName, HippyArray args) {
+		super.dispatchFunction((ViewGroup) view, functionName, args);
+		if(view instanceof  HippyScrollView)
+		{
+
+			if (TextUtils.equals(SCROLL_TO, functionName))
+			{
+				int destX = Math.round(PixelUtil.dp2px(args.getDouble(0)));
+				int destY = Math.round(PixelUtil.dp2px(args.getDouble(1)));
+				boolean animated = args.getBoolean(2);
+
+				if (animated)
+				{
+					((HippyScrollView)view).callSmoothScrollTo(destX, destY,0);//用默认的动画事件
+				}
+				else
+				{
+					view.scrollTo(destX, destY);
+				}
+			}
+			if (TextUtils.equals(SCROLL_TO_WITHOPTIONS, functionName) && args != null && args.size() > 0)
+			{
+				HippyMap hippyMap = args.getMap(0); //取第一个元素
+				int destX = Math.round(PixelUtil.dp2px(hippyMap.getInt("x")));
+				int destY = Math.round(PixelUtil.dp2px(hippyMap.getInt("y")));
+				int duration = hippyMap.getInt("duration");
+				if(duration > 0 )
+				{
+					((HippyScrollView)view).callSmoothScrollTo(destX, destY,duration);//用默认的动画事件
+				}
+				else
+				{
+					view.scrollTo(destX, destY);
+				}
+			}
+		}
+	}
+
+  @Override
+  public void dispatchFunction(View view, String functionName, HippyArray params, Promise promise) {
+    if (TextUtils.equals("getCurrentIndex", functionName)) {
+      if (view instanceof ICoverFlow && promise != null) {
+        ICoverFlow cView = (ICoverFlow) view;
+        int index = cView.getCurrentIndex();
+        HippyMap resultMap = new HippyMap();
+        resultMap.pushInt("index", index);
+        promise.resolve(resultMap);
+      }
+      return;
+    }
+    super.dispatchFunction(view, functionName, params, promise);
+  }
+
+  @HippyControllerProps(name = "autoScrollInterval", defaultType = HippyControllerProps.NUMBER,defaultNumber = 0)
+  public void setAutoScrollInterval(HippyScrollView view, int interval){
+    if (view instanceof ICoverFlow) {
+      ((ICoverFlow) view).setAutoScrollInterval(interval);
+    }
+  }
+
+  @HippyControllerProps(name = "zoomInValue", defaultType = HippyControllerProps.NUMBER,defaultNumber = 0)
+  public void setZoomInValue(HippyScrollView view, float value){
+    if (view instanceof ICoverFlow) {
+      ((ICoverFlow) view).setZoomInValue(value);
+    }
+  }
+
+
+}

package/rules/.source/hippy/extend_views/EngineRootView.java

@@ -0,0 +1,125 @@
+package com.tencent.extend.views;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.os.Build;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.RequiresApi;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.widget.FrameLayout;
+
+import com.tencent.mtt.hippy.HippyInstanceContext;
+import com.tencent.mtt.hippy.utils.PixelUtil;
+
+public class EngineRootView extends FrameLayout {
+
+  private static int translateX = 0;
+  private static int translateY = 0;
+
+  int overrideWidth = 0;
+  int overrideHeight = 0;
+
+  public EngineRootView(@NonNull Context context) {
+    super(context);
+    init();
+  }
+
+  public EngineRootView(@NonNull Context context, @Nullable AttributeSet attrs) {
+    super(context, attrs);
+    init();
+  }
+
+  public EngineRootView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
+    super(context, attrs, defStyleAttr);
+    init();
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+  public EngineRootView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+    super(context, attrs, defStyleAttr, defStyleRes);
+    init();
+  }
+
+  void init(){
+//    Log.i("EngineRootView","PixelUtil.getsScreenAdaptType() : "+PixelUtil.getsScreenAdaptType());
+//    Toast.makeText(getContext(), "width:"+PixelUtil.getScreenWidth()+",height:"+PixelUtil.getScreenHeight()+",ratio:"+PixelUtil.getScreenAspectRatio(), Toast.LENGTH_LONG).show();
+    if (PixelUtil.getsScreenAdaptType() == PixelUtil.SCREEN_ADAPT_TYPE_SCALE_WIDTH) {
+      try {
+        Activity activity;
+        if(getContext() instanceof Activity) {
+          activity = (Activity) getContext();
+        }else if(getContext() instanceof HippyInstanceContext) {
+          activity = (Activity) ((HippyInstanceContext) getContext()).getBaseContext();
+        }else {
+          activity = null;
+          Log.w("EngineRootView ","screen adapter error cant find activity context:"+getContext());
+          return;
+        }
+//        Log.i("EngineRootView"," base context:"+activity);
+        if(activity != null){
+//          int oldWidth = PixelUtil.getScreenWidth();
+//          int oldHeight = PixelUtil.getScreenHeight();
+          PixelUtil.adjustScreenSizeByActivity(activity);
+//          Log.i("EngineRootView"," after adjustScreenSizeByActivity screenWidth:"+PixelUtil.getScreenWidth()
+//            +" screenHeight:"+PixelUtil.getScreenHeight()+",oldWidth:"+oldWidth+",oldHeight:"+oldHeight);
+        }
+        final float currentAspectRatio = PixelUtil.getScreenAspectRatio();
+        //因为当前适配比例是16/9,如果不是16/9，则将页面整体居中
+        if (currentAspectRatio > PixelUtil.ASPECT_RATIO_16_9) {//相对16：9偏宽
+          overrideHeight = PixelUtil.getScreenHeight(); // 1080
+          float rate = PixelUtil.getDevHeightF() / PixelUtil.getScreenHeight(); //1.00f
+          overrideWidth = (int) (PixelUtil.getDevWidthF() / rate);
+          translateX = (int) ((PixelUtil.getScreenWidth() - overrideWidth) * 0.5f);
+          //1.0465
+//        setBackgroundColor(Color.GREEN);
+        } else if (currentAspectRatio < PixelUtil.ASPECT_RATIO_16_9) {//相对16：9偏长
+          overrideWidth = PixelUtil.getScreenWidth();
+          float rate = PixelUtil.getDevWidthF() / PixelUtil.getScreenWidth();
+          overrideHeight = (int) (PixelUtil.getDevHeightF() / rate);
+          translateY = (int) ((PixelUtil.getScreenHeight() - overrideHeight) * 0.5f);
+//        setBackgroundColor(Color.GREEN);
+        }
+      }catch (Throwable t){
+        t.printStackTrace();
+        Log.e("EngineRootView","init error:"+t.getMessage());
+      }
+    }
+    Log.i("EngineRootView","init overrideWidth:"+overrideWidth+" overrideHeight:"+overrideHeight+" translateX:"+translateX+" translateY:"+translateY);
+  }
+
+  public static int getScreenTranslateX() {
+    return translateX;
+  }
+
+  public static int getScreenTranslateY() {
+    return translateY;
+  }
+
+
+//  @Override
+//  protected void dispatchDraw(Canvas canvas) {
+//    if (translateX != 0 || translateY != 0) {
+//      canvas.save();
+//      canvas.translate(translateX,translateY);
+//      super.dispatchDraw(canvas);
+//      canvas.restore();
+//    }else{
+//      super.dispatchDraw(canvas);
+//    }
+//  }
+
+  @Override
+  public String toString() {
+    return "EngineRootView{" +
+      "translateX=" + translateX +
+      ", translateY=" + translateY +
+      ", overrideWidth=" + overrideWidth +
+      ", overrideHeight=" + overrideHeight +
+      ", super=" + super.toString() +
+      '}';
+  }
+}

package/rules/.source/hippy/extend_views/ExtendTag.java

@@ -0,0 +1,83 @@
+package com.tencent.extend.views;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.view.View;
+
+import com.tencent.mtt.hippy.R;
+import com.tencent.mtt.hippy.common.HippyMap;
+
+
+import java.util.HashMap;
+
+public class ExtendTag {
+
+
+  public String nodeClassName;
+  public String sid;
+  public String nextFocusUpSID;
+  public String nextFocusDownSID;
+  public String nextFocusLeftSID;
+  public String nextFocusRightSID;
+  public HippyMap nextFocusFocusName;
+  public String name;
+  public int pendingBackGroundColor = -1;
+
+  public HashMap<String,Object> extra;
+
+  public static void putExtraValue(@NonNull View view, @NonNull String key, @NonNull Object value){
+    ExtendTag tag = obtainExtendTag(view);
+    if(tag.extra == null){
+      tag.extra = new HashMap<>();
+    }
+    tag.extra.put(key,value);
+  }
+
+  public Object getExtraValue(@NonNull String key){
+    if(extra == null){
+      return null;
+    }
+    return extra.get(key);
+  }
+
+  public boolean getBooleanExtraValue(@NonNull String key){
+    Object value = getExtraValue(key);
+    if(value instanceof Boolean){
+      return (Boolean) value;
+    }
+    return false;
+  }
+
+
+  public static void putTag(View view, @Nullable ExtendTag tag){
+    view.setTag(R.id.tag_view_extend_4tv,tag);
+  }
+
+
+  public static @NonNull
+  ExtendTag obtainExtendTag(@NonNull View view){
+    Object tag = view.getTag(R.id.tag_view_extend_4tv);
+    if(tag instanceof ExtendTag){
+      return (ExtendTag) tag;
+    }else{
+      tag = new ExtendTag();
+      putTag(view, (ExtendTag) tag);
+    }
+    return (ExtendTag) tag;
+  }
+
+  public static @Nullable
+  ExtendTag getExtendTag(@Nullable View view){
+    if (view == null) {
+      return null;
+    }
+    Object tag = view.getTag(R.id.tag_view_extend_4tv);
+    if(tag instanceof ExtendTag){
+      return (ExtendTag) tag;
+    }else{
+      return null;
+    }
+  }
+
+
+}

package/rules/.source/hippy/extend_views/FocusSearchHelper.java

@@ -0,0 +1,124 @@
+package com.tencent.extend.views;
+
+
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.tencent.extend.views.fastlist.FastPendingView;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.uimanager.InternalExtendViewUtil;
+import com.tencent.mtt.hippy.utils.ExtendUtil;
+
+import java.util.ArrayList;
+
+public class FocusSearchHelper {
+
+  private final ViewGroup viewGroup;
+
+  private HippyMap firstFocusChildMap;
+  private boolean isFindAtStart = false;
+  public final static String TAG = "DebugFocusParent";
+  private static boolean DEBUG =  false;
+
+  public FocusSearchHelper(ViewGroup viewGroup) {
+    this.viewGroup = viewGroup;
+  }
+
+
+  public void setFindAtStart(boolean findAtStart) {
+    isFindAtStart = findAtStart;
+    if(DEBUG) {
+      Log.i(TAG,"setFindAtStart :"+findAtStart+",view:"+ExtendUtil.debugViewLite(viewGroup));
+    }
+  }
+
+  public void setFirstFocusChildMap(HippyMap firstFocusChildMap) {
+    this.firstFocusChildMap = firstFocusChildMap;
+    if(DEBUG) {
+      Log.i(TAG,"setFirstFocusChildMap :"+firstFocusChildMap+",view:"+ExtendUtil.debugViewLite(viewGroup));
+    }
+  }
+
+  public static  View findSpecifiedNext(ViewGroup parent,HippyMap map,int direction){
+    if (map == null || parent == null) {
+      return null;
+    }
+    View next = null;
+    final Object value = map.get(ExtendUtil.getDirectionName(direction));
+    if(DEBUG) {
+      Log.i(TAG,"findSpecifiedNext map:"+map+",value:"+value+",parent:"+ExtendUtil.debugViewLite(parent));
+    }
+    if (value instanceof Integer) {
+      //位置,childIndex
+      int index = (int) value;
+      if(parent instanceof FastPendingView){
+        next = ((FastPendingView) parent).findViewByPosition(index);
+      }else{
+        if (parent.getChildCount() > index && index > -1) {
+           next =  parent.getChildAt(index);
+        }
+      }
+      if(DEBUG) {
+        if (next != null) {
+          Log.e(TAG,"findSpecifiedNext by index:"+index+",next:"+ExtendUtil.debugViewLite(next)+",parent:"+ExtendUtil.debugViewLite(parent));
+        } else {
+          Log.i(TAG,"findSpecifiedNext by index:"+index+",next:"+null);
+        }
+      }
+
+    } else if (value instanceof String) {
+        next = ExtendUtil.findViewBySID((String) value,parent);
+        if(DEBUG) {
+          Log.i(TAG,"findSpecifiedNext by sid:"+value+",next:"+ExtendUtil.debugViewLite(next));
+        }
+    }
+    return next;
+  }
+
+
+  public View findFirstFocusChildByDirection(int direction){
+    View nextChild = null;
+    nextChild = findSpecifiedNext(viewGroup,firstFocusChildMap,direction);
+    if(DEBUG) {
+      if (firstFocusChildMap != null) {
+        Log.i(TAG,"findFirstFocusChildByDirection firstFocusChildMap :"+firstFocusChildMap+",viewGroup:"+ExtendUtil.debugViewLite(viewGroup));
+      }
+    }
+    if (nextChild == null){
+      if(isFindAtStart){
+        if (viewGroup instanceof FastPendingView) {
+          nextChild = ((FastPendingView) viewGroup).findFirstFocusByDirection(direction);
+          if(DEBUG) {
+            Log.i(TAG, "findFirstFocusChildByDirection from  FastPendingView :" + ExtendUtil.debugViewLite(nextChild) + ",isFindAtStart:" + isFindAtStart);
+          }
+        }
+      }
+    }else{
+      if(DEBUG) {
+        Log.e(TAG,"findFirstFocusChildByDirection specified :"+ExtendUtil.debugViewLite(nextChild));
+      }
+    }
+    return nextChild;
+  }
+
+  public boolean addFocusables(ArrayList<View> views, int direction){
+    if (viewGroup == null || viewGroup.hasFocus()) {
+      return false;
+    }
+    View next = findFirstFocusChildByDirection(direction);
+    if (InternalExtendViewUtil.testFocusable(next)) {
+      if(DEBUG) {
+        Log.e(TAG,"addFocusables view :"+ExtendUtil.debugViewLite(next));
+      }
+      views.add(next);
+      return true;
+    }else{
+      if(DEBUG) {
+        Log.i(TAG,"addFocusables view :"+ExtendUtil.debugViewLite(null));
+      }
+    }
+    return false;
+  }
+
+}

package/rules/.source/hippy/extend_views/IRecyclerItemView.java

@@ -0,0 +1,12 @@
+package com.tencent.extend.views;
+
+import android.view.View;
+
+public interface IRecyclerItemView {
+  void onCreate(View rootList);
+  void onBind(View rootList, int position, Object item);
+  void onAttachToWindow(View rootList, int position, Object item);
+  void onDetachFromWindow(View rootList, int position, Object item);
+  void onUnBind(View rootList, int position, Object item);
+  void setJSEventViewID(int JSEventViewID);
+}

package/rules/.source/hippy/extend_views/JSEventHandleView.java

@@ -0,0 +1,5 @@
+package com.tencent.extend.views;
+
+public interface JSEventHandleView {
+  void setJSEventViewID(int JSEventViewID);
+}

package/rules/.source/hippy/extend_views/MarqueeRelayManager.java

@@ -0,0 +1,133 @@
+package com.tencent.extend.views;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MarqueeRelayManager {
+  private static MarqueeRelayManager instance;
+  private final Map<String, List<MarqueeRelayTextView>> groups = new HashMap<>();
+  private final Map<String, Boolean> groupBusyMap = new HashMap<>();
+  private final Map<String, Boolean> activeGroups = new HashMap<>();
+  // 焦点计数器，用于判断组内是否还有焦点
+  private final Map<String, Integer> groupFocusCount = new HashMap<>();
+
+  public static synchronized MarqueeRelayManager getInstance() {
+    if (instance == null) instance = new MarqueeRelayManager();
+    return instance;
+  }
+
+  // 注册组件到指定组
+  public void register(String key, MarqueeRelayTextView view) {
+    if (key == null) return;
+    if (!groups.containsKey(key)) {
+      groups.put(key, new ArrayList<>());
+      groupBusyMap.put(key, false);
+      activeGroups.put(key, false);
+      groupFocusCount.put(key, 0);
+    }
+    List<MarqueeRelayTextView> list = groups.get(key);
+    if (!list.contains(view)) {
+      list.add(view);
+      // 确保按 Index 升序排列
+      Collections.sort(list, (v1, v2) -> Integer.compare(v1.getGroupIndex(), v2.getGroupIndex()));
+    }
+  }
+
+  // 当组件获得焦点时调用
+  public void onFocusGain(String key, MarqueeRelayTextView view) {
+      if (key == null) return;
+      Integer count = groupFocusCount.get(key);
+      if (count == null) count = 0;
+      groupFocusCount.put(key, count + 1);
+      
+      // 只要有焦点，就尝试启动（如果已经在跑，startCycle 会忽略）
+      startCycle(key, view);
+  }
+
+  // 当组件失去焦点时调用
+  public void onFocusLost(String key) {
+      if (key == null) return;
+      Integer count = groupFocusCount.get(key);
+      if (count == null || count <= 0) return;
+      
+      int newCount = count - 1;
+      groupFocusCount.put(key, newCount);
+      
+      // 如果没有任何焦点了，停止循环
+      if (newCount == 0) {
+          stopCycle(key);
+      }
+  }
+
+  // 手动请求启动（用于 setSelected 等非焦点场景）
+  public void requestRelay(String key, MarqueeRelayTextView view) {
+      // 视为一次临时的焦点获取？或者直接启动
+      // 为了兼容 setSelected 逻辑，我们直接启动，不计入 FocusCount
+      // 但 setSelected(false) 必须负责停止。
+      // 这是一个混合模式，比较复杂。
+      // 简单起见，requestRelay 只负责 startCycle，不涉及 focus 计数。
+      // 但这意味着 setSelected(false) 必须显式调用 stopCycle，或者我们假设 setSelected 也会触发 focus 变化（如果 View 是 focusable 的）。
+      startCycle(key, view);
+  }
+
+  public void startCycle(String key, MarqueeRelayTextView triggerView) {
+      if (key == null) return;
+      activeGroups.put(key, true);
+      Boolean isBusy = groupBusyMap.get(key);
+      if (isBusy != null && !isBusy) {
+          groupBusyMap.put(key, true);
+          triggerView.startRelayAnimation();
+      }
+  }
+
+  public void stopCycle(String key) {
+      if (key == null) return;
+      activeGroups.put(key, false);
+      List<MarqueeRelayTextView> list = groups.get(key);
+      if (list != null) {
+          for (MarqueeRelayTextView view : list) {
+              view.stopRelay();
+          }
+      }
+      groupBusyMap.put(key, false);
+      // 注意：stopCycle 不重置 focusCount，因为可能是手动停止但焦点还在
+      // 但如果是因为 focusCount 归零调用的 stopCycle，那也没问题。
+  }
+
+  // 调度下一个需要滚动的组件
+  public void dispatchNext(String key, int currentIndex) {
+    Boolean isActive = activeGroups.get(key);
+    if (isActive == null || !isActive) {
+        groupBusyMap.put(key, false);
+        return;
+    }
+    List<MarqueeRelayTextView> list = groups.get(key);
+    if (list == null || list.isEmpty()) {
+      groupBusyMap.put(key, false);
+      return;
+    }
+
+    int currentPosInList = -1;
+    for (int i = 0; i < list.size(); i++) {
+      if (list.get(i).getGroupIndex() == currentIndex) {
+        currentPosInList = i;
+        break;
+      }
+    }
+
+    MarqueeRelayTextView nextView = list.get((currentPosInList + 1) % list.size());
+    nextView.startRelayAnimation();
+  }
+
+  public void unregister(String key, MarqueeRelayTextView view) {
+    if (key != null && groups.containsKey(key)) {
+      groups.get(key).remove(view);
+      // 如果移除的 View 占用了 FocusCount，应该减掉吗？
+      // 很难判断它是否持有焦点。
+      // 但 View destroy 时通常会先 lose focus。
+    }
+  }
+}