Violinday

源码解读系列（一）：Retrofit 源码重点解读

2019-09-16T00:00:00+08:00

源码解读系列（一）：Retrofit 源码重点解读

Retrofit 源码要点：

设置必要参数，供 ServiceMethod 被调用时使用。

BaseUrl
CallAdapterFactory（RxJavaCallAdapter等）
ConverterFactory（GsonConverterFactory、FastjsonConverterFactory等）
Call.Factory (OkHttpClient)
接口注解、参数、返回值类型的信息

动态代理

调用顺序：

调用请求网络的”接口方法” ==>

动态代理类 ==>

生成 ServiceMethod，调用 invoke ==>

adapt适配合适的Call并返回给用户使用。

ServiceMethod
- 动态代理类的方法调用返回了由 HttpCallAdapter 包装后的 retrofit2.OkHttpCall，即 HttpCallAdapter。
- ServiceMethod (寻找合适的CallAdapterFactory) ==>
  
  调用 CallAdapterFactory#adapt 方法，包装下retrofit2.OkHttpCall ==>
  
  返回 HttpCallAdapter(实现自定义HttpCall接口，和retrofit2.Call接口的方法相似，保证基础请求功能、行为可用)给 Client 调用端 ==>
  
  发送 HttpCallAdapter 到请求队列（HttpCallAdapter.enqueue(自定义 CallBack) ==> retrofit2.OkHttpCall.enqueue(retrofit2.Callback) ==>
  
  okhttp3.Call call = serviceMethod.callFactory.newCall(request) ），最终使用 CallFactory，一般是OkHttpClient，请求网络。
retrofit 源码结构、调用流程图

如有缺漏不足之处，欢迎创建issue，PR 😄

如何从手机媒体库中获取全部视频文件

2018-07-01T00:00:00+08:00

如何从手机媒体库中获取全部视频文件

最近项目在做一个视频选择的功能，一开始的思路是通过 MediaStore获取媒体信息：

  public static List<LocalVideoBean> getLocalVideoList(Context context) {
    List<LocalVideoBean> localVideoBeans = new ArrayList<>();
    // MediaStore.Video.Thumbnails.DATA:视频缩略图的文件路径
    String[] thumbColumns = {MediaStore.Video.Thumbnails.DATA,
            MediaStore.Video.Thumbnails.VIDEO_ID};
    // 视频其他信息的查询条件
    String[] mediaColumns = {MediaStore.Video.Media._ID,
            MediaStore.Video.Media.DATA, MediaStore.Video.Media.DURATION, MediaStore.Video.Media.SIZE};

    Cursor cursor = context.getContentResolver().query(MediaStore.Video.Media
                    .EXTERNAL_CONTENT_URI,
            mediaColumns, null, null, null);

    if (cursor == null) {
      return localVideoBeans;
    }

    try {
      if (cursor.moveToFirst()) {
        do {
          LocalVideoBean info = new LocalVideoBean();
          int id = cursor.getInt(cursor
                  .getColumnIndex(MediaStore.Video.Media._ID));
          Cursor thumbCursor = context.getContentResolver().query(
                  MediaStore.Video.Thumbnails.EXTERNAL_CONTENT_URI,
                  thumbColumns, MediaStore.Video.Thumbnails.VIDEO_ID
                          + "=" + id, null, null);
          if (thumbCursor == null) {
            continue;
          }
          try {
            if (thumbCursor.moveToFirst()) {
              info.setId(id);
              info.setVideoPath(cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media
                      .DATA)));
              ......
              localVideoBeans.add(info);
            }
          } catch (Exception e) {
            LogUtil.e(TAG, e.toString());
          } finally {
            if (!thumbCursor.isClosed()) {
              thumbCursor.close();
            }
          }
        } while (cursor.moveToNext());
      }
    } catch (Exception e) {
      LogUtil.e(TAG, e.toString());
    } finally {
      if (!cursor.isClosed()) {
        cursor.close();
      }
    }
    return localVideoBeans;
  }

可是发现在一加手机5和三星的部分机型上并不能将最近拍的新视频获取到。网络上也大多是相互抄差不多的代码。

后来灵机一动，既然手机上的图库软件都能将最近拍摄的视频加载出来，那么肯定存在实现方式，能将最新的视频加载出来。

后来找到一个图库实现库，看了下源码，其实和上面的代码并没有多少差别：

  /**
   * 获取本地视频
   *
   * @param context
   * @return 本地视频列表
   */
  public static List<LocalVideoBean> getLocalVideoList(Context context) {
    List<LocalVideoBean> localVideoBeans = new ArrayList<>();
    ContentResolver contentResolver = context.getContentResolver();
    String[] projection = new String[]{
            MediaStore.Video.Media._ID,
            MediaStore.Video.Media.DATA,
            MediaStore.Video.Media.DURATION,
            MediaStore.Video.Media.SIZE
    };

    Cursor cursor = contentResolver.query(
            MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
            projection,
            null,
            null,
            MediaStore.Video.Media.DATE_ADDED + " DESC LIMIT " + Integer.MAX_VALUE + " OFFSET " + 0);

    if (cursor != null) {
      try {
        int count = cursor.getCount();
        if (count > 0) {
          cursor.moveToFirst();
          do {
            LocalVideoBean localVideoBean = parseVideoCursor(context, cursor);
            if (localVideoBean != null) {
              localVideoBeans.add(localVideoBean);
            }
          } while (cursor.moveToNext());
        }
      } catch (Exception e) {
        LogUtil.e(TAG, e);
      } finally {
        if (!cursor.isClosed()) {
          cursor.close();
        }
      }
    }
    return localVideoBeans;
  }

和第一段代码并没有什么不同之处，除了一处…

Cursor cursor = contentResolver.query( MediaStore.Video.Media.EXTERNAL_CONTENT_URI, projection, null, null, MediaStore.Video.Media.DATE_ADDED + “ DESC LIMIT “ + Integer.MAX_VALUE + “ OFFSET “ + 0);

为什么变为这个排序条件就可以将最近拍摄的视频取出呢？这需要看看源码是怎么实现的，阅读源码中…

如有缺漏不足之处，欢迎创建issue，PR 😄

具有选择效果的flexablelayout

2018-06-17T00:00:00+08:00

具有选择效果的flexablelayout

最近项目用到标签选择效果，类似

不同的是，要带有选中效果，即，点击选中，并回调选中项。有人可能会问，为什么不说那个FlexBoxLayoutManager + RecyclerView实现点击选中等效果呢？

是因为目前FlexBoxLayoutManager存在问题，在布局的时候回出现位置计算不准确的问题，详情见

回调代码如下：

public interface OnSelectChangedListener {
    void onItemSelected(int position, View view);
}


final String[] labels = new String[]{"程序员", "影视天堂", "美食", "漫画.手绘", "广告图", "旅行.在路上","娱乐八卦", "青春", "谈写作", "短篇小说", "散文", "摄影"};

houseFlexboxlayoutVideolabels.setData(labels);

houseFlexboxlayoutVideolabels.setOnSelectChangedListener(new SelectableFlexboxLayout.OnSelectChangedListener() {
    @Override
    public void onItemSelected(int position, View view) {
        Toast.makeText(getApplication(),labels[position], Toast.LENGTH_LONG).show;
    }
});

下面直接将封装代码奉上，有问题可以留言联系哈。

selectable_flexboxlayout_container.xml

<?xml version="1.0" encoding="utf-8"?>
<com.google.android.flexbox.FlexboxLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:link="http://schemas.android.com/tools"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/house_video_label_flexbox_container"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

</com.google.android.flexbox.FlexboxLayout>

label_item.xml

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/tv_video_label"
    android:layout_width="wrap_content"
    android:layout_height="@dimen/dimen_32dp"
    android:paddingLeft="@dimen/margin_12"
    android:paddingRight="@dimen/margin_12"
    android:gravity="center"
    android:textSize="@dimen/textsize_13"
    android:textColor="@color/color_4a4e59"
    android:background="@drawable/selector_bg_label" /> 

点击效果 selector_bg_label.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:drawable="@drawable/label_selected" android:state_selected="true" />
  <item android:drawable="@drawable/label_selected"
  android:state_checked="true" />
  <item android:drawable="@drawable/label_normal" />
</selector> 

label_selected,label_normal即为自己实现的选中效果

public class SelectableFlexboxLayout extends FlexboxLayout implements View.OnClickListener {

  private FlexboxLayout container;
  private LayoutInflater inflater;
  private ViewHolder mSelectedItem;
  private OnSelectChangedListener mOnSelectChangedListener;
  private List<ViewHolder> holders = new ArrayList<>();

  public SelectableFlexboxLayout(Context context) {
    super(context);
  }

  public SelectableFlexboxLayout(Context context, AttributeSet attrs) {
    super(context, attrs);
    inflater = LayoutInflater.from(getContext());
    inflate(context, R.layout.selectable_flexboxlayout_container, this);
    container = (FlexboxLayout)findViewById(R.id.house_video_label_flexbox_container);
    container.setFlexWrap(FLEX_WRAP_WRAP);
    container.setAlignItems(ALIGN_ITEMS_FLEX_START);
    container.setDividerDrawable(getResources().getDrawable(R.drawable.house_video_label_divider_placeholder));
    container.setShowDivider(SHOW_DIVIDER_MIDDLE);
  }

  public SelectableFlexboxLayout(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
  }

  private void addItems(CharSequence[] titles, int initSelected) {
    if (titles == null || titles.length == 0) return;

    for (int i = 0; i < titles.length; i++) {
      View item = inflater.inflate(R.layout.label_item, container, false);
      ViewHolder holder = new ViewHolder(item, i, titles[i]);
      item.setTag(holder);
      item.setOnClickListener(this);
      holders.add(holder);
      if (i == initSelected) {
        mSelectedItem = holder;
        holder.setItemStatus(true);
      } else {
        holder.setItemStatus(false);
      }
      container.addView(item);
    }
  }

  @Override public void onClick(View v) {
    ViewHolder holder = (ViewHolder) v.getTag();
    if (holder == mSelectedItem) return;

    mSelectedItem.setItemStatus(false);
    mSelectedItem = holder;
    holder.setItemStatus(true);
    if (mOnSelectChangedListener != null) {
      mOnSelectChangedListener.onItemSelected(holder.mPosition, v);
    }
  }

  public static class ViewHolder {
    private Context context;

    private View mRoot;
    private TextView mTitle;
    private int mPosition;

    ViewHolder(final View root, int position, CharSequence title) {
      this.context = root.getContext();
      mRoot = root;
      mTitle = (TextView) root.findViewById(R.id.tv_video_label);
      mTitle.setText(title);
      mPosition = position;
    }

    public void setItemStatus(boolean isSelected) {
      mTitle.setTextColor(isSelected ? Color.WHITE : ContextCompat.getColor(context, R.color.color_4A4E59));
      mRoot.setSelected(isSelected);
    }
  }

  public void setOnSelectChangedListener(OnSelectChangedListener listener) {
    mOnSelectChangedListener = listener;
  }

  public void setSelectPosition(int position) {
    if (mSelectedItem != null && mSelectedItem.mPosition == position) return;
    if (position >= this.getChildCount()) return;

    View view = this.getChildAt(position);
    if (view != null) {
      mSelectedItem.setItemStatus(false);
      mSelectedItem = (ViewHolder) view.getTag();
      mSelectedItem.setItemStatus(true);
    }
  }

  public void setData(String[] titles) {
    setData(titles, 0);
  }

  public void setData(String[] titles, int initIndex) {
    addItems(titles, initIndex);
  }

  public List<ViewHolder> getViewHolders() {
    return holders != null ? Collections.unmodifiableList(holders)
            : Collections.<ViewHolder>emptyList();
  }

  public interface OnSelectChangedListener {
    void onItemSelected(int position, View view);
  }
}

如有缺漏不足之处，欢迎创建issue，PR 😄

《算法》第四版读书笔记（3）

2018-05-30T00:00:00+08:00

《算法》第四版第四章读书笔记思维导图

最近在整理之前读书做的笔记，很多时候都是自己做完笔记，留一份xmind思维导图就放下了，这样很不好，不如拿出来分享给大家，让大家都能有所收获，在此基础上更进一步。

还是先上 xmind思维导图，没有安装xmind的可以直接保存下载图片哈：

思维导图见github链接： https://github.com/violinday/TechWithMindMap

如有缺漏不足之处，欢迎创建issue，PR 😄

前篇

《算法》第四版读书笔记（1）排序

《算法》第四版读书笔记（2）查找

《算法》第四版读书笔记（2）

2018-05-27T00:00:00+08:00

《算法》第四版第三章读书笔记思维导图

最近在整理之前读书做的笔记，很多时候都是自己做完笔记，留一份xmind思维导图就放下了，这样很不好，不如拿出来分享给大家，让大家都能有所收获，在此基础上更进一步。

还是先上 xmind思维导图，没有安装xmind的可以直接保存下载图片哈：

思维导图见github链接： https://github.com/violinday/TechWithMindMap

如有缺漏不足之处，欢迎创建issue，PR 😄

前篇《算法》第四版读书笔记（1）排序

《算法》第四版读书笔记（1）

2018-05-19T00:00:00+08:00

《算法》第四版第二章读书笔记思维导图

最近在整理之前读书做的笔记，很多时候都是自己做完笔记，留一份xmind思维导图就放下了，这样很不好，不如拿出来分享给大家，让大家都能有所收获，在此基础上更进一步。

首先是第二章排序 xmind思维导图：

思维导图见github链接： https://github.com/violinday/TechWithMindMap

如有缺漏不足之处，欢迎创建issue，PR 😄

Android 自定义进度条效果

2018-05-13T00:00:00+08:00

Android 自定义进度条效果

最近再看自定义View的相关代码，比照着网上的效果做了一个，录屏有卡顿

下面直接放出源码：

主要分为两部分重写的onDraw方法、自定义的setProgress(int progress)方法

下面看onDraw方法，分为三步：画背景，画进度，画文字内容。：

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    // TODO: consider storing these as member variables to reduce
    // allocations per draw cycle.
    int paddingLeft = getPaddingLeft();
    int paddingTop = getPaddingTop();
    int paddingRight = getPaddingRight();
    int paddingBottom = getPaddingBottom();

    int contentWidth = getWidth() - paddingLeft - paddingRight;
    int contentHeight = getHeight() - paddingTop - paddingBottom;

    // 2.画背景大圆弧
    int centerX = contentWidth / 2;
    int centerY = contentHeight / 2;
    // 设置圆弧画笔的宽度
    mTextPaint.setStrokeWidth(mRoundWidth);
    // 设置为 ROUND
    mTextPaint.setStrokeCap(Paint.Cap.ROUND);
    mTextPaint.setStrokeJoin(Paint.Join.ROUND);
    // 设置画笔颜色
    mTextPaint.setColor(mRoundColor);
    mTextPaint.setStyle(Paint.Style.STROKE);
    // 半径
    int radius = (int) (centerX - mRoundWidth);
    //避免频繁创建对象
    if (mOval == null) {
        mOval = new RectF(centerX - radius, centerY - radius, centerX + radius, centerY + radius);
    }
    // 画背景圆弧
    canvas.drawArc(mOval, 150, 240, false, mTextPaint);

    //画进度
    mTextPaint.setColor(Color.BLUE);
    // 根据当前百分比计算圆弧扫描的角度
    canvas.drawArc(mOval, mStartAngle, progress/100f  * mSweepAngle, false, mTextPaint);

    // 重置画笔
    mTextPaint.reset();
    mTextPaint.setAntiAlias(true);
    mTextPaint.setTextSize(getResources().getDimensionPixelSize(R.dimen.lb_action_text_size));
    mTextPaint.setColor(Color.RED);
    String mStep = progress + "%";
    // 测量文字的宽高
    mTextPaint.getTextBounds(mStep, 0, mStep.length(), textBounds);
    int dx = (getWidth() - textBounds.width()) / 2;
    // 获取画笔的FontMetrics
    Paint.FontMetrics fontMetrics = mTextPaint.getFontMetrics();
    // 计算文字的基线
    int baseLine = (int) (getHeight() / 2 + (fontMetrics.bottom - fontMetrics.top) / 2 - fontMetrics.bottom);
    // 绘制步数文字
    canvas.drawText(mStep, dx, baseLine, mTextPaint);
}

最后按照一定的效果（Interceptor插值器实现进度效果）更新progress，invalidate页面，从而重新调用onDraw方法回执界面。实现如下方法：

public void setProgress(int setProgress) {
    objectAnimator = ValueAnimator.ofInt(0, setProgress);
    objectAnimator.setDuration(3000);
    // 不同的拦截器实现不同的展示效果 new BounceInterpolator(); 
    // 可以实现类似速度表盘效果
    objectAnimator.setInterpolator(new AccelerateDecelerateInterpolator());
    objectAnimator.setEvaluator(new IntEvaluator());

    objectAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            progress = (int)animation.getAnimatedValue();
            invalidate();
        }
    });
    objectAnimator.start();
}

最后，有什么可以优化的地方请多指教 (ﾟ▽ﾟ)/

Android App（更新时）签名(证书)校验过程源码分析

2018-05-11T00:00:00+08:00

Android App（更新时）签名(证书)校验过程源码分析

还是看到知乎上的一个【问题】，然后翻了翻Android源代码，给出了一个答案，在这里好好整理一下代码流程。

对于非系统APP来说，更新包的时候，需要检查更新包和被更新目标是否是相同的签发者所签发，即更新包和被更新包是由相同的签名密钥签发，此时认为更新包和原应用是由相同实体（发布者）所生成，并建立更新包和已经存在应用的信任关系。这个规则叫做【同源策略TOFU Trust On First Use】——摘自《Android安全架构探究》

APP在升级的时候，会验证新的APK包的完整性，确保没被修改，验证通过，证书信息最终会保存到PackageParser.Package.mSignatures字段中。然后判断新旧证书是否是同一个，接下来进行升级或者拒绝。

接下来感兴趣的话看代码吧~ PackageManagerService

@Override
public int checkSignatures(String pkg1, String pkg2) {
    synchronized (mPackages) {
        final PackageParser.Package p1 = mPackages.get(pkg1);
        final PackageParser.Package p2 = mPackages.get(pkg2);
        if (p1 == null || p1.mExtras == null
                || p2 == null || p2.mExtras == null) {
            return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
        }
        final int callingUid = Binder.getCallingUid();
        final int callingUserId = UserHandle.getUserId(callingUid);
        final PackageSetting ps1 = (PackageSetting) p1.mExtras;
        final PackageSetting ps2 = (PackageSetting) p2.mExtras;
        if (filterAppAccessLPr(ps1, callingUid, callingUserId)
                || filterAppAccessLPr(ps2, callingUid, callingUserId)) {
            return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
        }
        return compareSignatures(p1.mSignatures, p2.mSignatures);
    }
}

然后：


/**
 * Compares two sets of signatures. Returns:
 * <br />
 * {@link PackageManager#SIGNATURE_NEITHER_SIGNED}: if both signature sets are null,
 * <br />
 * {@link PackageManager#SIGNATURE_FIRST_NOT_SIGNED}: if the first signature set is null,
 * <br />
 * {@link PackageManager#SIGNATURE_SECOND_NOT_SIGNED}: if the second signature set is null,
 * <br />
 * {@link PackageManager#SIGNATURE_MATCH}: if the two signature sets are identical,
 * <br />
 * {@link PackageManager#SIGNATURE_NO_MATCH}: if the two signature sets differ.
 */
static int compareSignatures(Signature[] s1, Signature[] s2) {
    if (s1 == null) {
        return s2 == null
                ? PackageManager.SIGNATURE_NEITHER_SIGNED
                : PackageManager.SIGNATURE_FIRST_NOT_SIGNED;
    }

    if (s2 == null) {
        return PackageManager.SIGNATURE_SECOND_NOT_SIGNED;
    }

    if (s1.length != s2.length) {
        return PackageManager.SIGNATURE_NO_MATCH;
    }

    // Since both signature sets are of size 1, we can compare without HashSets.
    if (s1.length == 1) {
        return s1[0].equals(s2[0]) ?
                PackageManager.SIGNATURE_MATCH :
                PackageManager.SIGNATURE_NO_MATCH;
    }

    ArraySet<Signature> set1 = new ArraySet<Signature>();
    for (Signature sig : s1) {
        set1.add(sig);
    }
    ArraySet<Signature> set2 = new ArraySet<Signature>();
    for (Signature sig : s2) {
        set2.add(sig);
    }
    // Make sure s2 contains all signatures in s1.
    if (set1.equals(set2)) {
        return PackageManager.SIGNATURE_MATCH;
    }
    return PackageManager.SIGNATURE_NO_MATCH;
}

咱们来看看Signature类，看看什么时候认为两个包是相同实体发布的，重点关注equals、hashCode方法：

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * 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 android.content.pm;

import android.os.Parcel;
import android.os.Parcelable;

import com.android.internal.util.ArrayUtils;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.security.PublicKey;
import java.security.cert.Certificate;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.util.Arrays;

/**
 * Opaque, immutable representation of a signing certificate associated with an
 * application package.
 * <p>
 * This class name is slightly misleading, since it's not actually a signature.
 */
public class Signature implements Parcelable {
    private final byte[] mSignature;
    private int mHashCode;
    private boolean mHaveHashCode;
    private SoftReference<String> mStringRef;
    private Certificate[] mCertificateChain;

    /**
     * Create Signature from an existing raw byte array.
     */
    public Signature(byte[] signature) {
        mSignature = signature.clone();
        mCertificateChain = null;
    }

    /**
     * Create signature from a certificate chain. Used for backward
     * compatibility.
     *
     * @throws CertificateEncodingException
     * @hide
     */
    public Signature(Certificate[] certificateChain) throws CertificateEncodingException {
        mSignature = certificateChain[0].getEncoded();
        if (certificateChain.length > 1) {
            mCertificateChain = Arrays.copyOfRange(certificateChain, 1, certificateChain.length);
        }
    }

    private static final int parseHexDigit(int nibble) {
        if ('0' <= nibble && nibble <= '9') {
            return nibble - '0';
        } else if ('a' <= nibble && nibble <= 'f') {
            return nibble - 'a' + 10;
        } else if ('A' <= nibble && nibble <= 'F') {
            return nibble - 'A' + 10;
        } else {
            throw new IllegalArgumentException("Invalid character " + nibble + " in hex string");
        }
    }

    /**
     * Create Signature from a text representation previously returned by
     * {@link #toChars} or {@link #toCharsString()}. Signatures are expected to
     * be a hex-encoded ASCII string.
     *
     * @param text hex-encoded string representing the signature
     * @throws IllegalArgumentException when signature is odd-length
     */
    public Signature(String text) {
        final byte[] input = text.getBytes();
        final int N = input.length;

        if (N % 2 != 0) {
            throw new IllegalArgumentException("text size " + N + " is not even");
        }

        final byte[] sig = new byte[N / 2];
        int sigIndex = 0;

        for (int i = 0; i < N;) {
            final int hi = parseHexDigit(input[i++]);
            final int lo = parseHexDigit(input[i++]);
            sig[sigIndex++] = (byte) ((hi << 4) | lo);
        }

        mSignature = sig;
    }

	......
    
    /**
     * Returns the public key for this signature.
     *
     * @throws CertificateException when Signature isn't a valid X.509
     *             certificate; shouldn't happen.
     * @hide
     */
    public PublicKey getPublicKey() throws CertificateException {
        final CertificateFactory certFactory = CertificateFactory.getInstance("X.509"); // DER 编码的X.509格式密钥
        final ByteArrayInputStream bais = new ByteArrayInputStream(mSignature);
        final Certificate cert = certFactory.generateCertificate(bais);
        return cert.getPublicKey();
    }

    ......

    @Override
    public boolean equals(Object obj) {
        try {
            if (obj != null) {
                Signature other = (Signature)obj;
                return this == other || Arrays.equals(mSignature, other.mSignature);
            }
        } catch (ClassCastException e) {
        }
        return false;
    }

    @Override
    public int hashCode() {
        if (mHaveHashCode) {
            return mHashCode;
        }
        mHashCode = Arrays.hashCode(mSignature);
        mHaveHashCode = true;
        return mHashCode;
    }
    ......
}

查看源代码可知，

Opaque, immutable representation of a signing certificate associated with an application package.

它是一个“不透明的、不可变的且与应用程序包关联的签名证书表示类（签名整数对象）”。即，它是一个与某个APK文件关联的DER编码格式签名证书的封装。

查看APK安装过程源码，找到证书数据加载的位置，在PackageManagerService.java类中:

private PackageParser.Package scanPackageInternalLI(PackageParser.Package pkg, File scanFile, int policyFlags, int scanFlags, long currentTime, @Nullable UserHandle user) {
	......

	//注意变量是否APP更新
	final boolean isUpdatedPkg = updatedPkg != null; 
    final boolean isUpdatedSystemPkg = isUpdatedPkg && (policyFlags & PackageParser.PARSE_IS_SYSTEM) != 0;
    
    ......

    //如果APP更新，设置policyFlags
    if (isUpdatedPkg) {
        // An updated system app will not have the PARSE_IS_SYSTEM flag set
        // initially
        policyFlags |= PackageParser.PARSE_IS_SYSTEM;

        // An updated privileged app will not have the PARSE_IS_PRIVILEGED
        // flag set initially
        if ((updatedPkg.pkgPrivateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0) {
            policyFlags |= PackageParser.PARSE_IS_PRIVILEGED;
        }
    }

    // Verify certificates against what was last scanned
    collectCertificatesLI(ps, pkg, scanFile, policyFlags);

}

经过 collectCertificatesLI，collectCertificatesInternal，层层跳转，进入 PackageParse.java

private static void collectCertificates(Package pkg, File apkFile, int parseFlags)
            throws PackageParserException {

    ......

    //省略了V2签名，直接看V1
    StrictJarFile jarFile = null;
    try {
        // Ignore signature stripping protections when verifying APKs from system partition.
        // For those APKs we only care about extracting signer certificates, and don't care
        // about verifying integrity.
        boolean signatureSchemeRollbackProtectionsEnforced =
                (parseFlags & PARSE_IS_SYSTEM_DIR) == 0;
        //初始化 jarFile
        jarFile = new StrictJarFile(
                apkPath,
                !verified, // whether to verify JAR signature
                signatureSchemeRollbackProtectionsEnforced);
        
        ......

        // Verify that entries are signed consistently with the first entry
        // we encountered. Note that for splits, certificates may have
        // already been populated during an earlier parse of a base APK.
        for (ZipEntry entry : toVerify) {
        	//紧接着，调用loadCertificates方法：
            final Certificate[][] entryCerts = loadCertificates(jarFile, entry);
            if (ArrayUtils.isEmpty(entryCerts)) {
                throw new PackageParserException(INSTALL_PARSE_FAILED_NO_CERTIFICATES,
                        "Package " + apkPath + " has no certificates at entry "
                        + entry.getName());
            }
            final Signature[] entrySignatures = convertToSignatures(entryCerts);

            //仅赋值一次，不为空则判断每次获取到的Certificate是否相同，不同则抛出PackageParserException异常
            if (pkg.mCertificates == null) {
                pkg.mCertificates = entryCerts;
                pkg.mSignatures = entrySignatures;
                pkg.mSigningKeys = new ArraySet<PublicKey>();
                for (int i=0; i < entryCerts.length; i++) {
                    pkg.mSigningKeys.add(entryCerts[i][0].getPublicKey());
                }
            } else {
                if (!Signature.areExactMatch(pkg.mSignatures, entrySignatures)) {
                    throw new PackageParserException(
                            INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES, "Package " + apkPath
                                    + " has mismatched certificates at entry "
                                    + entry.getName());
                }
            }
        }
        Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
    } catch (GeneralSecurityException e) {
        throw new PackageParserException(INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING,
                "Failed to collect certificates from " + apkPath, e);
    } catch (IOException | RuntimeException e) {
        throw new PackageParserException(INSTALL_PARSE_FAILED_NO_CERTIFICATES,
                "Failed to collect certificates from " + apkPath, e);
    } finally {
        closeQuietly(jarFile);
    }
}

快到地方了，不要着急，咱们接着看loadCertificates方法：

private static Certificate[][] loadCertificates(StrictJarFile jarFile, ZipEntry entry)
        throws PackageParserException {
    InputStream is = null;
    try {
        // We must read the stream for the JarEntry to retrieve
        // its certificates.
        
        //在getInputStream方法中初始化certificates数据
        is = jarFile.getInputStream(entry);
        
        //在其中调用is[JarFileInputStream类型]的read方法
        //read方法调用verify方法，读取密钥到verifiedEntries中
        readFullyIgnoringContents(is);
        return jarFile.getCertificateChains(entry);
    } catch (IOException | RuntimeException e) {
        throw new PackageParserException(INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION,
                "Failed reading " + entry.getName() + " in " + jarFile, e);
    } finally {
        IoUtils.closeQuietly(is);
    }
}

OK,终于看到出处了，StrictJarFile类中：

public InputStream getInputStream(ZipEntry ze) {
    final InputStream is = getZipInputStream(ze);
    if (isSigned) {
    	//init 方法，创建VerifierEntry
        StrictJarVerifier.VerifierEntry entry = verifier.initEntry(ze.getName());
        if (entry == null) {
            return is;
        }

        return new JarFileInputStream(is, ze.getSize(), entry);
    }

    return is;
} 

public Certificate[][] getCertificateChains(ZipEntry ze) {
    if (isSigned) {
    	//verifier 从哪里来呢，接下来往下看。
        return verifier.getCertificateChains(ze.getName());
    }
    return null;
}

verifier类型为StrictJarVerifier.java类查看源代码可知，verifiedEntries的赋值是在其内部类VerifierEntry的verify()方法中。

//存放密钥的变量
private final Hashtable<String, Certificate[][]> verifiedEntries =
            new Hashtable<String, Certificate[][]>();

......

Certificate[][] getCertificateChains(String name) {
    return verifiedEntries.get(name);
}

又因为verifiedEntries数据从外部传进来，所以还需要继续找。。。源头，在 jarFile = new StrictJarFile(apkPath, !verified, signatureSchemeRollbackProtectionsEnforced); 这句代码中，

private StrictJarFile(String name,
        FileDescriptor fd,
        boolean verify,
        boolean signatureSchemeRollbackProtectionsEnforced)
                throws IOException, SecurityException {
    this.nativeHandle = nativeOpenJarFile(name, fd.getInt$());
    this.fd = fd;

    try {
        // Read the MANIFEST and signature files up front and try to
        // parse them. We never want to accept a JAR File with broken signatures
        // or manifests, so it's best to throw as early as possible.
        if (verify) {
            HashMap<String, byte[]> metaEntries = getMetaEntries();
            this.manifest = new StrictJarManifest(metaEntries.get(JarFile.MANIFEST_NAME), true);
            this.verifier =
                    new StrictJarVerifier(
                            name,
                            manifest,
                            metaEntries,
                            signatureSchemeRollbackProtectionsEnforced);
            Set<String> files = manifest.getEntries().keySet();
            for (String file : files) {
                if (findEntry(file) == null) {
                    throw new SecurityException("File " + file + " in manifest does not exist");
                }
            }
            //此处readCertificates为最终数据初始化的地方
            isSigned = verifier.readCertificates() && verifier.isSignedJar();
        } else {
            isSigned = false;
            this.manifest = null;
            this.verifier = null;
        }
    } catch (IOException | SecurityException e) {
        nativeClose(this.nativeHandle);
        IoUtils.closeQuietly(fd);
        closed = true;
        throw e;
    }

    guard.open("close");
}

还是要到StrictJarVerifier.java类中

/**
 * If the associated JAR file is signed, check on the validity of all of the
 * known signatures.
 *
 * @return {@code true} if the associated JAR is signed and an internal
 *         check verifies the validity of the signature(s). {@code false} if
 *         the associated JAR file has no entries at all in its {@code
 *         META-INF} directory. This situation is indicative of an invalid
 *         JAR file.
 *         <p>
 *         Will also return {@code true} if the JAR file is <i>not</i>
 *         signed.
 * @throws SecurityException
 *             if the JAR file is signed and it is determined that a
 *             signature block file contains an invalid signature for the
 *             corresponding signature file.
 */
synchronized boolean readCertificates() {
    if (metaEntries.isEmpty()) {
        return false;
    }

    Iterator<String> it = metaEntries.keySet().iterator();
    while (it.hasNext()) {
        String key = it.next();
        //只解析这三种类型的密钥
        if (key.endsWith(".DSA") || key.endsWith(".RSA") || key.endsWith(".EC")) {
            verifyCertificate(key);
            it.remove();
        }
    }
    return true;
}


/**
 * @param certFile
 */
private void verifyCertificate(String certFile) {
    ...... //省略了使用证书（如RSA这行书）中的 .SF属性块对整个MF文件验证的过程

    //验证通过，signature在StrictJarVerifier类中的initEntry方法中变成二维数组，
    //放进StrictJarVerifier 的verifiedEntries变量中
    signatures.put(signatureFile, entries);
}

至此分析结束

参考：

Android中，在子线程使用Toast会报错？

2018-05-10T00:00:00+08:00

Android中，在子线程使用Toast会报错？

在知乎看到一个问题： https://www.zhihu.com/question/51099935/answer/387828477

在子线程中使用Toast抛出异常，提示错误显示:Can’t create handler inside thread that has not called Looper.prepare()

@森羴的回答：https://www.zhihu.com/question/51099935/answer/125487934

Toast,Handler,分析为什么抛异常。ActivityThread和ViewRootImpl分析到底什么叫子线程不能更新UI。

Toast本质上是一个window，跟activity是平级的，checkThread只是Activity维护的View树的行为。Toast使用的无所谓是不是主线程Handler，吐司操作的是window，不属于checkThread抛主线程不能更新UI异常的管理范畴。它用Handler只是为了用队列和时间控制排队显示吐司。即使是子线程，先Looper.prepare,再show吐司，再Looper.loop一样可以吐出来，只不过loop操作会阻塞这个线程，没人这么玩罢了，都是让Toast用主线程的Handler，这个是在ActivityThread里初始化的，本来就是阻塞处理所有的UI交互逻辑。贴个代码吧还是～～

new Thread(){
        public void run(){
          Looper.prepare();//给当前线程初始化Looper
          Toast.makeText(getApplicationContext(),"你猜我能不能弹出来～～",0).show();
          //Toast初始化的时候会new Handler();无参构造默认获取当前线程的Looper，如果没有prepare过，则抛出题主描述的异常。上一句代码初始化过了，就不会出错。
          Looper.loop();
          //这句执行，Toast排队show所依赖的Handler发出的消息就有人处理了，Toast就可以吐出来了。但是，这个Thread也阻塞这里了，因为loop()是个for (;;) ...
        }
  }.start();

我的补充,和 @森羴回答结合起来看效果更好😄：

public static Toast makeText(Context context, CharSequence text, @Duration int duration) {
    return makeText(context, null, text, duration);//①注意，这里looper为空
}

public static Toast makeText(@NonNull Context context, @Nullable Looper looper,
            @NonNull CharSequence text, @Duration int duration) {
        Toast result = new Toast(context, looper);//② looper为null

        LayoutInflater inflate = (LayoutInflater)
                context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View v = inflate.inflate(com.android.internal.R.layout.transient_notification, null);
        TextView tv = (TextView)v.findViewById(com.android.internal.R.id.message);
        tv.setText(text);

        result.mNextView = v;
        result.mDuration = duration;

        return result;
    }

public Toast(@NonNull Context context, @Nullable Looper looper) {
        mContext = context;
        mTN = new TN(context.getPackageName(), looper);//③创建TN
        mTN.mY = context.getResources().getDimensionPixelSize(
                com.android.internal.R.dimen.toast_y_offset);
        mTN.mGravity = context.getResources().getInteger(
                com.android.internal.R.integer.config_toastDefaultGravity);
    }

其中：

 mTN = new TN(context.getPackageName(), looper);

TN(String packageName, @Nullable Looper looper) {
    ......
    if (looper == null) {
        // Use Looper.myLooper() if looper is not specified.
        //④从当前线程获取looper，一般为主线程，故在主线程中时，让Toast用主线程的Looper创建一个Handler
        looper = Looper.myLooper(); 
        if (looper == null) {
            throw new RuntimeException(
                    "Can't toast on a thread that has not called Looper.prepare()");
        }
    }
    mHandler = new Handler(looper, null) {
    }
    ......
}

看源码可以很清楚地分析出问题原因，多看源码对上层APP开发有很大益处 ; )

android.intent.category.DEFAULT的用途和使用

2018-04-30T00:00:00+08:00

android.intent.category.DEFAULT

两个概念

explicit(明确，显式) intent

  Intent intent= new Intent(MainActivity.this, Secondary.class)； 

implicit(隐藏,隐式) intent

Implicit Intent没有明确的指定要启动哪个Activity ，而是通过设置一些Intent Filter来让系统去筛选合适的Acitivity去启动。

在官方文档中有这么一段话：

Android treats all implicit intents passed to startActivity() as if they contained at least one category: “android.intent.category.DEFAULT” (the CATEGORY_DEFAULT constant). Therefore, activities that are willing to receive implicit intents must include “android.intent.category.DEFAULT” in their intent filters

意思是说，每一个通过 startActivity() 方法发出的隐式 Intent 都至少有一个 category，就是 “android.intent.category.DEFAULT”，所以只要是想接收一个隐式 Intent 的 Activity 都应该包括”android.intent.category.DEFAULT” category，不然将导致 Intent 匹配失败。

即：如果要启动的Activity的在AndroidManifest.xml文件中没有android.intent.category.DEFAULT这个category的话，就会匹配失败。

从上面的论述还可以获得以下信息：

一个 Intent 可以有多个 category，但至少会有一个，也是默认的一个 category。
只有 Intent 的所有 category 都匹配上，Activity 才会接收这个 Intent。

Android 源代码【正在寻找自动添加的地方…】：

寻找ing...

引用： https://blog.csdn.net/jason0539/article/details/10049899

Violinday

源码解读系列（一）：Retrofit 源码重点解读

源码解读系列（一）：Retrofit 源码重点解读

Retrofit 源码要点：

如何从手机媒体库中获取全部视频文件

如何从手机媒体库中获取全部视频文件

具有选择效果的flexablelayout

具有选择效果的flexablelayout

《算法》 第四版 读书笔记（3）

《算法》 第四版 第四章 读书笔记 思维导图

《算法》 第四版 读书笔记（2）

《算法》 第四版 第三章 读书笔记 思维导图

《算法》 第四版 读书笔记（1）

《算法》 第四版 第二章 读书笔记 思维导图

Android 自定义进度条效果

Android 自定义进度条效果

Android App（更新时）签名(证书)校验过程源码分析

Android App（更新时）签名(证书)校验过程源码分析

Android中，在子线程使用Toast会报错？

Android中，在子线程使用Toast会报错？

android.intent.category.DEFAULT的用途和使用

android.intent.category.DEFAULT

两个概念

《算法》第四版读书笔记（3）

《算法》第四版第四章读书笔记思维导图

《算法》第四版读书笔记（2）

《算法》第四版第三章读书笔记思维导图

《算法》第四版读书笔记（1）

《算法》第四版第二章读书笔记思维导图