@quicktvui/ai 1.0.7 → 1.0.8

package/rules/.source/hippy/hippy_views/hippylist/RecyclerViewEventHelper.java

@@ -0,0 +1,394 @@
+/* Tencent is pleased to support the open source community by making Hippy available.
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tencent.mtt.hippy.views.hippylist;
+
+import static android.support.v7.widget.RecyclerView.SCROLL_STATE_DRAGGING;
+import static android.support.v7.widget.RecyclerView.SCROLL_STATE_IDLE;
+import static android.support.v7.widget.RecyclerView.SCROLL_STATE_SETTLING;
+
+import android.graphics.Rect;
+import android.support.annotation.NonNull;
+import android.support.v7.widget.OverPullHelper;
+import android.support.v7.widget.OverPullListener;
+import android.support.v7.widget.RecyclerView;
+import android.support.v7.widget.RecyclerView.OnScrollListener;
+import android.view.View;
+import android.view.View.OnAttachStateChangeListener;
+import android.view.View.OnLayoutChangeListener;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import android.view.ViewTreeObserver.OnPreDrawListener;
+import com.tencent.mtt.hippy.common.HippyMap;
+import com.tencent.mtt.hippy.uimanager.HippyViewEvent;
+import com.tencent.mtt.hippy.utils.LogUtils;
+import com.tencent.mtt.hippy.utils.PixelUtil;
+import com.tencent.mtt.hippy.views.list.HippyListItemView;
+import com.tencent.mtt.hippy.views.scroll.HippyScrollViewEventHelper;
+
+public class RecyclerViewEventHelper extends OnScrollListener implements OnLayoutChangeListener,
+    OnAttachStateChangeListener, OverPullListener {
+
+  public static final String EVENT_ON_END_REACHED = "onEndReached";
+  public static final String EVENT_ON_TOP_REACHED = "onTopReached";
+  public static final String INITIAL_LIST_READY = "initialListReady";
+  protected final HippyRecyclerView hippyRecyclerView;
+  private boolean scrollBeginDragEventEnable;
+  private boolean scrollEndDragEventEnable;
+  private HippyViewEvent onScrollDragEndedEvent;
+  private boolean momentumScrollBeginEventEnable;
+  private boolean momentumScrollEndEventEnable;
+  private HippyViewEvent onScrollFlingStartedEvent;
+  private HippyViewEvent onScrollFlingEndedEvent;
+  private int currentState;
+  protected boolean onScrollEventEnable = true;
+  private HippyViewEvent onScrollEvent;
+  private long lastScrollEventTimeStamp;
+  private int scrollEventThrottle;
+  private boolean exposureEventEnable;
+  private HippyViewEvent onScrollDragStartedEvent;
+
+  //initialListReady event
+  private boolean isInitialListReadyNotified = false;
+  private ViewTreeObserver viewTreeObserver;
+  private OnPreDrawListener preDrawListener;
+
+
+  public RecyclerViewEventHelper(HippyRecyclerView recyclerView) {
+    this.hippyRecyclerView = recyclerView;
+    hippyRecyclerView.addOnScrollListener(this);
+    hippyRecyclerView.addOnAttachStateChangeListener(this);
+    hippyRecyclerView.addOnLayoutChangeListener(this);
+    preDrawListener = new ViewTreeObserver.OnPreDrawListener() {
+      @Override
+      public boolean onPreDraw() {
+        notifyInitialListReady();
+        return true;
+      }
+    };
+  }
+
+  void notifyInitialListReady() {
+    if (canNotifyInit()) {
+      isInitialListReadyNotified = true;
+      viewTreeObserver.removeOnPreDrawListener(preDrawListener);
+      hippyRecyclerView.post(new Runnable() {
+        @Override
+        public void run() {
+          new HippyViewEvent(INITIAL_LIST_READY).send(getParentView(), null);
+        }
+      });
+    }
+  }
+
+  protected View getParentView() {
+    return (View) hippyRecyclerView.getParent();
+  }
+
+  /**
+   * 是否满足initialListReady的通知条件，需要有真实view上屏才进行通知
+   */
+  private boolean canNotifyInit() {
+    return !isInitialListReadyNotified && hippyRecyclerView.getAdapter().getItemCount() > 0
+        && hippyRecyclerView.getChildCount() > 0
+        && viewTreeObserver.isAlive();
+  }
+
+  public void setScrollBeginDragEventEnable(boolean enable) {
+    scrollBeginDragEventEnable = enable;
+  }
+
+  public void setScrollEndDragEventEnable(boolean enable) {
+    scrollEndDragEventEnable = enable;
+  }
+
+  public void setMomentumScrollBeginEventEnable(boolean enable) {
+    momentumScrollBeginEventEnable = enable;
+  }
+
+  public void setMomentumScrollEndEventEnable(boolean enable) {
+    momentumScrollEndEventEnable = enable;
+  }
+
+  public void setOnScrollEventEnable(boolean enable) {
+    onScrollEventEnable = enable;
+  }
+
+  @Override
+  public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft,
+      int oldTop, int oldRight,
+      int oldBottom) {
+    checkSendExposureEvent();
+  }
+
+  protected HippyViewEvent getOnScrollDragStartedEvent() {
+    if (onScrollDragStartedEvent == null) {
+      onScrollDragStartedEvent = new HippyViewEvent(
+          HippyScrollViewEventHelper.EVENT_TYPE_BEGIN_DRAG);
+    }
+    return onScrollDragStartedEvent;
+  }
+
+  // scroll
+  protected HippyViewEvent getOnScrollEvent() {
+    if (onScrollEvent == null) {
+      onScrollEvent = new HippyViewEvent(HippyScrollViewEventHelper.EVENT_TYPE_SCROLL);
+    }
+    return onScrollEvent;
+  }
+
+  // start fling
+  protected HippyViewEvent getOnScrollFlingStartedEvent() {
+    if (onScrollFlingStartedEvent == null) {
+      onScrollFlingStartedEvent = new HippyViewEvent(
+          HippyScrollViewEventHelper.EVENT_TYPE_MOMENTUM_BEGIN);
+    }
+    return onScrollFlingStartedEvent;
+  }
+
+  // end drag event
+  protected HippyViewEvent getOnScrollDragEndedEvent() {
+    if (onScrollDragEndedEvent == null) {
+      onScrollDragEndedEvent = new HippyViewEvent(HippyScrollViewEventHelper.EVENT_TYPE_END_DRAG);
+    }
+    return onScrollDragEndedEvent;
+  }
+
+  @Override
+  public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
+    int oldState = currentState;
+    currentState = newState;
+    sendDragEvent(newState);
+    sendDragEndEvent(oldState, currentState);
+    sendFlingEvent(newState);
+    sendFlingEndEvent(oldState, currentState);
+  }
+
+  @Override
+  public void onScrolled(@NonNull final RecyclerView recyclerView, int dx, int dy) {
+    if (dx != 0 || dy != 0) {
+      checkSendOnScrollEvent();
+    }
+
+    checkSendExposureEvent();
+
+    if (!recyclerView.canScrollVertically(1)) {
+      sendOnEndReachedEvent();
+    }
+
+    if (!recyclerView.canScrollVertically(-1)) {
+      sendOnTopReachedEvent();
+    }
+  }
+
+  protected void sendOnEndReachedEvent() {
+    new HippyViewEvent(EVENT_ON_END_REACHED).send(getParentView(), null);
+  }
+
+  protected void sendOnTopReachedEvent() {
+    new HippyViewEvent(EVENT_ON_TOP_REACHED).send(getParentView(), null);
+  }
+
+  private void checkSendOnScrollEvent() {
+    if (onScrollEventEnable) {
+      long currTime = System.currentTimeMillis();
+      if (currTime - lastScrollEventTimeStamp >= scrollEventThrottle) {
+        lastScrollEventTimeStamp = currTime;
+        sendOnScrollEvent();
+      }
+    }
+  }
+
+  public void sendOnScrollEvent() {
+    getOnScrollEvent().send(getParentView(), generateScrollEvent());
+  }
+
+  private void observePreDraw() {
+    if (!isInitialListReadyNotified && viewTreeObserver == null) {
+      viewTreeObserver = hippyRecyclerView.getViewTreeObserver();
+      viewTreeObserver.addOnPreDrawListener(preDrawListener);
+    }
+  }
+
+  protected void sendFlingEvent(int newState) {
+    if (momentumScrollBeginEventEnable && newState == SCROLL_STATE_SETTLING) {
+      getOnScrollFlingStartedEvent().send(getParentView(), generateScrollEvent());
+    }
+  }
+
+  protected void sendDragEndEvent(int oldState, int newState) {
+    if (scrollEndDragEventEnable && isReleaseDrag(oldState, newState) && !hippyRecyclerView
+        .isOverPulling()) {
+      getOnScrollDragEndedEvent().send(getParentView(), generateScrollEvent());
+    }
+  }
+
+  private boolean isReleaseDrag(int oldState, int newState) {
+    return (oldState == SCROLL_STATE_DRAGGING &&
+        (newState == SCROLL_STATE_IDLE || newState == SCROLL_STATE_SETTLING));
+  }
+
+  protected void sendFlingEndEvent(int oldState, int newState) {
+    if (momentumScrollEndEventEnable && oldState == SCROLL_STATE_SETTLING
+        && newState != SCROLL_STATE_SETTLING) {
+      getOnScrollFlingEndedEvent().send(getParentView(), generateScrollEvent());
+    }
+  }
+
+  protected void sendDragEvent(int newState) {
+    if (scrollBeginDragEventEnable && newState == RecyclerView.SCROLL_STATE_DRAGGING) {
+      getOnScrollDragStartedEvent().send(getParentView(), generateScrollEvent());
+    }
+  }
+
+  // end fling
+  protected HippyViewEvent getOnScrollFlingEndedEvent() {
+    if (onScrollFlingEndedEvent == null) {
+      onScrollFlingEndedEvent = new HippyViewEvent(
+          HippyScrollViewEventHelper.EVENT_TYPE_MOMENTUM_END);
+    }
+    return onScrollFlingEndedEvent;
+  }
+
+  public void setScrollEventThrottle(int scrollEventThrottle) {
+    this.scrollEventThrottle = scrollEventThrottle;
+  }
+
+  public final HippyMap generateScrollEvent() {
+    HippyMap contentOffset = new HippyMap();
+
+    float offsetX = hippyRecyclerView.getContentOffsetX();
+    float offsetY = hippyRecyclerView.getContentOffsetY();
+
+    if (offsetX != 0) {
+      offsetX = PixelUtil.px2dp(offsetX);
+    }
+
+    if (offsetY != 0) {
+      offsetY = PixelUtil.px2dp(offsetY);
+    }
+
+    contentOffset.pushDouble("x", offsetX);
+    contentOffset.pushDouble("y", offsetY);
+    HippyMap event = new HippyMap();
+    event.pushMap("contentOffset", contentOffset);
+    return event;
+  }
+
+  public void setExposureEventEnable(boolean enable) {
+    exposureEventEnable = enable;
+  }
+
+  /**
+   * 可视面积小于10%，任务view当前已经不在可视区域
+   */
+  private boolean isViewVisible(View view) {
+    if (view == null) {
+      return false;
+    }
+    Rect rect = new Rect();
+    boolean visibility = view.getGlobalVisibleRect(rect);
+    if (!visibility) {
+      return false;
+    } else {
+      float visibleArea = rect.height() * rect.width(); //可见区域的面积
+      float viewArea = view.getMeasuredWidth() * view.getMeasuredHeight();//当前view的总面积
+      return visibleArea > viewArea * 0.1f;
+    }
+  }
+
+  protected void checkExposureView(View view) {
+    if (view instanceof HippyListItemView) {
+      HippyListItemView itemView = (HippyListItemView) view;
+      if (isViewVisible(view)) {
+        if (itemView.getExposureState() != HippyListItemView.EXPOSURE_STATE_APPEAR) {
+          sendExposureEvent(view, HippyListItemView.EXPOSURE_EVENT_APPEAR);
+          itemView.setExposureState(HippyListItemView.EXPOSURE_STATE_APPEAR);
+        }
+      } else {
+        if (itemView.getExposureState() != HippyListItemView.EXPOSURE_STATE_DISAPPEAR) {
+          sendExposureEvent(view, HippyListItemView.EXPOSURE_EVENT_DISAPPEAR);
+          itemView.setExposureState(HippyListItemView.EXPOSURE_STATE_DISAPPEAR);
+        }
+      }
+    }
+  }
+
+  protected void sendExposureEvent(View view, String eventName) {
+    if (eventName.equals(HippyListItemView.EXPOSURE_EVENT_APPEAR) || eventName
+        .equals(HippyListItemView.EXPOSURE_EVENT_DISAPPEAR)) {
+      new HippyViewEvent(eventName).send(view, null);
+    }
+  }
+
+  private void checkSendExposureEvent() {
+    if (!exposureEventEnable) {
+      return;
+    }
+    int childCount = hippyRecyclerView.getChildCount();
+    for (int i = 0; i < childCount; i++) {
+      checkExposureView(findHippyListItemView((ViewGroup) hippyRecyclerView.getChildAt(i)));
+    }
+  }
+
+  /**
+   * 由于挂载到RecyclerView到子View可能不是HippyListItemView，比如对于stickyItem，我们会包一层
+   * ViewGroup，所以这里拿HippyListItemView，需要做两层的判断
+   */
+  private View findHippyListItemView(ViewGroup viewGroup) {
+    if (viewGroup instanceof HippyListItemView) {
+      return viewGroup;
+    }
+    if (viewGroup.getChildCount() > 0) {
+      View child = viewGroup.getChildAt(0);
+      if (child instanceof HippyListItemView) {
+        return child;
+      }
+    }
+    return null;
+  }
+
+  @Override
+  public void onViewAttachedToWindow(View v) {
+    observePreDraw();
+  }
+
+  @Override
+  public void onViewDetachedFromWindow(View v) {
+
+  }
+
+  @Override
+  public void onOverPullStateChanged(int oldState, int newState, int offset) {
+    LogUtils.d("QBRecyclerViewEventHelper", "oldState:" + oldState + ",newState:" + newState);
+    if (oldState == OverPullHelper.OVER_PULL_NONE && isOverPulling(newState)) {
+      sendOnEndReachedEvent();
+      getOnScrollDragStartedEvent().send(getParentView(), generateScrollEvent());
+    }
+    if (isOverPulling(oldState) && isOverPulling(newState)) {
+      sendOnScrollEvent();
+    }
+    if (newState == OverPullHelper.OVER_PULL_SETTLING
+        && oldState != OverPullHelper.OVER_PULL_SETTLING) {
+      getOnScrollDragEndedEvent().send(getParentView(), generateScrollEvent());
+    }
+  }
+
+  private boolean isOverPulling(int newState) {
+    return newState == OverPullHelper.OVER_PULL_DOWN_ING
+        || newState == OverPullHelper.OVER_PULL_UP_ING;
+  }
+}

package/rules/.source/hippy/hippy_views/image/HippyContentDrawable.java

@@ -0,0 +1,113 @@
+/* Tencent is pleased to support the open source community by making Hippy available.
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.tencent.mtt.hippy.views.image;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import com.tencent.mtt.hippy.utils.ContextHolder;
+import com.tencent.mtt.supportui.views.asyncimage.ContentDrawable;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffColorFilter;
+import android.graphics.Rect;
+import android.graphics.drawable.NinePatchDrawable;
+
+class HippyContentDrawable extends ContentDrawable {
+
+  private Rect mNinePatchRect;
+  private NinePatchDrawable mNinePatchDrawable;
+
+  HippyContentDrawable() {
+    super();
+  }
+
+  void setNinePatchCoordinate(Rect rect) {
+    mNinePatchRect = rect;
+    mNinePatchDrawable = null;
+  }
+
+  @Override
+  public void draw(Canvas canvas) {
+    // 处理.9Patch的形式，不支持缩放、圆角
+    if (mNinePatchRect != null && mContentBitmap != null) {
+      if (mNinePatchDrawable == null) {
+        mNinePatchDrawable = new NinePatchDrawable(ContextHolder.getAppContext().getResources(),
+            mContentBitmap,
+            createNinePatchTrunk(mContentBitmap, mNinePatchRect), null, null);
+      }
+      mNinePatchDrawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
+      mNinePatchDrawable.setAlpha(mAlpha);
+      if (mTintColor != Color.TRANSPARENT) {
+        mNinePatchDrawable
+            .setColorFilter(new PorterDuffColorFilter(mTintColor, PorterDuff.Mode.SRC_ATOP));
+      }
+      mNinePatchDrawable.draw(canvas);
+      return;
+    }
+    super.draw(canvas);
+  }
+
+  private byte[] createNinePatchTrunk(Bitmap bitmap, Rect ninePatchRect) {
+    int[] xRegions = new int[]{ninePatchRect.left, bitmap.getWidth() - ninePatchRect.right};
+    int[] yRegions = new int[]{ninePatchRect.top, bitmap.getHeight() - ninePatchRect.bottom};
+    int NO_COLOR = 0x00000001;
+    int colorSize = 9;
+    int bufferSize = xRegions.length * 4 + yRegions.length * 4 + colorSize * 4 + 32;
+
+    ByteBuffer byteBuffer = ByteBuffer.allocate(bufferSize).order(ByteOrder.nativeOrder());
+    // 第一个byte，要不等于0
+    byteBuffer.put((byte) 1);
+
+    //mDivX length
+    byteBuffer.put((byte) 2);
+    //mDivY length
+    byteBuffer.put((byte) 2);
+    //mColors length
+    byteBuffer.put((byte) colorSize);
+
+    //skip
+    byteBuffer.putInt(0);
+    byteBuffer.putInt(0);
+
+    //padding 先设为0
+    byteBuffer.putInt(0);
+    byteBuffer.putInt(0);
+    byteBuffer.putInt(0);
+    byteBuffer.putInt(0);
+
+    //skip
+    byteBuffer.putInt(0);
+
+    // mDivX
+    byteBuffer.putInt(xRegions[0]);
+    byteBuffer.putInt(xRegions[1]);
+
+    // mDivY
+    byteBuffer.putInt(yRegions[0]);
+    byteBuffer.putInt(yRegions[1]);
+
+    // mColors
+    for (int i = 0; i < colorSize; i++) {
+      byteBuffer.putInt(NO_COLOR);
+    }
+
+    return byteBuffer.array();
+  }
+}