探索Fresco图片框架so加载失败导致崩溃的问题

public class ImagePipelineNativeLoader {
  public static final String DSO_NAME = "imagepipeline";


  public static final List<String> DEPENDENCIES;
  static {
    List<String> dependencies = new ArrayList<String>();
    DEPENDENCIES = Collections.unmodifiableList(dependencies);
  }


  public static void load() {
    SoLoader.loadLibrary("imagepipeline");
  }
}

// 获取ImagePipeline对象   Fresco的一些配置包括缓存策略及编码等等的配置就在这里面加载
ImagePipeline mImagePipeline = Fresco.getImagePipeline();


=================进入源码==================================
/** Gets the image pipeline instance. */
  public static ImagePipeline getImagePipeline() {
    return getImagePipelineFactory().getImagePipeline();
  }
  //这一段都是初始化配置信息等等一些操作
  public ImagePipeline getImagePipeline() {
    if (mImagePipeline == null) {
      mImagePipeline =
          new ImagePipeline(
              getProducerSequenceFactory(),
              mConfig.getRequestListeners(),
              mConfig.getIsPrefetchEnabledSupplier(),
              getBitmapMemoryCache(),
              getEncodedMemoryCache(),
              getMainBufferedDiskCache(),
              getSmallImageBufferedDiskCache(),
              mConfig.getCacheKeyFactory(),
              mThreadHandoffProducerQueue,
              Suppliers.of(false),
              mConfig.getExperiments().isLazyDataSource());
    }
    return mImagePipeline;
  }
此处省略若干方法，经过一系列的追踪
  private MemoryChunkPool getMemoryChunkPool(@MemoryChunkType int memoryChunkType) {
    switch (memoryChunkType) {
      case NATIVE_MEMORY:
        return getNativeMemoryChunkPool();
      case BUFFER_MEMORY:
        return getBufferMemoryChunkPool();
      default:
        throw new IllegalArgumentException("Invalid MemoryChunkType");
    }
  }
可以看到 这地方了Fresco的缓存模式被分为了两种，一种是native层缓存 一种是磁盘缓存，我们进入它的native缓存调用的方法里面看看发生了什么
  public NativeMemoryChunkPool getNativeMemoryChunkPool() {
    if (mNativeMemoryChunkPool == null) {
      mNativeMemoryChunkPool =
          new NativeMemoryChunkPool(
              mConfig.getMemoryTrimmableRegistry(),
              mConfig.getMemoryChunkPoolParams(),
              mConfig.getMemoryChunkPoolStatsTracker());
    }
    return mNativeMemoryChunkPool;
  }
这个方法返回了一个NativeMemoryChunkPool这东西，进去后发现
public class NativeMemoryChunkPool extends MemoryChunkPool {


  public NativeMemoryChunkPool(
      MemoryTrimmableRegistry memoryTrimmableRegistry,
      PoolParams poolParams,
      PoolStatsTracker nativeMemoryChunkPoolStatsTracker) {
    super(memoryTrimmableRegistry, poolParams, nativeMemoryChunkPoolStatsTracker);
  }


  @Override
  protected NativeMemoryChunk alloc(int bucketedSize) {
    return new NativeMemoryChunk(bucketedSize);
  }
}
它的alloc方法调用了nativeMemoryChunk  看着名字我们就怀疑它就是初始化ImagePipelineNativeLoader.load()的地方，进去后果不其然


 /**
 * Wrapper around chunk of native memory.
 *
 * <p>This class uses JNI to obtain pointer to native memory and read/write data from/to it.
 *
 * <p>Native code used by this class is shipped as part of libimagepipeline.so @ThreadSafe
 */
@DoNotStrip
public class NativeMemoryChunk implements MemoryChunk, Closeable {
  private static final String TAG = "NativeMemoryChunk";


  static {
    ImagePipelineNativeLoader.load();
  }


  /**
   * Address of memory chunk wrapped by this NativeMemoryChunk
   */
  private final long mNativePtr;


}

/**
     * If true, the pipeline will use alternative implementations without native code.
     *
     * @param nativeCodeDisabled set true for disabling native implementation.
     * @return The Builder itself for chaining
     */
    public ImagePipelineConfig.Builder setNativeCodeDisabled(boolean nativeCodeDisabled) {
      mNativeCodeDisabled = nativeCodeDisabled;
      return mConfigBuilder;
    }

private static int getMemoryChunkType(
      final Builder builder, final ImagePipelineExperiments imagePipelineExperiments) {
    if (builder.mMemoryChunkType != null) {
      return builder.mMemoryChunkType;
    } else if (imagePipelineExperiments.isNativeCodeDisabled()) {
      return MemoryChunkType.BUFFER_MEMORY;
    } else {
      return MemoryChunkType.NATIVE_MEMORY;
    }
  }

private MemoryChunkPool getMemoryChunkPool(@MemoryChunkType int memoryChunkType) {
    switch (memoryChunkType) {
      case NATIVE_MEMORY:
        return getNativeMemoryChunkPool();
      case BUFFER_MEMORY:
        return getBufferMemoryChunkPool();
      default:
        throw new IllegalArgumentException("Invalid MemoryChunkType");
    }
  }

/**
 * Wrapper around chunk using a direct ByteBuffer in native memory. A direct ByteBuffer is composed
 * of a Java {@link ByteBuffer} object allocated on the Java heap and the underlying buffer which is
 * in native memory.
 *
 * <p>The buffer in native memory will be released when the Java object gets garbage collected.
 */
public class BufferMemoryChunk implements MemoryChunk, Closeable {
  private static final String TAG = "BufferMemoryChunk";


  /** Internal representation of the chunk */
  private ByteBuffer mBuffer;


  /** Size of the ByteBuffer */
  private final int mSize;


  /** Unique identifier of the chunk */
  private final long mId;


  public BufferMemoryChunk(final int size) {}
}