/**
 *
 * 专为Android4.4设计的从Uri获取文件绝对路径
 */
@SuppressLint("NewApi")
public static String getPath(final Context context, final Uri uri) {
    final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
    LogUtil.d("uri:" + uri);
    // DocumentProvider
    if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
        // ExternalStorageProvider
        if (isExternalStorageDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            if ("primary".equalsIgnoreCase(type)) {
                return Environment.getExternalStorageDirectory() + "/" + split[1];
            }
            // TODO handle non-primary volumes
        }
        // DownloadsProvider
        else if (isDownloadsDocument(uri)) {

            final String id = DocumentsContract.getDocumentId(uri);
            final Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));

            return getDataColumn(context, contentUri, null, null);
        }
        // MediaProvider
        else if (isMediaDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            Uri contentUri = null;
            if ("image".equals(type)) {
                contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
            } else if ("video".equals(type)) {
                contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
            } else if ("audio".equals(type)) {
                contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
            }

            final String selection = "_id=?";
            final String[] selectionArgs = new String[]{split[1]};
            LogUtil.d("format uri:" + contentUri);
            return getDataColumn(context, contentUri, selection, selectionArgs);
        }
    }
    // MediaStore (and general)
    else if ("content".equalsIgnoreCase(uri.getScheme())) {
        return getDataColumn(context, uri, null, null);
    }
    // File
    else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }

    return null;
}

/**
 * Get the value of the data column for this Uri. This is useful for
 * MediaStore Uris, and other file-based ContentProviders.
 *
 * @param context       The context.
 * @param uri           The Uri to query.
 * @param selection     (Optional) Filter used in the query.
 * @param selectionArgs (Optional) Selection arguments used in the query.
 * @return The value of the _data column, which is typically a file path.
 */
public static String getDataColumn(Context context, Uri uri, String selection,
                                   String[] selectionArgs) {

    Cursor cursor = null;
    final String column = "_data";
    final String[] projection = {column};

    try {
        cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
                null);
        if (cursor != null && cursor.moveToFirst()) {
            final int column_index = cursor.getColumnIndexOrThrow(column);
            return cursor.getString(column_index);
        }
    } finally {
        if (cursor != null)
            cursor.close();
    }
    return null;

}
/**
  * @param uri The Uri to check.
  * @return Whether the Uri authority is ExternalStorageProvider.
  */
 public static boolean isExternalStorageDocument(Uri uri) {
     return "com.android.externalstorage.documents".equals(uri.getAuthority());
 }

 /**
  * @param uri The Uri to check.
  * @return Whether the Uri authority is DownloadsProvider.
  */
 public static boolean isDownloadsDocument(Uri uri) {
     return "com.android.providers.downloads.documents".equals(uri.getAuthority());
 }

 /**
  * @param uri The Uri to check.
  * @return Whether the Uri authority is MediaProvider.
  */
 public static boolean isMediaDocument(Uri uri) {
     return "com.android.providers.media.documents".equals(uri.getAuthority());
 }

private static final String PATH_DOCUMENT = "document";
private static final String PATH_TREE = "tree";
public static final String PROVIDER_INTERFACE = "android.content.action.DOCUMENTS_PROVIDER";

/**
   * Test if the given URI represents a {@link Document} backed by a
   * {@link DocumentsProvider}.
   *
   * @see #buildDocumentUri(String, String)
   * @see #buildDocumentUriUsingTree(Uri, String)
   */
  public static boolean isDocumentUri(Context context, @Nullable Uri uri) {
      if (isContentUri(uri) && isDocumentsProvider(context, uri.getAuthority())) {
          final List<String> paths = uri.getPathSegments();
          if (paths.size() == 2) {
              return PATH_DOCUMENT.equals(paths.get(0));
          } else if (paths.size() == 4) {
              return PATH_TREE.equals(paths.get(0)) && PATH_DOCUMENT.equals(paths.get(2));
          }
      }
      return false;
  }
  /** {@hide} */
   public static boolean isContentUri(@Nullable Uri uri) {
      // public static final String SCHEME_CONTENT = "content";     !!add by custom
       return uri != null && ContentResolver.SCHEME_CONTENT.equals(uri.getScheme());
   }

   private static boolean isDocumentsProvider(Context context, String authority) {
    final Intent intent = new Intent(PROVIDER_INTERFACE);
    final List<ResolveInfo> infos = context.getPackageManager()
            .queryIntentContentProviders(intent, 0);
    for (ResolveInfo info : infos) {
        if (authority.equals(info.providerInfo.authority)) {
            return true;
        }
    }
    return false;
}

/**
     * Measures the children when the orientation of this LinearLayout is set
     * to {@link #VERTICAL}.
     *
     * @param widthMeasureSpec Horizontal space requirements as imposed by the parent.
     * @param heightMeasureSpec Vertical space requirements as imposed by the parent.
     *
     * @see #getOrientation()
     * @see #setOrientation(int)
     * @see #onMeasure(int, int)
     */
    void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
		// mTotalLength作为LinearLayout成员变量，其主要目的是在测量的时候通过累加得到所有子控件的高度和（Vertical）或者宽度和（Horizontal）
        mTotalLength = 0;
		// maxWidth用来记录所有子控件中控件宽度最大的值。
        int maxWidth = 0;
		// 子控件的测量状态，会在遍历子控件测量的时候通过combineMeasuredStates来合并上一个子控件测量状态与当前遍历到的子控件的测量状态，采取的是按位相或
        int childState = 0;

		/**
		* 以下两个最大宽度跟上面的maxWidth最大的区别在于matchWidthLocally这个参数
		* 当matchWidthLocally为真，那么以下两个变量只会跟当前子控件的左右margin和相比较取大值
		* 否则，则跟maxWidth的计算方法一样
		*/
		// 子控件中layout_weight<=0的View的最大宽度
        int alternativeMaxWidth = 0;
		// 子控件中layout_weight>0的View的最大宽度
        int weightedMaxWidth = 0;
		// 是否子控件全是match_parent的标志位，用于判断是否需要重新测量
        boolean allFillParent = true;
		// 所有子控件的weight之和
        float totalWeight = 0;

		// 如您所见，得到所有子控件的数量，准确的说，它得到的是所有同级子控件的数量
        // 在官方的注释中也有着对应的例子
        // 比如TableRow，假如TableRow里面有N个控件，而LinearLayout（TableLayout也是继承LinearLayout哦）下有M个TableRow，那么这里返回的是M，而非M*N
        // 但实际上，官方似乎也只是直接返回getChildCount()，起这个方法名的原因估计是为了让人更加的明白，毕竟如果是getChildCount()可能会让人误认为为什么没有返回所有（包括不同级）的子控件数量
        final int count = getVirtualChildCount();

		// 得到测量模式
        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);

		// 当子控件为match_parent的时候，该值为ture，同时判定的还有上面所说的matchWidthLocally，这个变量决定了子控件的测量是父控件干预还是填充父控件（剩余的空白位置）。
        boolean matchWidth = false;

        boolean skippedMeasure = false;

        final int baselineChildIndex = mBaselineAlignedChildIndex;        
        final boolean useLargestChild = mUseLargestChild;

        int largestChildHeight = Integer.MIN_VALUE;

        // See how tall everyone is. Also remember max width.

		//查看每一个高，并记住最大宽度
        for (int i = 0; i < count; ++i) {
			//首先获取子View
            final View child = getVirtualChildAt(i);
			//如果子View是null就继续测量下一个子View
            if (child == null) {
				// 目前而言，measureNullChild()方法返回的永远是0，估计是设计者留下来以后或许有补充的。
                mTotalLength += measureNullChild(i);
                continue;
            }
			//如果子View是GONE的也不算在总高度里面，这里也能看出GONE和INVISIBLE的区别
            if (child.getVisibility() == View.GONE) {
				// 同上，返回的都是0。
               // 事实上这里的意思应该是当前遍历到的View为Gone的时候，就跳过这个View，下一句的continue关键字也正是这个意思。
               // 忽略当前的View，这也就是为什么Gone的控件不占用布局资源的原因。（毕竟根本没有分配空间）
               i += getChildrenSkipCount(child, i);
               continue;
            }

			// 根据showDivider的值（before/middle/end）来决定遍历到当前子控件时，高度是否需要加上divider的高度
            // 比如showDivider为before，那么只会在第0个子控件测量时加上divider高度，其余情况下都不加
            if (hasDividerBeforeChildAt(i)) {
                mTotalLength += mDividerHeight;
            }
			//有时候我们在代码里面通过Inflater服务，动态加载一个布局，然后去设置他的LayoutParams，
			//如果不引用父容器的LayoutParams就会报一个强转错误，原因就在这个父容器在add,measure的时候都会
			//把子View的LayoutParams强转成自己的类型
            LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
			//得到每个子控件的LayoutParams后，累加权重和,后面用于跟weightSum相比较
            totalWeight += lp.weight;


			// 我们都知道，测量模式有三种：
            // * UNSPECIFIED：父控件对子控件无约束,基本没有用到
            // * Exactly：父控件对子控件强约束，子控件永远在父控件边界内，越界则裁剪。如果要记忆的话，可以记忆为有对应的具体数值或者是Match_parent
            // * AT_Most：子控件为wrap_content的时候，测量值为AT_MOST。

            // 下面的if/else分支都是跟weight相关
			//这里就值得注意下了如果当前的LinearLayout是EXACTLY模式，且子view的高度为0，且权重大于0
			//这个子view只有在LinearLayout高度有剩余的时候，才会根据权重的占比去平分剩余空间
			//上文说的二次测量也就指的这部分
            if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
                // Optimization: don't bother measuring children who are going to use
                // leftover space. These views will get measured again down below if
                // there is any leftover space.
				// 这个if里面需要满足三个条件：
                // * LinearLayout的高度为match_parent(或者有具体值)
                // * 子控件的高度为0
                // * 子控件的weight>0   	

				// 如果LinearLayout的垂直方向测量模式是EXACTLY，即确定值，且子视图的高度为0，weight大于0，
        //则先将总高度加上子视图的topMargin和bottomMargin，并设置skippedMeasure（暂时跳过测量标识）为true

                // 这其实就是我们通常情况下用weight时的写法，此时需要记住view的topMargin和bottomMargin（对于方向为）
                // 测量到这里的时候，会给个标志位，稍后再处理。此时会计算总高度
                final int totalLength = mTotalLength;
                mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
                skippedMeasure = true;
            } else {
				// 到这个分支，则需要对不同的情况进行测量
                int oldHeight = Integer.MIN_VALUE;

                if (lp.height == 0 && lp.weight > 0) {
                    // heightMode is !!either UNSPECIFIED or AT_MOST!!, and this
                    // child wanted to stretch to fill available space.
                    // Translate that to WRAP_CONTENT so that it does not end up
                    // with a height of 0
					// 满足这两个条件，意味着父类即LinearLayout是wrap_content，或者mode为UNSPECIFIED
                    // 那么此时将当前子控件的高度置为wrap_content
                    // 为何需要这么做，主要是因为当父类为wrap_content时，其大小实际上由子控件控制
                    // 我们都知道，自定义控件的时候，通常我们会指定测量模式为wrap_content时的默认大小
                    // 这里强制给定为wrap_content为的就是防止子控件高度为0.

					//这里其实官方的注释讲了也挺清楚的，到了这步，当前的LinearLayout的模式
					//肯定是UNSPECIFIED或者MOST，因为EXACTLY模式会进入上一个判断
					//然后把子View的高度赋值成-1(WRAP_CONTENT)
					// 如果垂直方向测量模式为UNSPECIFIED或AT_MOST，同时子视图想要尽量获取可用的剩余空间，
          //把子视图的高度改为WRAP_CONTENT，这样子视图的最终高度就不会是0

                    oldHeight = 0;
                    lp.height = LayoutParams.WRAP_CONTENT;
                }

                // Determine how big this child would like to be. If this or
                // previous children have given a weight, then we allow it to
                // use all available space (and we will shrink things later
                // if needed).
				/**【1】*/
                // 下面这句虽然最终调用的是ViewGroup通用的同名方法，但传入的height值是跟平时不一样的
                // 这里可以看到，传入的height是跟weight有关，关于这里，稍后的文字描述会着重阐述

				// 这个函数最后会调用child.measure(childWidthMeasureSpec, childHeightMeasureSpec)
        //测量出子视图要占用多大空间，并设置子视图的mMeasuredWidth和mMeasuredHeight
                measureChildBeforeLayout(
                       child, i, widthMeasureSpec, 0, heightMeasureSpec,
                       totalWeight == 0 ? mTotalLength : 0);

				// 重置子控件高度，然后进行精确赋值
                if (oldHeight != Integer.MIN_VALUE) {
                   lp.height = oldHeight;
                }

                final int childHeight = child.getMeasuredHeight();
                final int totalLength = mTotalLength;

				// getNextLocationOffset返回的永远是0，因此这里实际上是比较child测量前后的总高度，取大值。
				//加上子View的margin值
                mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                       lp.bottomMargin + getNextLocationOffset(child));

				// 重新设置最大子视图高度
                if (useLargestChild) {
                    largestChildHeight = Math.max(childHeight, largestChildHeight);
                }
            }

            /**
             * If applicable, compute the additional offset to the child's baseline
             * we'll need later when asked {@link #getBaseline}.
             */
			// 计算子视图baseline的偏移量
            if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {
               mBaselineChildTop = mTotalLength;
            }

            // if we are trying to use a child index for our baseline, the above
            // book keeping only works if there are no children above it with
            // weight.  fail fast to aid the developer.
			// 如果要为baseline指定子视图索引，只有在此子视图之上的视图没有设置weight属性时才有效
            if (i < baselineChildIndex && lp.weight > 0) {
                throw new RuntimeException("A child of LinearLayout with index "
                        + "less than mBaselineAlignedChildIndex has weight > 0, which "
                        + "won't work.  Either remove the weight, or don't set "
                        + "mBaselineAlignedChildIndex.");
            }


			// 下面开始测量宽度
            boolean matchWidthLocally = false;

            // 还记得我们变量里又说到过matchWidthLocally这个东东吗
            // 当父类（LinearLayout）不是match_parent或者精确值的时候，但子控件却是一个match_parent
            // 那么matchWidthLocally和matchWidth置为true
            // 意味着这个控件将会占据父类（水平方向）的所有空间
            if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {
                // The width of the linear layout will scale, and at least one
                // child said it wanted to match our width. Set a flag
                // indicating that we need to remeasure at least that view when
                // we know our width.
				//如果LinearLayout宽度不是已确定的，如wrap_content,而子视图是MATCH_PARENT，  
                matchWidth = true;
                matchWidthLocally = true;
            }

			// 计算子视图总宽度（包含左右外边距）
            final int margin = lp.leftMargin + lp.rightMargin;
            final int measuredWidth = child.getMeasuredWidth() + margin;
            maxWidth = Math.max(maxWidth, measuredWidth);
			// 合并子元素的测量状态
            childState = combineMeasuredStates(childState, child.getMeasuredState());

			// 子视图宽度是否都为MATCH_PARENT
            allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;
            if (lp.weight > 0) {
                /*
                 * Widths of weighted Views are bogus if we end up
                 * remeasuring, so keep them separate.
                 */
				//如设置了weigh属性，则子视图的宽度需要在父视图确定后才能确定。这里并不是真实的宽度  
                weightedMaxWidth = Math.max(weightedMaxWidth,
                        matchWidthLocally ? margin : measuredWidth);
            } else {
                alternativeMaxWidth = Math.max(alternativeMaxWidth,
                        matchWidthLocally ? margin : measuredWidth);
            }

            i += getChildrenSkipCount(child, i);
        }
		//for 循环结束

		// 下面的这一段代码主要是为useLargestChild属性服务的，不在本文主要分析范围，略过
        if (mTotalLength > 0 && hasDividerBeforeChildAt(count)) {
            mTotalLength += mDividerHeight;
        }

        if (useLargestChild &&
                (heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED)) {
            mTotalLength = 0;

			// 如果设置了useLargestChild属性，且LinearLayout的垂直方向测量模式是AT_MOST或UNSPECIFIED，
      //重新测量总高度，useLargestChild属性会使所有带weight属性的子视图具有最大子视图的最小尺寸
            for (int i = 0; i < count; ++i) {
                final View child = getVirtualChildAt(i);

                if (child == null) {
                    mTotalLength += measureNullChild(i);
                    continue;
                }

                if (child.getVisibility() == GONE) {
                    i += getChildrenSkipCount(child, i);
                    continue;
                }

                final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)
                        child.getLayoutParams();
                // Account for negative margins
                final int totalLength = mTotalLength;
                mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +
                        lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
            }
        }
		//在这两段代码之间还有些杂七杂八的处理，如果读者有兴趣可以自己阅读分析下
		//当测量完子View的大小后，总高度会再加上padding的高度
        // Add in our padding
        mTotalLength += mPaddingTop + mPaddingBottom;

        int heightSize = mTotalLength;
		    //如果设置了minimumheight属性，会根据当前使用高度和最小高度进行比较
        //然后取两者中大的值,getSuggestedMinimumHeight为背景的最小高和视图设置的最小高的大值
        // Check against our minimum height
        heightSize = Math.max(heightSize, getSuggestedMinimumHeight());

        // Reconcile our calculated size with the heightMeasureSpe
		// 把测量出来的高度与测量模式进行匹配，得到最终的高度，MeasureSpec实际上是一个32位的int，高两位是测量模式，
    //剩下的就是大小，因此heightSize = heightSizeAndState & MEASURED_SIZE_MASK;作用就是用来得到大小的精确值（不含测量模式）
        int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
        heightSize = heightSizeAndState & MEASURED_SIZE_MASK;

		//到了这里，会再对带weight属性的子View进行一次测绘
        //首先计算剩余高度

		//算出剩余空间，假如之前是skipp的话，那么几乎可以肯定是有剩余空间（同时有weight）的
        // Either expand children with weight to take up available space or
        // shrink them if they extend beyond our current bounds. If we skipped
        // measurement on any children, we need to measure them now.
        int delta = heightSize - mTotalLength;
        if (skippedMeasure || delta != 0 && totalWeight > 0.0f) {
			//如果设置了weightSum就会使用你设置的weightSum，否则采用当前所有子View的权重和。所以如果要手动设置weightSum的时候，千万别计算错误哦
            float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;

            mTotalLength = 0;
			//这里的代码就和第一次测量很像了
            for (int i = 0; i < count; ++i) {
                final View child = getVirtualChildAt(i);

                if (child.getVisibility() == View.GONE) {
                    continue;
                }

                LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();

                float childExtra = lp.weight;
                if (childExtra > 0) {
					// 全篇最精华的一个地方。。。。拥有weight的时候计算方式,ps:执行到这里时，child依然还没进行自身的measure
					//子控件的weight占比*剩余高度
                    // Child said it could absorb extra space -- give him his share
                    int share = (int) (childExtra * delta / weightSum);
					// weightSum计余
                    weightSum -= childExtra;
					//剩余高度减去分配出去的高度
                    delta -= share;

                    final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                            mPaddingLeft + mPaddingRight +
                                    lp.leftMargin + lp.rightMargin, lp.width);
					//如果是当前LinearLayout的模式是EXACTLY
                    //那么这个子View是没有被测量过的，就需要测量一次
                    //如果不是EXACTLY的，在第一次循环里就被测量一些了
                    // TODO: Use a field like lp.isMeasured to figure out if this
                    // child has been previously measured
                    if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {
                        // child was measured once already above...
                        // base new measurement on stored values
						//如果是非EXACTLY模式下的子View就再加上
                        //weight分配占比*剩余高度
						// 上面已经测量过这个子视图，把上面测量的结果加上根据weight分配的大小
                        int childHeight = child.getMeasuredHeight() + share;
                        if (childHeight < 0) {
                            childHeight = 0;
                        }

						//重新测量一次，因为高度发生了变化
                        child.measure(childWidthMeasureSpec,
                                MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));
                    } else {
                        // child was skipped in the loop above.
                        // Measure for this first time here  

						//如果是EXACTLY模式下的
                        //这里只会把weight占比所拥有的高度分配给你的子View
						// 上面测量的时候被跳过，那么在这里进行测量    
                        child.measure(childWidthMeasureSpec,
                                MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,
                                        MeasureSpec.EXACTLY));
                    }

                    // Child may now not fit in vertical dimension.
                    childState = combineMeasuredStates(childState, child.getMeasuredState()
                            & (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));
                }

                final int margin =  lp.leftMargin + lp.rightMargin;
                final int measuredWidth = child.getMeasuredWidth() + margin;
                maxWidth = Math.max(maxWidth, measuredWidth);

                boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&
                        lp.width == LayoutParams.MATCH_PARENT;

                alternativeMaxWidth = Math.max(alternativeMaxWidth,
                        matchWidthLocally ? margin : measuredWidth);

                allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;

                final int totalLength = mTotalLength;
                mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +
                        lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
            }
            // 这里得到最终高度
            // Add in our padding
            mTotalLength += mPaddingTop + mPaddingBottom;
            // TODO: Should we recompute the heightSpec based on the new total length?
        } else {
			 // 没有weight的情况下，只看useLargestChild参数，如果都无相关，那就走layout流程了，因此这里忽略
            alternativeMaxWidth = Math.max(alternativeMaxWidth,weightedMaxWidth);


            // We have no limit, so make all weighted views as tall as the largest child.
            // Children will have already been measured once.
			// 使所有具有weight属性 视图都和最大子视图一样高，子视图可能在上面已经被测量过一次
            if (useLargestChild && heightMode != MeasureSpec.EXACTLY) {
                for (int i = 0; i < count; i++) {
                    final View child = getVirtualChildAt(i);

                    if (child == null || child.getVisibility() == View.GONE) {
                        continue;
                    }

                    final LinearLayout.LayoutParams lp =
                            (LinearLayout.LayoutParams) child.getLayoutParams();

                    float childExtra = lp.weight;
                    if (childExtra > 0) {
                        child.measure(
                                MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(),
                                        MeasureSpec.EXACTLY),
                                MeasureSpec.makeMeasureSpec(largestChildHeight,
                                        MeasureSpec.EXACTLY));
                    }
                }
            }
        }

        if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {
            maxWidth = alternativeMaxWidth;
        }

        maxWidth += mPaddingLeft + mPaddingRight;

        // Check against our minimum width
        maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

		// 设置测量完的宽高
        setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                heightSizeAndState);

        if (matchWidth) {
			// 使宽度一致
            forceUniformWidth(count, heightMeasureSpec);
        }
    }

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {      
        // mTotalLength作为LinearLayout成员变量，其主要目的是在测量的时候通过累加得到所有子控件的高度和（Vertical）或者宽度和（Horizontal）
        mTotalLength = 0;
        // maxWidth用来记录所有子控件中控件宽度最大的值。
        int maxWidth = 0;
        // 子控件的测量状态，会在遍历子控件测量的时候通过combineMeasuredStates来合并上一个子控件测量状态与当前遍历到的子控件的测量状态，采取的是按位相或
        int childState = 0;

        /**
         * 以下两个最大宽度跟上面的maxWidth最大的区别在于matchWidthLocally这个参数
         * 当matchWidthLocally为真，那么以下两个变量只会跟当前子控件的左右margin和相比较取大值
         * 否则，则跟maxWidth的计算方法一样
         */
        // 子控件中layout_weight<=0的View的最大宽度
        int alternativeMaxWidth = 0;
        // 子控件中layout_weight>0的View的最大宽度
        int weightedMaxWidth = 0;
        // 是否子控件全是match_parent的标志位，用于判断是否需要重新测量
        boolean allFillParent = true;
        // 所有子控件的weight之和
        float totalWeight = 0;

        // 如您所见，得到所有子控件的数量，准确的说，它得到的是所有同级子控件的数量
        // 在官方的注释中也有着对应的例子
        // 比如TableRow，假如TableRow里面有N个控件，而LinearLayout（TableLayout也是继承LinearLayout哦）下有M个TableRow，那么这里返回的是M，而非M*N
        // 但实际上，官方似乎也只是直接返回getChildCount()，起这个方法名的原因估计是为了让人更加的明白，毕竟如果是getChildCount()可能会让人误认为为什么没有返回所有（包括不同级）的子控件数量
        final int count = getVirtualChildCount();

        // 得到测量模式
        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        // 当子控件为match_parent的时候，该值为ture，同时判定的还有上面所说的matchWidthLocally，这个变量决定了子控件的测量是父控件干预还是填充父控件（剩余的空白位置）。
        boolean matchWidth = false;

        boolean skippedMeasure = false;

        final int baselineChildIndex = mBaselineAlignedChildIndex;        
        final boolean useLargestChild = mUseLargestChild;

        int largestChildHeight = Integer.MIN_VALUE;

        // ...... 底下两个for循环
    }

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
        // ...上面的一大堆局部变量
        for (int i = 0; i < count; ++i) {

            final View child = getVirtualChildAt(i);

            if (child == null) {
                // 目前而言，measureNullChild()方法返回的永远是0，估计是设计者留下来以后或许有补充的。
                mTotalLength += measureNullChild(i);
                continue;
            }

            if (child.getVisibility() == GONE) {
               // 同上，返回的都是0。
               // 事实上这里的意思应该是当前遍历到的View为Gone的时候，就跳过这个View，下一句的continue关键字也正是这个意思。
               // 忽略当前的View，这也就是为什么Gone的控件不占用布局资源的原因。（毕竟根本没有分配空间）
                i += getChildrenSkipCount(child, i);
                continue;
            }

            // 根据showDivider的值（before/middle/end）来决定遍历到当前子控件时，高度是否需要加上divider的高度
            // 比如showDivider为before，那么只会在第0个子控件测量时加上divider高度，其余情况下都不加
            if (hasDividerBeforeChildAt(i)) {
                mTotalLength += mDividerWidth;
            }

            final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)
                    child.getLayoutParams();
            // 得到每个子控件的LayoutParams后，累加权重和，后面用于跟weightSum相比较
            totalWeight += lp.weight;

            // 我们都知道，测量模式有三种：
            // * UNSPECIFIED：父控件对子控件无约束
            // * Exactly：父控件对子控件强约束，子控件永远在父控件边界内，越界则裁剪。如果要记忆的话，可以记忆为有对应的具体数值或者是Match_parent
            // * AT_Most：子控件为wrap_content的时候，测量值为AT_MOST。

            // 下面的if/else分支都是跟weight相关
            if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
                // 这个if里面需要满足三个条件：
                // * LinearLayout的高度为match_parent(或者有具体值)
                // * 子控件的高度为0
                // * 子控件的weight>0
                // 这其实就是我们通常情况下用weight时的写法
                // 测量到这里的时候，会给个标志位，稍后再处理。此时会计算总高度
                final int totalLength = mTotalLength;
                mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
                skippedMeasure = true;
            } else {
                // 到这个分支，则需要对不同的情况进行测量
                int oldHeight = Integer.MIN_VALUE;

                if (lp.height == 0 && lp.weight > 0) {
                    // 满足这两个条件，意味着父类即LinearLayout是wrap_content，或者mode为UNSPECIFIED
                    // 那么此时将当前子控件的高度置为wrap_content
                    // 为何需要这么做，主要是因为当父类为wrap_content时，其大小实际上由子控件控制
                    // 我们都知道，自定义控件的时候，通常我们会指定测量模式为wrap_content时的默认大小
                    // 这里强制给定为wrap_content为的就是防止子控件高度为0.
                    oldHeight = 0;
                    lp.height = LayoutParams.WRAP_CONTENT;
                }

                /**【1】*/
                // 下面这句虽然最终调用的是ViewGroup通用的同名方法，但传入的height值是跟平时不一样的
                // 这里可以看到，传入的height是跟weight有关，关于这里，稍后的文字描述会着重阐述
                measureChildBeforeLayout(
                       child, i, widthMeasureSpec, 0, heightMeasureSpec,
                       totalWeight == 0 ? mTotalLength : 0);

                // 重置子控件高度，然后进行精确赋值
                if (oldHeight != Integer.MIN_VALUE) {
                   lp.height = oldHeight;
                }

                final int childHeight = child.getMeasuredHeight();
                final int totalLength = mTotalLength;
                // getNextLocationOffset返回的永远是0，因此这里实际上是比较child测量前后的总高度，取大值。
                mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                       lp.bottomMargin + getNextLocationOffset(child));

                if (useLargestChild) {
                    largestChildHeight = Math.max(childHeight, largestChildHeight);
                }
            }

            if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {
               mBaselineChildTop = mTotalLength;
            }

            if (i < baselineChildIndex && lp.weight > 0) {
                throw new RuntimeException("A child of LinearLayout with index "
                        + "less than mBaselineAlignedChildIndex has weight > 0, which "
                        + "won't work.  Either remove the weight, or don't set "
                        + "mBaselineAlignedChildIndex.");
            }

            boolean matchWidthLocally = false;

            // 还记得我们变量里又说到过matchWidthLocally这个东东吗
            // 当父类（LinearLayout）不是match_parent或者精确值的时候，但子控件却是一个match_parent
            // 那么matchWidthLocally和matchWidth置为true
            // 意味着这个控件将会占据父类（水平方向）的所有空间
            if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {
                matchWidth = true;
                matchWidthLocally = true;
            }

            final int margin = lp.leftMargin + lp.rightMargin;
            final int measuredWidth = child.getMeasuredWidth() + margin;
            maxWidth = Math.max(maxWidth, measuredWidth);
            childState = combineMeasuredStates(childState, child.getMeasuredState());

            allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;

            if (lp.weight > 0) {
                weightedMaxWidth = Math.max(weightedMaxWidth,
                        matchWidthLocally ? margin : measuredWidth);
            } else {
                alternativeMaxWidth = Math.max(alternativeMaxWidth,
                        matchWidthLocally ? margin : measuredWidth);
            }

            i += getChildrenSkipCount(child, i);
        }
        //... 底下第二个for循环
    }
```   
  在第一个for循环中，主要是if(){}else{}分支，判断是heightMode == MeasureSpec.EXACTLY &&
  lp.height == 0 && lp.weight > 0，这个主要是linearLayout测量模式为EXACTLY且子视图明确
 了是使用linearLayout的剩余空间，此时将其上下间距计入总高度并以之前的做对比去大值，并设置
 skippedMeasure标志为true。而在else中则为复杂点，else中首先对lp.height == 0 &&
  lp.weight > 0的子视图的height做预处理使其为LayoutParams.WRAP_CONTENT（因为父类即
  LinearLayout此时是wrap_content，或者mode为UNSPECIFIED），接着对子视图进行测量（
  这个受总权重影响），并将其高度和上下间距计入到总高度中。之后对baselineChildIndex做处理，
  计入总的基线高度并判定基线配置是否合理，不合理抛出异常，最后根据子视图设置最大宽度、
  allFillParent、weightedMaxWidth或alternativeMaxWidth变量。

#### 第2个重要代码块（if(){}else{}分支)）执行前的处理 ####

这里主要对useLargestChild属性处理，执行前提是设置了useLargestChild属性，且LinearLayout的垂直
方向测量模式是AT_MOST或UNSPECIFIED，重新测量总高度，useLargestChild属性会使所有带weight属性的子视
图具有最大子视图的最小尺寸

第2个重要代码块（if(){}else{}分支)）执行逻辑

POST /rest/sur?dk=28192985&ak=23565637&av=4.5.0&c=default-Channel&v=3.0&s=72eec83f97e2d4b15457f2b348b450d2&d=Wp4zp4JKnXIDAPzAGdNq5Fdp&sv=6.2.0&p=MacOSX&t=1531794939&u=&is=0 HTTP/1.1
Host	adash.m.taobao.com
Content-Type	multipart/form-data; boundary=--iphone_BOUNDARY--
Connection	keep-alive
Accept	*/*
User-Agent	%E9%92%89%E9%92%89/400 CFNetwork/901.1 Darwin/17.6.0 (x86_64)
Accept-Language	zh-cn
Accept-Encoding	gzip
Content-Length	702

HTTP/1.1 200 OK
Content-Type	text/plain
Content-Length	8
Last-Modified	Mon, 15 May 2017 18:04:40 GMT
ETag	"ae780585f49b94ce1444eb7d28906123"
Accept-Ranges	bytes
Server	AmazonS3
X-Amz-Cf-Id	jodC9tJqDu4my9HVAend7hMtgKNcrlV4SUHJOKveUP-hHSIJ6ewkig==
Cache-Control	no-cache, no-store, must-revalidate
Date	Tue, 17 Jul 2018 02:28:52 GMT
Proxy-Connection	Keep-alive

import 'package:flutter/material.dart';
import 'package:english_words/english_words.dart';

void main() => runApp(new MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final wordPair = new WordPair.random();   //!!!!
    return new MaterialApp(
      title: 'Welcome to Flutter',
      home: new Scaffold(
        appBar: new AppBar(
          title: new Text('Welcome to Flutter'),
        ),
        body: new Center(
          //child: new Text('Hello World'), // Replace the highlighted text...
          child: new Text(wordPair.asPascalCase),  // With this highlighted text. !!!
        ),
      ),
    );
  }
}

  class RandomWordsState extends State<RandomWords> { //!!!
  }
  ```   

3. 添加这个 state 类之后，IDE 会提示该类缺少 build 方法。接下来，需要添加一个基本的 build 方法，并将生成单词的代码行从 MyApp 类移动到 RandomWordsState 类的 build 方法中，生成词组。  
将 build 方法添加到 RandomWordState 中，如!!!代码所示：

4. 根据!!!部分的更改，从 MyApp 中删除生成单词的代码：

重启应用。如果尝试热重载，则可能会看到警告:

这可能是一个误报，但可以考虑重启应用，以确保更改能正常反映在应用的 UI 界面中。

应用程序应该像之前一样运行，每次热重载或保存应用程序时都会显示一个词组。

[screenshot at completion of third step](step3-screenshot.png)   
#### 有问题吗? ####

如果应用运行不正常，则可以使用以下链接中的代码使其恢复正常

- [lib/main.dart](lib/main.dart)

### 第4步：创建一个无限滚动的 ListView ###
在这一步，可以扩展 RandomWordsState 类，生成并展示词组列表。当用户滑动列表，ListView widget 中显示的列表将无限增长。 ListView 的 builder 工厂构造函数允许按需建立一个延迟加载的列表 view 。

1. \_suggestions 变量向 RandomWordsState 类中添加一个数组列表，用来保存推荐词组。 该变量以下划线(\_)开头，在 Dart 语言中使用下划线前缀表示强制私有。   
此外，添加一个 biggerFont 变量来增大字体。

2. 向 RandomWordsState 类添加一个 \_buildSuggestions() 函数，用于构建一个显示词组的 ListView 。   
ListView 类提供了一个 itemBuilder 属性，这是一个工厂 builder 并作为匿名函数进行回调。它有两个传入参数— BuildContext 上下文和行迭代器 i 。对于每个推荐词组都会执行一次函数调用，迭代器从 0 开始，每调用一次函数就累加 1 。这个模块允许推荐列表在用户滑动时无限增长。  
添加如下代码行：

3.  函数都调用一次 \_buildRow 函数。这个函数每次会在一个 ListTile widget 中展示一条新词组，这将在下一步操作中，使一行数据更有表现力。    
  添加 \_buildRow 函数到 RandomWordsState 类中：

4. 更新 RandomWordsState 类的 build 方法来使用 \_buildSuggestions() 函数，而不是直接调用单词生成库。对部分进行修改：

5. 更新 MyApp 类的 build 方法。从 MyApp 中删除 Scaffold 和 AppBar 实例。这些将由 RandomWordsState 类进行统一管理，这样在下一步操作中，可以使用户从一个页面导航到另一页面时，更方便的更改应用栏中的页面名称。

  用下面高亮的 build 方法替换原始代码：

重启应用程序，将可以看到一个词组清单。尽量向下滑动，将继续看到新的词组。

[screenshot at completion of fourth step](step4-screenshot.png)  
有问题吗?

如果应用运行不正常，则可以使用以下链接中的代码使其恢复正常

- [lib/main.dart](https://gist.githubusercontent.com/Sfshaza/d6f9460a04d3a429eb6ac0b0f07da564/raw/34fe240f4122435c871bb737708ee0357741801c/main.dart)


### 第5步：添加可交互性 ###
在这一步，将为每一行添加可点击的心形图标。当用户点击列表中的条目，切换其“收藏”状态，词组就会添加到收藏栏，或从已保存词组的收藏栏中删除。

1. 添加一个 Set 集合 \_saved 到 RandomWordsState 类。保存用户收藏的词组。Set 集合比 List 更适用于此，因为它不允许重复元素。

2. 在 \_buildRow 函数中，添加 alreadySaved 标志检查来确保一个词组还没有被添加到收藏。

3. 在 \_buildRow() 的 ListTiles widget 中，添加一个心形图标来使用收藏功能，随后将添加与心形图标进行交互的功能。  

  添加以下高亮代码行：

4. 重启应用。现在应该可以在每一行看到心形图标，但还没有交互功能。

5. 在 \_buildRow 函数中使心形可点击。如果词条已经被加入收藏，再次点击它将从收藏中删除。当心形图标被点击，函数将调用 setState() 通知应用框架state已经改变。

  添加高亮代码行：

  <table><tr><td bgcolor=#f0f0f0>
  小贴士： 在 Flutter 的响应式风格框架中，调用 setState() ，将为 State 对象触发 build() 方法的调用，从而实现对UI的更新。
  </td></tr></table>

热重载应用。可以点击任意一行来收藏或取消收藏条目。 请注意，点击一行可以产生从心形图标展开的泼墨动画效果。

[screenshot at completion of 5th step](step5-screenshot.png)  
有问题吗?

如果应用运行不正常，则可以使用以下链接中的代码使其恢复正常。

- [lib/main.dart](https://gist.githubusercontent.com/Sfshaza/936ce0059029a8c6e88aaa826a3789cd/raw/a3065d5c681a81eff32f75a9cd5f4d9a5b24f9ff/main.dart)


### 第6步：导航到新页面 ###
在这一步，将添加一个显示收藏夹的新页面(在 Flutter 中称为 route(路由))。你将学习如何在主路由和新路由之间导航。

在 Flutter 中， Navigator 管理着包含了应用程序所有路由的一个堆栈。将一个路由push到 Navigator 的堆栈，将显示更新为新页面路由。将一个路由 pull 出 Navigator 的堆栈，显示将返回到前一个页面路由。

1. 在 RandomWordsState 类的 build 方法中，向 AppBar 添加一个列表图标。当用户点击列表图标时，包含了已收藏条目的新路由将被 push 到 Navigator 堆栈并显示新页面。
<table><tr><td bgcolor=#f1f1f1>
 小贴士： 某些 widget 属性使用独立 widget(child) 和其他属性例如 action 组成一个子 widget 数组(children)，用方括号([])表示。
</td></tr></table>
将该图标及其相应的 action 操作添加到 build 方法中：

2. 向 RandomWordsState 类添加一个 \_pushSaved() 函数。

重新加载应用程序。列表图标将出现在应用栏中。点击它不会有任何响应，因为 \_pushSaved 这个函数还未实现功能。

3. 当用户点击应用栏中的列表图标时，将建立一个新路由并 push 到 Navigator 的路由堆栈中，这个操作将改变界面显示，展示新的路由页面。   

  新页面的内容使用匿名函数在 MaterialPageRoute widget的builder属性中创建。

  将函数调用添加到 Navigator.push 中作为参数,如高亮代码所示，将路由 push 到 Navigator 的堆栈中。

4. 添加 MaterialPageRoute widget 及其 builder 属性。先添加生成 ListTile widget 的代码。其中 ListTile 的 divideTiles() 方法为每个 ListTile widget 之间添加水平间距。divided变量保存最终生成的所有行，并用 toList() 函数转换为列表。

5. builder 属性返回一个 Scaffold widget ，其中包含了应用栏标题名为 “Saved Suggestions” 的新路由页面。新页面的body属性由包含多个 ListTile widget 的 ListView 组成。

  添加如下代码：

6. 热重载应用程序。对一些条目点击收藏，然后点击应用栏右侧的列表图标。显示出包含收藏夹列表的新页面。注意，Navigator 会在应用栏左侧添加一个“返回”按钮。不必再显式实现 Navigator.pop 。点击返回按钮会返回到主页面。

[screenshot at completion of 6th stepsecond route](step6a-screenshot.png)  
有问题吗?

如果应用运行不正常，则可以使用以下链接中的代码使其恢复正常。

- [lib/main.dart](https://gist.github.com/Sfshaza/bc5547e112e4dc3a1aa87afdf917caeb)

### 第7步：使用主题更改UI ##
在最后一步中，将使用该应用的主题。 theme 控制的是应用程序的观感。可以使用默认主题，该主题取决于使用的模拟器或真机，也可以自定义主题以反映你的品牌。

可以通过配置 ThemeData 类轻松更改应用程序的主题。应用程序目前使用默认主题，现在将更改主要颜色为白色。

1. 将高亮代码添加到 MyApp 类中，可以把应用程序的主题更改为白色：

import 'dart:convert';
List<int> bytes = utf8.encode("Some data");   //UTF8 is deprecated sind Dart 2. But it was just renamed to utf8: List<int> bytes = utf8.encode("Some data");
print(bytes) //[115, 111, 109, 101, 32, 100, 97, 116, 97]

String json = json.encode(user);

DeviceInfoPlugin deviceInfo = new DeviceInfoPlugin();
if(Platform.isIOS){
  IosDeviceInfo iosInfo = await deviceInfo.iosInfo;
  print('Running on ${iosInfo.utsname.machine}');  // e.g. "iPod7,1"
      //ios相关代码
    }else if(Platform.isAndroid){
      AndroidDeviceInfo androidInfo = await deviceInfo.androidInfo;
      print('Running on ${androidInfo.model}');  // e.g. "Moto G (4)"
      //android相关代码
    }

dependencies:
  flutter:
    sdk: flutter
flutter:
  uses-material-design: true
  assets:
    - assets/config.json     //资源所在位置

import 'dart:convert';
import 'dart:async' show Future;
import 'package:flutter/material.dart';
import 'package:flutter/services.dart' show rootBundle;
Future<String> loadAsset() async {
  return await rootBundle.loadString('assets/config.json');
}
void _loadJson() {
  loadAsset().then((value){
    JsonDecoder decoder = new JsonDecoder();
    List<List<String>> json = decoder.convert(value);
    print('姓名：'+json[0][0]+'，年龄：'+json[0][1]);
  });
}