@quicktvui/ai 1.0.7 → 1.0.8

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

@@ -0,0 +1,218 @@
+package com.tencent.extend.views;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.drawable.ClipDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.GradientDrawable;
+import android.graphics.drawable.LayerDrawable;
+import android.graphics.drawable.StateListDrawable;
+import android.os.Build;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.ProgressBar;
+import android.widget.SeekBar;
+
+import com.tencent.mtt.hippy.R;
+import com.tencent.mtt.hippy.annotation.HippyController;
+import com.tencent.mtt.hippy.annotation.HippyControllerProps;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.dom.node.NodeProps;
+import com.tencent.mtt.hippy.uimanager.HippyViewBase;
+import com.tencent.mtt.hippy.uimanager.HippyViewEvent;
+import com.tencent.mtt.hippy.uimanager.NativeGestureDispatcher;
+
+import java.lang.reflect.Field;
+
+@HippyController(name = "SeekBar")
+public class SeekBarViewController extends ProgressBarViewController {
+
+  private HippyViewEvent mEvent;
+
+
+  @Override
+  protected View createViewImpl(Context context) {
+    return null;
+  }
+
+  private HippyViewEvent getSeekEvent(){
+    if(mEvent == null){
+      mEvent = new HippyViewEvent("onSeekBarChange");
+    }
+    return mEvent;
+  }
+
+
+  protected Drawable crateThumbDrawable(Context context,HippyMap iniProps){
+    return (StateListDrawable) context.getResources().getDrawable(R.drawable.seek_thumb);
+  }
+
+  protected LayerDrawable crateProgressDrawable(Context context,HippyMap iniProps){
+    return (LayerDrawable) context.getResources().getDrawable(R.drawable.player_seekbar);
+  }
+
+  @HippyControllerProps(name = "listenProgress", defaultType = HippyControllerProps.BOOLEAN)
+  public void setListenProgress(ProgressBar pb,boolean listen){
+    if(pb instanceof SeekBarView) {
+      ((SeekBarView) pb).setListenProgressEvent(listen);
+    }
+  }
+
+  @HippyControllerProps(name = "interceptKeyEvent", defaultType = HippyControllerProps.BOOLEAN)
+  public void setInterceptKeyEvent(ProgressBar pb,boolean listen){
+    if(pb instanceof SeekBarView) {
+      ((SeekBarView) pb).setInterceptKeyEvent(listen);
+    }
+  }
+
+
+
+  @Override
+  protected View createViewImpl(Context context, HippyMap iniProps) {
+    final SeekBarView seekBar = new SeekBarView(context);
+    final LayerDrawable drawable = crateProgressDrawable(context,iniProps);
+    fixDrawable(drawable,iniProps);
+    seekBar.setProgressDrawable(drawable);
+    Drawable thumb = crateThumbDrawable(context,iniProps);
+
+    seekBar.setThumb(thumb);
+
+    seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
+      @Override
+      public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+        if(seekBar instanceof SeekBarView && ((SeekBarView) seekBar).isListenProgressEvent()) {
+          HippyMap hippyMap = new HippyMap();
+          hippyMap.pushInt("progress", progress);
+          hippyMap.pushBoolean("fromUser", fromUser);
+          getSeekEvent().send(seekBar, hippyMap);
+        }
+      }
+
+      @Override
+      public void onStartTrackingTouch(SeekBar seekBar) {
+
+      }
+
+      @Override
+      public void onStopTrackingTouch(SeekBar seekBar) {
+
+      }
+    });
+
+    if(iniProps.containsKey("thumbSize")){
+        int size = iniProps.getInt("thumbSize");
+        thumb.setBounds(0,0,size,size);
+    }
+    return seekBar;
+  }
+
+  @Override
+  protected void updateExtra(View view, Object object) {
+    super.updateExtra(view, object);
+  }
+
+  private void fixDrawable(LayerDrawable drawable, HippyMap map){
+    /*
+     * backGroundColor:
+     * startColor:
+     * endColor:
+     * cornerRadius:
+     * secondStartColor:
+     * secondEndColor:
+     */
+
+    if(map.containsKey("backGroundColor")){
+      //bg
+      GradientDrawable bg = (GradientDrawable) drawable.getDrawable(0);
+      int bgColor = Color.parseColor(map.getString("backGroundColor"));
+      bg.setColor(bgColor);
+    }
+
+    if(map.containsKey("cornerRadius")){
+      for(int i = 0; i < drawable.getNumberOfLayers(); i++){
+        final Drawable d = drawable.getDrawable(i);
+        if(d instanceof GradientDrawable) {
+          ((GradientDrawable) d).setCornerRadius(map.getInt("cornerRadius"));
+        }else if(d instanceof ClipDrawable){
+          GradientDrawable gd =  getDrawableFromClipDrawable((ClipDrawable) d);
+          if(gd != null){
+            gd.setCornerRadius(map.getInt("cornerRadius"));
+          }
+        }
+      }
+    }
+
+    if(map.containsKey("secondColor")){
+      ClipDrawable clipDrawable = (ClipDrawable) drawable.getDrawable(1);
+      int color = Color.parseColor(map.getString("secondColor"));
+      GradientDrawable gd = getDrawableFromClipDrawable(clipDrawable);
+      if(gd != null) {
+        gd.setColor(color);
+      }
+    }
+
+    if(map.containsKey("startColor")){
+      ClipDrawable clipDrawable = (ClipDrawable) drawable.getDrawable(2);
+      GradientDrawable gd = getDrawableFromClipDrawable(clipDrawable);
+      if(gd != null) {
+        int startColor = Color.parseColor(map.getString("startColor"));
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN && map.containsKey("endColor")) {
+          int endColor = Color.parseColor(map.getString("endColor"));
+          int[] colors = new int[]{startColor, endColor};
+          gd.mutate();
+          gd.setColors(colors);
+        } else {
+          gd.setColor(startColor);
+        }
+      }
+    }
+
+  }
+
+  private GradientDrawable getDrawableFromClipDrawable(ClipDrawable clipDrawable){
+    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){
+      return (GradientDrawable) clipDrawable.getDrawable();
+    }else{
+      try {
+        Field field = clipDrawable.getClass().getSuperclass().getDeclaredField("mDrawable");
+        field.setAccessible(true);
+        Object o = new Object();
+        Log.d("hippy","o is :"+o);
+        Object r = field.get(o);
+        Log.d("hippy","r is :"+r);
+        return null;
+      }catch (Throwable t){
+        Log.e("hippy","SeekBarViewController getDrawableFromClipDrawable fail ANDROID_VERSION:"+Build.VERSION.SDK_INT);
+        return null;
+      }
+    }
+  }
+
+
+  @Override
+  public void setProgress(ProgressBar pb, int progress) {
+    super.setProgress(pb, progress);
+  }
+
+
+  @Override
+  public void setMaxProgress(ProgressBar pb, int max) {
+    super.setMaxProgress(pb, max);
+  }
+
+  @Override
+  public void setSecondProgress(ProgressBar pb, int progress) {
+    super.setSecondProgress(pb, progress);
+  }
+
+
+  @HippyControllerProps(name = "keyProgressIncrement", defaultType = HippyControllerProps.NUMBER)
+  public void setKeyProgressIncrement(ProgressBar pb,int number){
+    if(pb instanceof SeekBarView) {
+      ((SeekBarView) pb).setKeyProgressIncrement(number);
+    }
+  }
+
+
+}

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

@@ -0,0 +1,149 @@
+package com.tencent.extend.views;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.util.Log;
+import android.view.View;
+
+import com.tencent.extend.RenderUtil;
+import com.tencent.mtt.hippy.common.HippyMap;
+
+import com.tencent.mtt.hippy.utils.LogUtils;
+import com.tencent.mtt.hippy.views.image.HippyImageView;
+import com.tencent.mtt.hippy.views.view.HippyViewGroup;
+
+import java.util.HashMap;
+
+public class StateImageView extends HippyViewGroup {
+  private boolean needUpdate = true;
+
+  private HashMap<Integer,HippyImageView> mChildren;
+  private HashMap<Integer,String> mStateUrl;
+
+  int imgLoadDelay = 0;
+
+  public StateImageView(Context context) {
+    super(context);
+  }
+
+  static String NotNullStr(String str){
+    if (str == null) {
+      return "";
+    }
+    return str;
+  }
+
+  public void setImgLoadDelay(int imgLoadDelay) {
+    this.imgLoadDelay = imgLoadDelay;
+  }
+
+  private void clearChildren(){
+    removeAllViews();
+    if (mChildren != null) {
+      mChildren.clear();
+      mChildren = null;
+    }
+  }
+
+  public void setStateSrc(HippyMap  map){
+    boolean noChange = false;
+    int oldSize = mStateUrl != null ? mStateUrl.size() : 0;
+    int newSize = map != null ? map.size() : 0;
+    if (oldSize == newSize && newSize > 0) {
+      //全部相同就是没有变化
+      noChange = !NotNullStr(map.getString("focused")).equals(mStateUrl.get(android.R.attr.state_focused))
+        && !NotNullStr(map.getString("normal")).equals(mStateUrl.get(-1))
+        && !NotNullStr(map.getString("selected")).equals(mStateUrl.get(android.R.attr.state_selected));
+    }
+    if (!noChange) {
+      clearChildren();
+    }else{
+      if (LogUtils.isDebug()) {
+        Log.w(TAG,"return on noChanged");
+      }
+    }
+    if (map == null || map.size() < 1) {
+      this.mStateUrl = null;
+    }else{
+      if (mStateUrl == null) {
+        mStateUrl = new HashMap<>();
+      }else{
+        mStateUrl.clear();
+      }
+      for(String key : map.keySet()){
+        switch (key){
+          case "focused":
+            mStateUrl.put(android.R.attr.state_focused,map.getString(key));
+            break;
+          case "normal":
+            mStateUrl.put(-1,map.getString(key));
+            break;
+          case "selected":
+            mStateUrl.put(android.R.attr.state_selected,map.getString(key));
+            break;
+        }
+      }
+    }
+    if (!noChange) {
+      markUpdate();
+    }
+  }
+
+  @Override
+  protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+    super.onSizeChanged(w, h, oldw, oldh);
+    layoutChildren();
+    if (getChildCount() > 0 && w > 0 && h > 0) {
+      this.markUpdate();
+    }
+  }
+
+
+  public void markUpdate(){
+    this.needUpdate = true;
+    this.invalidate();
+  }
+
+  @Override
+  protected void dispatchDraw(Canvas canvas) {
+    super.dispatchDraw(canvas);
+    if (needUpdate) {
+      needUpdate = false;
+      crateChildrenIfNeed();
+    }
+  }
+
+  void crateChildrenIfNeed(){
+    if (mStateUrl != null && getWidth() > 0 && getHeight() > 0) {
+      if (mChildren == null) {
+        mChildren = new HashMap<>();
+        for(int state : mStateUrl.keySet()){
+          HippyImageView view = new HippyImageView(getContext());
+          view.setFocusable(false);
+          view.setFocusableInTouchMode(false);
+          view.setDuplicateParentStateEnabled(true);
+          //view.refreshDrawableState();
+          if (imgLoadDelay > 0) {
+            view.setDelayLoad(imgLoadDelay);
+          }
+          addView(view);
+          view.setShowOnState(new int[]{state});
+          RenderUtil.reLayoutView(view,0,0,getWidth(),getHeight());
+          view.setUrl(mStateUrl.get(state));
+          mChildren.put(state,view);
+        }
+        refreshDrawableState();
+      }
+    }
+
+  }
+  void layoutChildren() {
+    for(int i = 0; i < getChildCount(); i ++){
+      View v = getChildAt(i);
+      RenderUtil.reLayoutView(v,0,0,getWidth(),getHeight());
+    }
+
+  }
+
+
+}

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

@@ -0,0 +1,34 @@
+package com.tencent.extend.views;
+
+import android.content.Context;
+import android.view.View;
+
+import com.tencent.mtt.hippy.annotation.HippyController;
+import com.tencent.mtt.hippy.annotation.HippyControllerProps;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.views.view.HippyViewGroupController;
+
+@HippyController(name = "StateImageView")
+public class StateImageViewController extends HippyViewGroupController {
+  @Override
+  protected View createViewImpl(Context context) {
+    return new StateImageView(context);
+  }
+
+  @HippyControllerProps(name = "src", defaultType = HippyControllerProps.MAP)
+  public void setStateDrawable(View tv, HippyMap map) {
+    if (tv instanceof StateImageView) {
+      ((StateImageView) tv).setStateSrc(map);
+    }
+  }
+
+  /*** zhaopeng add8***/
+  @HippyControllerProps(name = "loadImgDelay", defaultType = HippyControllerProps.NUMBER, defaultNumber = -1)
+  public void setDelayLoadImage(View tv, int delay)
+  {
+    if (tv instanceof StateImageView) {
+      ((StateImageView) tv).setImgLoadDelay(delay);
+    }
+  }
+
+}

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

@@ -0,0 +1,314 @@
+package com.tencent.extend.views;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.text.Layout;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+
+import com.tencent.extend.RenderUtil;
+import com.tencent.mtt.hippy.HippyEngineContext;
+import com.tencent.mtt.hippy.HippyInstanceContext;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.uimanager.HippyViewBase;
+import com.tencent.mtt.hippy.uimanager.NativeGestureDispatcher;
+import com.tencent.mtt.hippy.utils.ExtendUtil;
+import com.tencent.mtt.hippy.utils.LogUtils;
+
+import java.util.List;
+
+
+public class TVButtonView extends FrameLayout implements HippyViewBase {
+
+    TextView tx;
+
+    Drawable drawable;
+    Drawable drawableFocused;
+    Rect padding = new Rect();
+
+    RectF markRect;
+
+    Paint mPaint;
+
+    int markWidth = 36;
+    int markHeight = 6;
+    int rounder = 4;
+    int markMargin = 2;
+
+    boolean enableMark = false;
+    boolean needUpdate = true;
+    boolean isAutoWidth = false;
+
+    public static final String TAG = "TVButtonViewLog";
+
+    public TVButtonView(@NonNull Context context,HippyMap iniProps) {
+        super(context);
+
+        tx = new TextView(getContext());
+        tx.setDuplicateParentStateEnabled(true);
+        tx.setSingleLine();
+//        tx.setEllipsize(TextUtils.TruncateAt);
+
+        setClipChildren(false);
+//        setBackgroundResource(R.drawable.item_background);
+        if(iniProps != null && iniProps.containsKey("autoWidth")){
+          this.isAutoWidth = true;
+        }
+        LayoutParams lp = new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
+        lp.gravity = Gravity.CENTER;
+        tx.setLayoutParams(new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,ViewGroup.LayoutParams.WRAP_CONTENT));
+        addView(tx,lp);
+
+
+        mPaint = new Paint();
+        mPaint.setAntiAlias(true);
+        mPaint.setColor(Color.WHITE);
+
+    }
+
+    public void setColorStateList(ColorStateList color){
+        this.tx.setTextColor(color);
+        invalidate();
+    }
+
+    public void setColorStateListMap(HippyMap map){
+        final ColorStateList color = TemplateUtil.createColorStateListByMap(map);
+        this.tx.setTextColor(color);
+        invalidate();
+    }
+
+    public void setTextSize(int textSize){
+        tx.setTextSize(textSize);
+        updateSize();
+    }
+
+    public void setMarkWidth(int width){
+        this.markWidth = width;
+        updateSize();
+    }
+
+    public void setMarkHeight(int markHeight) {
+        this.markHeight = markHeight;
+        updateSize();
+    }
+
+    public void setMarkMargin(int margin) {
+        this.markMargin = margin;
+        updateSize();
+    }
+
+  @Override
+  public void requestLayout() {
+    super.requestLayout();
+    RenderUtil.requestNodeLayout(this);
+  }
+
+  @Override
+  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+    super.onLayout(changed, left, top, right, bottom);
+    //CustomControllerHelper.updateLayout(tx,left, top, right - left, bottom - top);
+
+  }
+
+  public void setEnableMark(boolean enableMark) {
+        this.enableMark = enableMark;
+        if(enableMark) {
+            this.markRect = new RectF();
+        }else{
+            this.markRect = null;
+        }
+        updateSize();
+    }
+
+    public void setMarkRounder(int rounder) {
+        this.rounder = rounder;
+        invalidate();
+    }
+
+    public void setMarkColor(int color){
+        this.mPaint.setColor(color);
+        invalidate();
+    }
+//    public void setStateDrawable(@NotNull Drawable drawable) {
+//        this.drawable = drawable;
+//        drawable.setVisible(false,false);
+//        updateSize();
+//    }
+
+    public void setStateDrawableMap(HippyMap map) {
+        final List<? extends Drawable> list = TemplateUtil.createStateListDrawableByMap(map);
+        ///Log.d(TAG,"setStateDrawableMap :"+list);
+        if(list .size() == 2) {
+            this.drawable = list.get(0);
+            this.drawableFocused = list.get(1);
+        }
+        updateSize();
+    }
+
+
+    public void updateSize(){
+        this.needUpdate = true;
+        this.invalidate();
+    }
+
+    public void setBackgroundPadding(int[] padding){
+        if(padding != null && padding.length == 2){
+            final int h = padding[0];
+            final int v = padding[1];
+            this.padding = new Rect(-h,-v,h,v);
+        }else{
+            if(this.padding != null) {
+                this.padding.setEmpty();
+            }
+        }
+        updateSize();
+    }
+
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+
+
+        updateSize();
+    }
+
+    void validSize(){
+        if(needUpdate) {
+            needUpdate = false;
+            final int w = getWidth();
+            final int h = getHeight();
+            Log.d(TAG,"validSize w:"+w+",h:"+h);
+            if(drawable != null) {
+                drawable.setBounds(padding.left, padding.top, w + padding.right, h + padding.bottom);
+            }
+            if(drawableFocused != null){
+                drawableFocused.setBounds(padding.left, padding.top, w + padding.right, h + padding.bottom);
+            }
+            if(markRect != null){
+                if (w > 0 & h > 0) {
+                    int left = (int) ((w - markWidth) * 0.5f);
+                    int top = h + markMargin;
+                    markRect.set(left, top, left + markWidth, top + markHeight);
+                }
+            }
+            fixSize();
+        }
+
+    }
+
+    @Override
+    protected void dispatchDraw(Canvas canvas) {
+        validSize();
+        if(drawable != null && drawable.isVisible()) {
+            drawable.draw(canvas);
+        }
+        if(drawableFocused != null && drawableFocused.isVisible()){
+            drawableFocused.draw(canvas);
+        }
+        if(markRect != null && isSelected() && !isFocused()){
+            canvas.drawRoundRect(markRect,rounder,rounder,mPaint);
+        }
+        super.dispatchDraw(canvas);
+    }
+
+    @Override
+    protected void onFocusChanged(boolean gainFocus, int direction, @Nullable Rect previouslyFocusedRect) {
+        super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
+    }
+
+    @Override
+    protected void drawableStateChanged() {
+        super.drawableStateChanged();
+        refreshState();
+    }
+
+    protected void refreshState(){
+        final int[] state = getDrawableState();
+        if(isFocusable() || isDuplicateParentStateEnabled() ) {
+            final boolean focused = ExtendUtil.stateContainsAttribute(state, android.R.attr.state_focused);
+            Log.d(TAG,"refreshState focused:"+focused);
+            if(focused){
+                if(drawableFocused != null){
+                    drawableFocused.setVisible(true,false);
+                    invalidate();
+                }
+                if(drawable != null) {
+                    drawable.setVisible(false, false);
+                    invalidate();
+                }
+            }else{
+                if(drawable != null) {
+                    drawable.setVisible(true, false);
+                    invalidate();
+                }
+                if(drawableFocused != null){
+                    drawableFocused.setVisible(false,false);
+                    invalidate();
+                }
+            }
+        }
+    }
+
+
+    public void setText(String text){
+        tx.setText(text);
+        updateSize();
+    }
+
+
+    void fixSize(){
+      if(LogUtils.isDebug()){
+        Log.d(TAG,"fixSize text:"+tx.getText());
+      }
+      if(tx != null && isAutoWidth) {
+        final TextButtonNode node = (TextButtonNode) getHippyContext().getDomManager().getNode(getId());
+        if(node == null){
+          needUpdate = true;
+          return;
+        }
+        if(LogUtils.isDebug()){
+          Log.e(TAG,"fixSize measure getWidth:"+getWidth()+",node getPaddingWidth:"+node.getPaddingWidth()+",text:"+tx.getText());
+        }
+          int width;
+          if(TextUtils.isEmpty(tx.getText())){
+            width = 0;
+          }else{
+//            width = (int) tx.getPaint().measureText(tx.getText(), 0, tx.getText().length());
+            width = (int) Layout.getDesiredWidth(tx.getText(), 0, tx.getText().length(),tx.getPaint());
+          }
+          if(LogUtils.isDebug()){
+            Log.e(TAG,"fixSize measure width:"+width+",node:"+node+",text:"+tx.getText());
+          }
+          node.setTextWidth(width);
+          node.markUpdated();
+      }
+    }
+
+    HippyEngineContext getHippyContext(){
+      return ((HippyInstanceContext)getContext()).getEngineContext();
+    }
+
+    @Override
+    public NativeGestureDispatcher getGestureDispatcher() {
+        return null;
+    }
+
+    @Override
+    public void setGestureDispatcher(NativeGestureDispatcher dispatcher) {
+
+    }
+}