Hippy项目源码分析Week1

2021SC@SDUSC

Hippy项目源码分析第一周

• layoutandroidjavaflex
• • flexFlexAlign.java
  • FlexConstants.java
  • FlexCSSDirction.java
  • FlexDirection.java
  • FlexJustify.java
  • FlexMeasureMode.java
  • FlexNodeAPI.java
  • FlexOutput.java
  • FlexOverflow.java
  • FlexPositionType.java
  • FlexSpacing.java
  • FlexWrap.java
  • FlexUtil.java
• 结语

layoutandroidjavaflex

本周分析layoutandroidjavaflex目录下的部分代码

Hippy中为了方便移动端编写布局，默认支持了现在移动端最流行的Flex布局，同时仅支持Flex布局。

flexFlexAlign.java

package com.tencent.mtt.hippy.dom.flex;
public enum FlexAlign {
	AUTO,
	FLEX_START,
	CENTER,
	FLEX_END,
	STRETCH,
	baseLINE,
	SPACE_BETWEEN,
	SPACE_AROUND,;
  public static FlexAlign fromInt(int value) {
	    switch (value) {
	      case 0: return AUTO;
	      case 1: return FLEX_START;
	      case 2: return CENTER;
	      case 3: return FLEX_END;
	      case 4: return STRETCH;
	      case 5: return baseLINE;
	      case 6: return SPACE_BETWEEN;
	      case 7: return SPACE_AROUND;
	      default: throw new IllegalArgumentException("Unknown enum value: " + value);
	    }
	  } 
}

会根据传入的数据返回不同的类型，从而决定布局的方式，在FlexNodeAPI.java中出现

FlexConstants.java

package com.tencent.mtt.hippy.dom.flex;

public class FlexConstants {

  public static final float UNDEFINED = Float.NaN;

  public static boolean isUndefined(float value) {
    return Float.compare(value, UNDEFINED) == 0;
  }
}

是一个负责判断是否尚未定义的函数，此函数在FlexSpacing.java中有调用

FlexCSSDirction.java

package com.tencent.mtt.hippy.dom.flex;

public enum FlexCSSDirection {
  ROW,
  ROW_REVERSE,
  COLUMN,
  COLUMN_REVERSE;

  public static FlexCSSDirection fromInt(int value) {
	    switch (value) {
	      case 0: return ROW;
	      case 1: return ROW_REVERSE;
	      case 2: return COLUMN;
	      case 3: return COLUMN_REVERSE;
	      default: throw new IllegalArgumentException("Unknown enum value: " + value);
	    }
	  }
}

FlexCSSDriection.java是一个枚举类，根据输入来判断不同情况，在FlexNodeAPI.java中出现

FlexDirection.java

package com.tencent.mtt.hippy.dom.flex;

public enum FlexDirection {
  INHERIT,
  LTR,
  RTL;
  public static FlexDirection fromInt(int value) {
	    switch (value) {
	      case 0: return INHERIT;
	      case 1: return LTR;
	      case 2: return RTL;
	      default: throw new IllegalArgumentException("Unknown enum value: " + value);
	    }
	  }
}

FlexDirection.java也是一个枚举类，用来确定内部元素主轴的方向，在FlexNodeAPI.java中出现

FlexJustify.java

package com.tencent.mtt.hippy.dom.flex;

public enum FlexJustify {
  FLEX_START,
  CENTER,
  FLEX_END,
  SPACE_BETWEEN,
  SPACE_AROUND;
  public static FlexJustify fromInt(int value) {
	    switch (value) {
	      case 0: return FLEX_START;
	      case 1: return CENTER;
	      case 2: return FLEX_END;
	      case 3: return SPACE_BETWEEN;
	      case 4: return SPACE_AROUND;
	      default: throw new IllegalArgumentException("Unknown enum value: " + value);
	    }
	  }
}

也是一个枚举类，根据输入来判断不同情况，在FlexNodeAPI.java中出现

FlexMeasureMode.java

package com.tencent.mtt.hippy.dom.flex;

public enum FlexMeasureMode {
  UNDEFINED,
  EXACTLY,
  AT_MOST;
  public static FlexMeasureMode fromInt(int value) {
	    switch (value) {
	      case 0: return UNDEFINED;
	      case 1: return EXACTLY;
	      case 2: return AT_MOST;
	      default: throw new IllegalArgumentException("Unknown enum value: " + value);
	    }
	  }
}

枚举类，根据输入来判断不同情况，在FlexNodeAPI.java中出现

FlexNodeAPI.java

package com.tencent.mtt.hippy.dom.flex;

import com.tencent.smtt.flexbox.FlexNodeStyle;

public interface FlexNodeAPI {

  interface MeasureFunction {
    long measure(
            FlexNodeAPI node,
            float width,
            FlexMeasureMode widthMode,
            float height,
            FlexMeasureMode heightMode);
  }
  int getChildCount();
  FlexNodeType getChildAt(int i);
  void addChildAt(FlexNodeType child, int i);
  FlexNodeType removeChildAt(int i);
  FlexNodeType getParent();
  int indexOf(FlexNodeType child);
  void setMeasureFunction(MeasureFunction measureFunction);
  boolean isMeasureDefined();
  void calculateLayout();
  boolean isDirty();
  boolean hasNewLayout();
  void dirty();
  void markLayoutSeen();
  boolean valuesEqual(float f1, float f2);
  FlexDirection getStyleDirection();
  void setDirection(FlexDirection direction);
  FlexCSSDirection getFlexDirection();
  void setFlexDirection(FlexCSSDirection flexDirection);
  FlexJustify getJustifyContent();
  void setJustifyContent(FlexJustify justifyContent);
  FlexAlign getAlignItems();
  void setAlignItems(FlexAlign alignItems);
  FlexAlign getAlignSelf();
  void setAlignSelf(FlexAlign alignSelf);
  FlexAlign getAlignContent();
  void setAlignContent(FlexAlign alignContent);
  FlexPositionType getPositionType();
  void setPositionType(FlexPositionType positionType);
  void setWrap(FlexWrap flexWrap);
  void setFlex(float flex);
  void setDisplay(FlexNodeStyle.Display  display);
  float getFlexGrow();
  void setFlexGrow(float flexGrow);
  float getFlexShrink();
  void setFlexShrink(float flexShrink);
  float getFlexBasis();
  void setFlexBasis(float flexBasis);
  float getMargin(int spacingType);
  void setMargin(int spacingType, float margin);
  float getPadding(int spacingType);
  void setPadding(int spacingType, float padding);
  float getBorder(int spacingType);
  void setBorder(int spacingType, float border);
  float getPosition(int spacingType);
  void setPosition(int spacingType, float position);
  float getStyleWidth();
  void setStyleWidth(float width);
  float getStyleHeight();
  void setStyleHeight(float height);
  float getStyleMaxWidth();
  void setStyleMaxWidth(float maxWidth);
  float getStyleMinWidth();
  void setStyleMinWidth(float minWidth);
  float getStyleMaxHeight();
  void setStyleMaxHeight(float maxHeight);
  float getStyleMinHeight();
  void setStyleMinHeight(float minHeight);
  float getLayoutX();
  float getLayoutY();
  float getLayoutWidth();
  float getLayoutHeight();
  FlexDirection getLayoutDirection();
  FlexOverflow getOverflow();
  void setOverflow(FlexOverflow overflow);
  void setData(Object data);
  Object getData();
  void reset();
}

预先定义的函数，方便开发人员无需访问源码即可调用对应方法

FlexOutput.java

package com.tencent.mtt.hippy.dom.flex;
public class FlexOutput {
  public static long make(float width, float height) {
    return make((int) width, (int) height);
  }

  public static long make(int width, int height) {
    return ((long) width) << 32 | ((long) height);
  }

  public static int getWidth(long measureOutput) {
    return (int) (0xFFFFFFFF & (measureOutput >> 32));
  }

  public static int getHeight(long measureOutput) {
    return (int) (0xFFFFFFFF & measureOutput);
  }
}

提供了几个函数，将输入的width和height转化成long类型的数据

FlexOverflow.java

package com.tencent.mtt.hippy.dom.flex;

public enum FlexOverflow {
  VISIBLE,
  HIDDEN,
  SCROLL;
  public static FlexOverflow fromInt(int value) {
	    switch (value) {
	      case 0: return VISIBLE;
	      case 1: return HIDDEN;
	      case 2: return SCROLL;
	      default: throw new IllegalArgumentException("Unknown enum value: " + value);
	    }
	  }
}

枚举类，根据输入判断不同情况，在FlexNodeAPI.java中出现

FlexPositionType.java

package com.tencent.mtt.hippy.dom.flex;

public enum FlexPositionType {
  RELATIVE,
  ABSOLUTE;
  public static FlexPositionType fromInt(int value) {
	    switch (value) {
	      case 0: return RELATIVE;
	      case 1: return ABSOLUTE;
	      default: throw new IllegalArgumentException("Unknown enum value: " + value);
	    }
	  }
}

枚举类，根据输入判断不同情况，在FlexNodeAPI.java中出现

FlexSpacing.java

由于代码过长，不方便贴出，主要作用于伸缩容器上，用于指定元素之间的最小间距。

FlexWrap.java

package com.tencent.mtt.hippy.dom.flex;


public enum FlexWrap {
  NOWRAP,
  WRAP,
  WRAP_REVERSE;
  public static FlexWrap fromInt(int value) {
	    switch (value) {
	      case 0: return NOWRAP;
	      case 1: return WRAP;
	      case 2: return WRAP_REVERSE;
	      default: throw new IllegalArgumentException("Unknown enum value: " + value);
	    }
	  }
}

枚举类，根据输入判断不同情况，在FlexNodeAPI.java中出现

FlexUtil.java

package com.tencent.mtt.hippy.dom.flex;

public class FloatUtil {

  private static final float EPSILON = .00001f;

  public static boolean floatsEqual(float f1, float f2) {
    if (Float.isNaN(f1) || Float.isNaN(f2)) {
      return Float.isNaN(f1) && Float.isNaN(f2);
    }
    return Math.abs(f2 - f1) < EPSILON;
  }
}

提供了一个布尔型函数，用于判断两个浮点数是否相等

结语

以上就是本周所看的代码