learnNG
learnNG

Glide V4 源码浅析（上）-- 主流程分析

1. Glide的作用

图片加载基本是每个APP都需要的基础功能，而在使用的过程中我们需要考虑到图片的加载方式、缓存、多媒体等问题，而Glide帮我们完成这一类的工作，并且提供了一套易用的API。

Glide的官方介绍如下：

Glide是一个快速高效的Android图片加载库，注重于平滑的滚动。Glide提供了易用的API，高性能、可扩展的图片解码管道（decode pipeline），以及自动的资源池技术。

总结起来它的优势如下：

  1. 可加载多媒体格式多样化，如Gif、Webp、Video等
  2. 加载过程绑定生命周期，通过生命周期管理实现更好的实现资源利用
  3. 高效缓存策略，拥有2层内存缓存和磁盘缓存。

2. Glide的使用方法

由于Glide的API十分灵活，开发者可以通过各种设置来达到不同加载效果，因此这里仅就最基础的使用方式进行分析，至于glide下载与安装可以直接参考官方项目地址下载安装最新版。

Glide项目地址：github

加载一张圆形图片

//初始化一个RequestOptions，并在其中通过circleCropTransform()设置圆形
RequestOptions mRequestOptions = new RequestOptions().circleCropTransform();
//通过Glide将图片地址为myUrl的图片以圆形的裁剪方式加载到imageView中
Glide.with(fragment)
    .load(myUrl)
    .apply(mRequestOptions)
    .into(imageView);

3. Glide的工作原理

根据上面的例子，Glide主要的流程如下图
Glide V4 源码浅析（上）-- 主流程分析_第1张图片

短短几行代码就实现了将图片加载到我们指定地方，其中Glide框架帮我们完成了资源的不同类型（PNG、JPG、WEBP、GIF）和不同来源（网络、本地）的加载，以及对应的缓存策略。

3.1 Glide.with()

Glide.with()一共有个6重载方法，其中一个已经被标记为Deprecated了，分别对应在不同的情景下使用，每种重载方法的调用逻辑是一致的，都是先调用getRetriever()，之后再调用get()方法获取RequestManager，这里我们以比较常用的Activity作为例子

  public static RequestManager with(@NonNull Activity activity) {
    return getRetriever(activity).get(activity);
  }
3.1.1 如上文写的一样先调用getRetriever获取RequestManagerRetriever
  private static RequestManagerRetriever getRetriever(@Nullable Context context) {
    //对传入的Context进行判空
    Preconditions.checkNotNull(
        context,
        "You cannot start a load on a not yet attached View or a Fragment where getActivity() "
            + "returns null (which usually occurs when getActivity() is called before the Fragment "
            + "is attached or after the Fragment is destroyed).");
    return Glide.get(context).getRequestManagerRetriever();
  }

其中在Glide.get(context)中，完成了对Glide单例的初始化

  //双重验证单例
  public static Glide get(@NonNull Context context) {
    if (glide == null) {
      synchronized (Glide.class) {
        if (glide == null) {
          checkAndInitializeGlide(context);
        }
      }
    }

    return glide;
  }

初始化Glide会在gilde.build()时创建RequestManagerRetriever

  @NonNull
  Glide build(@NonNull Context context) {
    //创建默认参数
    ......

    RequestManagerRetriever requestManagerRetriever =
        new RequestManagerRetriever(requestManagerFactory);

    //创建将参数传入Glide的构造函数完成初始化
    ......
  }

RequestManagerRetriever根据官方注解的描述是一个用于创建或者获取现有的RequestManager的集合，此时我们在with()方法中通过getRetriever(activity)获取到生成的requestManagerRetriever.

3.1.2 再通过RequestManagerRetriever获取RequestManager.

RequestManagerRetriever的get()方法和with()方法一样拥有许多重载方法，我们还是继续以Activity为例

  public RequestManager get(@NonNull Activity activity) {
    if (Util.isOnBackgroundThread()) {
      //如果当前不在主线程，通过调用get(@NonNull Context context)调用getApplicationManager
      return get(activity.getApplicationContext());
    } else {
      assertNotDestroyed(activity);
      android.app.FragmentManager fm = activity.getFragmentManager();
      return fragmentGet(
          activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
    }
  }
  
  
  private RequestManager fragmentGet(@NonNull Context context,
      @NonNull android.app.FragmentManager fm,
      @Nullable android.app.Fragment parentHint,
      boolean isParentVisible) {
    RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
      Glide glide = Glide.get(context);
      requestManager =
          factory.build(
              glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
      current.setRequestManager(requestManager);
    }
    return requestManager;
  }

可见在调用Activity的get时实际是通过fragmentGet方法中的factory.build()产生返回的requestManager的。

 //RequestManagerRetriever的构造函数中创建了factory
 public RequestManagerRetriever(@Nullable RequestManagerFactory factory) {
    //若创建RequestManagerRetriever未传入RequestManagerFactory，则使用DEFAULT_FACTORY作为factory
    this.factory = factory != null ? factory : DEFAULT_FACTORY;
    handler = new Handler(Looper.getMainLooper(), this /* Callback */);
  }
  
 private static final RequestManagerFactory DEFAULT_FACTORY = new RequestManagerFactory() {
    @NonNull
    @Override
    public RequestManager build(@NonNull Glide glide, @NonNull Lifecycle lifecycle,
        @NonNull RequestManagerTreeNode requestManagerTreeNode, @NonNull Context context) {
      //创建对应的RequestManager
      return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);
    }
  };

在factory中通过new RequestManager()创建所需的RequestManager。至此Glide.with()分析完成

3.2 load()

在load方法中我们一般传入我们所需的资源文件，Glide提供了很多种重载方法用于兼容不同类型的加载方式，如Bitmap，Drawable，Uri等。
在RequestManager中对于load方法一般直接通过asDrawable().load(xxx)方法继续调用。当然除了asDrawable()，Glide还提供asFile()、asGif()、asBitmap()等方法。而他们最终都会调用到as(xxx)方法用于返回一个RequestBuilder

  public RequestBuilder asDrawable() {
    return as(Drawable.class);
  }
  
  public  RequestBuilder as(
      @NonNull Class resourceClass) {
    return new RequestBuilder<>(glide, this, resourceClass, context);
  }

因此上文中asDrawable().load(xxx)方法最终会调用到RequestBuilder中的load(xxx)方法,而这些方法无一例外会调用到loadGeneric()方法

  private RequestBuilder loadGeneric(@Nullable Object model) {
    this.model = model;
    isModelSet = true;
    return this;
  }

在loadGeneric仅对model进行了赋值，因此整个load()操作总结下主要作用如下：1.生成RequestBuilder，2.对传入model进行赋值保存。

3.3 apply()

我们使用 apply() 方法将我们自定义的requestOptions传入

  public RequestBuilder apply(@NonNull RequestOptions requestOptions) {
    Preconditions.checkNotNull(requestOptions);
    this.requestOptions = getMutableOptions().apply(requestOptions);
    return this;
  }
  
  //获取现有的RequestOptions
  protected RequestOptions getMutableOptions() {
    //如果目前的requestOptions与defaultRequestOptions一致则表明未进行修改，为了保证源文件不被修改，使用clone方法创建一个新的requestOptions回传回去
    return defaultRequestOptions == this.requestOptions
        ? this.requestOptions.clone() : this.requestOptions;
  }

由此可知最终会调用到RequestBuilder中RequestOptions的apply()方法

  public RequestOptions apply(@NonNull RequestOptions other) {
    if (isAutoCloneEnabled) {
      return clone().apply(other);
    }

    if (isSet(other.fields, SIZE_MULTIPLIER)) {
      sizeMultiplier = other.sizeMultiplier;
    }
    if (isSet(other.fields, USE_UNLIMITED_SOURCE_GENERATORS_POOL)) {
      useUnlimitedSourceGeneratorsPool = other.useUnlimitedSourceGeneratorsPool;
    }
    if (isSet(other.fields, USE_ANIMATION_POOL)) {
      useAnimationPool = other.useAnimationPool;
    }
    if (isSet(other.fields, DISK_CACHE_STRATEGY)) {
      diskCacheStrategy = other.diskCacheStrategy;
    }
    if (isSet(other.fields, PRIORITY)) {
      priority = other.priority;
    }
    if (isSet(other.fields, ERROR_PLACEHOLDER)) {
      errorPlaceholder = other.errorPlaceholder;
    }
    if (isSet(other.fields, ERROR_ID)) {
      errorId = other.errorId;
    }
    if (isSet(other.fields, PLACEHOLDER)) {
      placeholderDrawable = other.placeholderDrawable;
    }
    if (isSet(other.fields, PLACEHOLDER_ID)) {
      placeholderId = other.placeholderId;
    }
    if (isSet(other.fields, IS_CACHEABLE)) {
      isCacheable = other.isCacheable;
    }
    if (isSet(other.fields, OVERRIDE)) {
      overrideWidth = other.overrideWidth;
      overrideHeight = other.overrideHeight;
    }
    if (isSet(other.fields, SIGNATURE)) {
      signature = other.signature;
    }
    if (isSet(other.fields, RESOURCE_CLASS)) {
      resourceClass = other.resourceClass;
    }
    if (isSet(other.fields, FALLBACK)) {
      fallbackDrawable = other.fallbackDrawable;
    }
    if (isSet(other.fields, FALLBACK_ID)) {
      fallbackId = other.fallbackId;
    }
    if (isSet(other.fields, THEME)) {
      theme = other.theme;
    }
    if (isSet(other.fields, TRANSFORMATION_ALLOWED)) {
      isTransformationAllowed = other.isTransformationAllowed;
    }
    if (isSet(other.fields, TRANSFORMATION_REQUIRED)) {
      isTransformationRequired = other.isTransformationRequired;
    }
    if (isSet(other.fields, TRANSFORMATION)) {
      transformations.putAll(other.transformations);
      isScaleOnlyOrNoTransform = other.isScaleOnlyOrNoTransform;
    }
    if (isSet(other.fields, ONLY_RETRIEVE_FROM_CACHE)) {
      onlyRetrieveFromCache = other.onlyRetrieveFromCache;
    }

    // Applying options with dontTransform() is expected to clear our transformations.
    if (!isTransformationAllowed) {
      transformations.clear();
      fields &= ~TRANSFORMATION;
      isTransformationRequired = false;
      fields &= ~TRANSFORMATION_REQUIRED;
      isScaleOnlyOrNoTransform = true;
    }

    fields |= other.fields;
    options.putAll(other.options);

    return selfOrThrowIfLocked();
  }

在apply()方法中通过isSet方法比较对应的标志位的值从而对相应属性进行修改。此时apply()逻辑完成，主要用于对用户的设置进行配置。

3.4 into()

into()方法是我们此次分析流程中的最后一步，可以看到前文提到的with()、load()、apply()这些方法中均未涉及到图片的加载和显示过程，更多是做一些初始化和参数的配置。因此可以猜测缓存加载的相关操作应该是房子into()中

  public ViewTarget into(@NonNull ImageView view) {
    Util.assertMainThread();
    Preconditions.checkNotNull(view);

    //省略部分代码，根据imageView的ScaleType设置相应的RequestOptions
    ......

    return into(
        glideContext.buildImageViewTarget(view, transcodeClass),
        /*targetListener=*/ null,
        requestOptions);
  }
  
  
  private > Y into(
      @NonNull Y target,
      @Nullable RequestListener targetListener,
      @NonNull RequestOptions options) {
    Util.assertMainThread();
    Preconditions.checkNotNull(target);
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }

    options = options.autoClone();
    //初始化Request
    Request request = buildRequest(target, targetListener, options);

    Request previous = target.getRequest();
    //将此次Request与之前的Request相比较看能否复用
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      request.recycle();
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        previous.begin();
      }
      return target;
    }

    requestManager.clear(target);
    //将当前生成的request赋值给target
    target.setRequest(request);
    //通过requestManager追踪target和request
    requestManager.track(target, request);

    return target;
  }
3.4.1 生成对应的ViewTarget

根据传入的view和上文提到资源类型(asDrawable()所传入的类型)生成一个对应的ViewTarget，通过glideContext.buildImageViewTarget的层层调用最终会调用到ImageViewTargetFactory中的buildTarget方法中

  public  ViewTarget buildTarget(@NonNull ImageView view,
      @NonNull Class clazz) {
    if (Bitmap.class.equals(clazz)) {
      return (ViewTarget) new BitmapImageViewTarget(view);
    } else if (Drawable.class.isAssignableFrom(clazz)) {
      return (ViewTarget) new DrawableImageViewTarget(view);
    } else {
      throw new IllegalArgumentException(
          "Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
    }
  }

这里会传入资源类型生成对应的ViewTarget

3.4.2 生成对应的request

通过buildRequest最终会调用buildRequestRecursive()方法

private Request buildRequestRecursive(
      Target target,
      @Nullable RequestListener targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      RequestOptions requestOptions) {

    // 根据使用glide加载图片时是否传入了errorBuilder(通过error()方法传入)来确定是否会生成errorRequestCoordinator
    ErrorRequestCoordinator errorRequestCoordinator = null;
    if (errorBuilder != null) {
      errorRequestCoordinator = new ErrorRequestCoordinator(parentCoordinator);
      parentCoordinator = errorRequestCoordinator;
    }

    //初始化mainRequest
    Request mainRequest =
        buildThumbnailRequestRecursive(
            target,
            targetListener,
            parentCoordinator,
            transitionOptions,
            priority,
            overrideWidth,
            overrideHeight,
            requestOptions);

    //如果未生成errorRequestCoordinator则直接返回mainRequest
    if (errorRequestCoordinator == null) {
      return mainRequest;
    }

    int errorOverrideWidth = errorBuilder.requestOptions.getOverrideWidth();
    int errorOverrideHeight = errorBuilder.requestOptions.getOverrideHeight();
    if (Util.isValidDimensions(overrideWidth, overrideHeight)
        && !errorBuilder.requestOptions.isValidOverride()) {
      errorOverrideWidth = requestOptions.getOverrideWidth();
      errorOverrideHeight = requestOptions.getOverrideHeight();
    }

    //如果errorRequestCoordinator存在则生成errorRequest并返回
    Request errorRequest = errorBuilder.buildRequestRecursive(
        target,
        targetListener,
        errorRequestCoordinator,
        errorBuilder.transitionOptions,
        errorBuilder.requestOptions.getPriority(),
        errorOverrideWidth,
        errorOverrideHeight,
        errorBuilder.requestOptions);
    errorRequestCoordinator.setRequests(mainRequest, errorRequest);
    return errorRequestCoordinator;
  }

这里我们可以看到生成request时会先通过errorBuilder存在与否分别返回不同的request，但无论返回哪个request，其中都需要mainRequest。

private Request buildThumbnailRequestRecursive(
      Target target,
      RequestListener targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      RequestOptions requestOptions) {
    //判断是否存在thumbnailBuilder，由此决定是否创建thumbRequest
    if (thumbnailBuilder != null) {
      //省略部分代码
      ......
      //创建thumbRequest
      Request thumbnailRequest =
          obtainRequest(
              target,
              targetListener,
              thumbnailOptions,
              coordinator,
              transitionOptions,
              getThumbnailPriority(priority),
              overrideWidth,
              overrideHeight);
      //将fullRequest和thumbnailRequest放入coordinator中
      coordinator.setRequests(fullRequest, thumbnailRequest);
      return coordinator;
    //若未传入对应的thumbnailBuilder判断是否传入对应的thumbSizeMultiplier(float类型的缩放比例)，与上方逻辑类似创建对应的thumbnailRequest并和fullRequest放入coordinator中，并返回。
    } else if (thumbSizeMultiplier != null) {
      //省略部分代码
    } else {
      // 若无thumbnail相关参数，则直接调用obtainRequest返回
      return obtainRequest(
          target,
          targetListener,
          requestOptions,
          parentCoordinator,
          transitionOptions,
          priority,
          overrideWidth,
          overrideHeight);
    }
  }

可见buildThumbnailRequestRecursive()逻辑与buildRequestRecursive逻辑类似，用于根据thumbnail生成对应的coordinator，但是对应的request的生成均是由obtainRequest()方法实现

private Request obtainRequest(
      Target target,
      RequestListener targetListener,
      RequestOptions requestOptions,
      RequestCoordinator requestCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight) {
    //调用了SingleRequest的obtain
    return SingleRequest.obtain(
        context,
        glideContext,
        model,
        transcodeClass,
        requestOptions,
        overrideWidth,
        overrideHeight,
        priority,
        target,
        targetListener,
        requestListener,
        requestCoordinator,
        glideContext.getEngine(),
        transitionOptions.getTransitionFactory());
  }
  
  
  //该方法最终会调用到SingleRequest的init()方法，该方法也仅仅是用于初始化赋值，并将request的状态改为PENDING
  private void init(
      Context context,
      GlideContext glideContext,
      Object model,
      Class transcodeClass,
      RequestOptions requestOptions,
      int overrideWidth,
      int overrideHeight,
      Priority priority,
      Target target,
      RequestListener targetListener,
      RequestListener requestListener,
      RequestCoordinator requestCoordinator,
      Engine engine,
      TransitionFactory animationFactory) {
    this.context = context;
    this.glideContext = glideContext;
    this.model = model;
    this.transcodeClass = transcodeClass;
    this.requestOptions = requestOptions;
    this.overrideWidth = overrideWidth;
    this.overrideHeight = overrideHeight;
    this.priority = priority;
    this.target = target;
    this.targetListener = targetListener;
    this.requestListener = requestListener;
    this.requestCoordinator = requestCoordinator;
    this.engine = engine;
    this.animationFactory = animationFactory;
    status = Status.PENDING;
  }

经过多层嵌套，request的生成终于完成了，虽然代码量不少，但是整体逻辑还是比较清晰的，先根据是否有errorBuilder确定最外层的errorRequestCoordinator是否存在，再在buildThumbnailRequestRecursive()中是否有thumbnail相关参数来确定内部的coordinator是否存在。
如果两者均存在，则生成的request为ErrorRequestCoordinator(ThumbnailRequestCoordinator(fullRequest,thumbRequest),errorRequest)。

3.4.3 通过requestManager追踪target和request
  void track(@NonNull Target target, @NonNull Request request) {
    //分别用targetTracker 追踪 target，requestTracker 调用request
    targetTracker.track(target);
    requestTracker.runRequest(request);
  }

targetTracker在官方注释中表示这个类的作用是用于对target进行相应生命周期的管理，而它的track方法也十分简单，仅仅是将target加入到它的一个内部集合类targets中

  public void track(@NonNull Target target) {
    targets.add(target);
  }

而requestTrack与targetTracker类似，也是将传入的request保存到内部集合类中，用于对其进行相应生命周期管理，而且该方法还会调用request的begin方法

  public void runRequest(@NonNull Request request) {
    requests.add(request);
    //当前非paused状态时，调用request的begin，否则加入pendingRequests队列中
    if (!isPaused) {
      request.begin();
    } else {
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "Paused, delaying request");
      }
      pendingRequests.add(request);
    }
  }

在上文关于request的创建中我们知道了，这里的request指的是singleRequest，因此会调用它的begin方法

  @Override
  public void begin() {
    //省略部分异常判断的代码
    ......

    //判断当前status是否是已完成（即完成相应资源的加载）。
    if (status == Status.COMPLETE) {
      onResourceReady(resource, DataSource.MEMORY_CACHE);
      return;
    }
    
    //将状态更变为WAITING_FOR_SIZE
    status = Status.WAITING_FOR_SIZE;
    //判断用户是否通过requestOptions指定合法的宽高
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
      //如果指定了合法的宽高则直接调用onSizeReady()
      onSizeReady(overrideWidth, overrideHeight);
    } else {
      //如果未指定，则由上文生成的viewTarget获取对应的size
      target.getSize(this);
    }

    if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
        && canNotifyStatusChanged()) {
      target.onLoadStarted(getPlaceholderDrawable());
    }
    if (IS_VERBOSE_LOGGABLE) {
      logV("finished run method in " + LogTime.getElapsedMillis(startTime));
    }
  }

target.getSize(this)方法，将singleRequest本身作为一个callback传递了进去，当target获取到了所需尺寸后则会通过传入的callback调用onSizeReady()方法，所以之后的流程还是会进入到onSizeReady()方法

  @Override
  public void onSizeReady(int width, int height) {
    //省略部分异常判断代码
    ......
    
    //将目前的状态变更为RUNNING
    status = Status.RUNNING;

    float sizeMultiplier = requestOptions.getSizeMultiplier();
    this.width = maybeApplySizeMultiplier(width, sizeMultiplier);
    this.height = maybeApplySizeMultiplier(height, sizeMultiplier);

    if (IS_VERBOSE_LOGGABLE) {
      logV("finished setup for calling load in " + LogTime.getElapsedMillis(startTime));
    }
    
    //通过engine.load()进行加载，并返回loadStatus
    loadStatus = engine.load(
        glideContext,
        model,
        requestOptions.getSignature(),
        this.width,
        this.height,
        requestOptions.getResourceClass(),
        transcodeClass,
        priority,
        requestOptions.getDiskCacheStrategy(),
        requestOptions.getTransformations(),
        requestOptions.isTransformationRequired(),
        requestOptions.isScaleOnlyOrNoTransform(),
        requestOptions.getOptions(),
        requestOptions.isMemoryCacheable(),
        requestOptions.getUseUnlimitedSourceGeneratorsPool(),
        requestOptions.getUseAnimationPool(),
        requestOptions.getOnlyRetrieveFromCache(),
        this);

    // This is a hack that's only useful for testing right now where loads complete synchronously
    // even though under any executor running on any thread but the main thread, the load would
    // have completed asynchronously.
    if (status != Status.RUNNING) {
      loadStatus = null;
    }
    if (IS_VERBOSE_LOGGABLE) {
      logV("finished onSizeReady in " + LogTime.getElapsedMillis(startTime));
    }
  }

engine是在Glide在初始化build时创建的，官方注释描述该类用于启动加载和管理对应的活动资源和缓存资源。

    public  LoadStatus load(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      Class resourceClass,
      Class transcodeClass,
      Priority priority,
      DiskCacheStrategy diskCacheStrategy,
      Map, Transformation> transformations,
      boolean isTransformationRequired,
      boolean isScaleOnlyOrNoTransform,
      Options options,
      boolean isMemoryCacheable,
      boolean useUnlimitedSourceExecutorPool,
      boolean useAnimationPool,
      boolean onlyRetrieveFromCache,
      ResourceCallback cb) {
    Util.assertMainThread();
    long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;

    //创建本次加载的资源对应的key
    EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
        resourceClass, transcodeClass, options);
    
    //从活动资源查找对应资源是否存在
    EngineResource active = loadFromActiveResources(key, isMemoryCacheable);
    if (active != null) {
      cb.onResourceReady(active, DataSource.MEMORY_CACHE);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from active resources", startTime, key);
      }
      return null;
    }
    
    //如未找到，从缓存资源中查找对应资源是否存在
    EngineResource cached = loadFromCache(key, isMemoryCacheable);
    if (cached != null) {
      cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from cache", startTime, key);
      }
      return null;
    }
    
    //如果内存缓存未找到则查找目前正在运行的加载任务中是否存在相同的任务
    EngineJob current = jobs.get(key, onlyRetrieveFromCache);
    if (current != null) {
      current.addCallback(cb);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Added to existing load", startTime, key);
      }
      return new LoadStatus(cb, current);
    }

    //全部未命中后创建engineJob和decodeJob
    EngineJob engineJob =
        engineJobFactory.build(
            key,
            isMemoryCacheable,
            useUnlimitedSourceExecutorPool,
            useAnimationPool,
            onlyRetrieveFromCache);

    DecodeJob decodeJob =
        decodeJobFactory.build(
            glideContext,
            model,
            key,
            signature,
            width,
            height,
            resourceClass,
            transcodeClass,
            priority,
            diskCacheStrategy,
            transformations,
            isTransformationRequired,
            isScaleOnlyOrNoTransform,
            onlyRetrieveFromCache,
            options,
            engineJob);

    //将创建的engineJob与key绑定存入jobs中，让后续任务可以查找
    jobs.put(key, engineJob);

    //将cb(即上文中的SingleRequest)加入callback，继续向下传递
    engineJob.addCallback(cb);
    //由engineJob启动decodeJob
    engineJob.start(decodeJob);

    if (VERBOSE_IS_LOGGABLE) {
      logWithTimeAndKey("Started new load", startTime, key);
    }
    return new LoadStatus(cb, engineJob);
  }

在此方法中涉及到了两级的内存缓存的查找，后续再详细讨论。我们继续关注加载的主流程，在内存缓存未命中的时候我们创建分别创建了EngineJob和DecodeJob。根据官方注释，EngineJob是用来管理添加和删除加载时callback的类，并会在完成时通知对应callback。而DecodeJob正如它的名字是一个解码任务负责从缓存数据或者原始数据解码的类。engineJob.start(decodeJob)则会开启decodeJob的运行

  public void start(DecodeJob decodeJob) {
    this.decodeJob = decodeJob;
    GlideExecutor executor = decodeJob.willDecodeFromCache()
        ? diskCacheExecutor
        : getActiveSourceExecutor();
    executor.execute(decodeJob);
  }

在线程池中运行decodeJob。

  @Override
  public void run() {
    GlideTrace.beginSectionFormat("DecodeJob#run(model=%s)", model);
    DataFetcher localFetcher = currentFetcher;
    try {
      //判断该任务是否取消
      if (isCancelled) {
        notifyFailed();
        return;
      }
      //运行任务
      runWrapped();
    } catch (Throwable t) {
      //异常情况处理
      if (Log.isLoggable(TAG, Log.DEBUG)) {
        Log.d(TAG, "DecodeJob threw unexpectedly"
            + ", isCancelled: " + isCancelled
            + ", stage: " + stage, t);
      }
      if (stage != Stage.ENCODE) {
        throwables.add(t);
        notifyFailed();
      }
      if (!isCancelled) {
        throw t;
      }
    } finally {
      if (localFetcher != null) {
        localFetcher.cleanup();
      }
      GlideTrace.endSection();
    }
  }
  
  private void runWrapped() {
    //根据runReason状态调用不同处理逻辑，runReason在DecodeJob初始化时会被赋值为INITIALIZE
    switch (runReason) {
      case INITIALIZE:
        //获取下个stage和generator
        stage = getNextStage(Stage.INITIALIZE);
        currentGenerator = getNextGenerator();
        //状态更新后调用的runGenerators
        runGenerators();
        break;
      case SWITCH_TO_SOURCE_SERVICE:
        runGenerators();
        break;
      case DECODE_DATA:
        decodeFromRetrievedData();
        break;
      default:
        throw new IllegalStateException("Unrecognized run reason: " + runReason);
    }
  }

这里stage更新会根据当前的缓存状态来改变，如果缓存未命中且未限制仅能从缓存中读取，则状态会变为SOURCE。getNextGenerator()方法则会根据当前的stage状态生成不同的currentGenerator。

  private void runGenerators() {
    currentThread = Thread.currentThread();
    startFetchTime = LogTime.getLogTime();
    boolean isStarted = false;
    //判断任务是否被取消，违背取消则去调用currentGenerator的startNext()方法用于查找对应缓存，而while循环会不断的更新stage和currentGenerator的状态。
    while (!isCancelled && currentGenerator != null
        && !(isStarted = currentGenerator.startNext())) {
      stage = getNextStage(stage);
      currentGenerator = getNextGenerator();

      //如果stage为SOURCE，则会调用reschedule
      if (stage == Stage.SOURCE) {
        //reschedule会将runReason变为SWITCH_TO_SOURCE_SERVICE，并通过callback的reschedule方法重新调用runWrapped从而达到状态更新目的
        reschedule();
        return;
      }
    }
    if ((stage == Stage.FINISHED || isCancelled) && !isStarted) {
      notifyFailed();
    }
  }

关于文件缓存暂时略过，后续再详细讨论。因此我们目前以SourceGenerator为例，进行接下来流程的讨论

  @Override
  public boolean startNext() {
    //判断dataToCache状态来确定是否需要生成对应的sourceCacheGenerator。
    if (dataToCache != null) {
      Object data = dataToCache;
      dataToCache = null;
      cacheData(data);
    }

    //如果生成了对应的sourceCacheGenerator，则调用其startNext方法，并返回true
    if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
      return true;
    }
    sourceCacheGenerator = null;

    loadData = null;
    boolean started = false;
    //循环查找ModelLoader中是否存在加载对应数据的ModelLoader
    while (!started && hasNextModelLoader()) {
      loadData = helper.getLoadData().get(loadDataListIndex++);
      if (loadData != null
          && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
          || helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
        //找到能处理的loadData后，调用loadData方法进行加载
        started = true;
        loadData.fetcher.loadData(helper.getPriority(), this);
      }
    }
    return started;
  }

loadData加载对应资源成功后，会通过传入的第二个参数this回调onDataReady方法。

  @Override
  public void onDataReady(Object data) {
    DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy();
    //判断数据是否可以缓存
    if (data != null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
      //若允许缓存，则进行赋值，且调用cb的reschedule()方法
      dataToCache = data;
      cb.reschedule();
    } else {
      //否则直接调用cb的onDataFetcherReady()方法
      cb.onDataFetcherReady(loadData.sourceKey, data, loadData.fetcher,
          loadData.fetcher.getDataSource(), originalKey);
    }
  }

如上文所述reschedule方法会重新调用DecodeJob的runWrapped()方法，最终会回到startNext()方法中，但此时dataToCache已被赋值，因此会调用cacheData()方法

  private void cacheData(Object dataToCache) {
    long startTime = LogTime.getLogTime();
    try {
      Encoder encoder = helper.getSourceEncoder(dataToCache);
      DataCacheWriter writer =
          new DataCacheWriter<>(encoder, dataToCache, helper.getOptions());
      originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());
      helper.getDiskCache().put(originalKey, writer);
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        Log.v(TAG, "Finished encoding source to cache"
            + ", key: " + originalKey
            + ", data: " + dataToCache
            + ", encoder: " + encoder
            + ", duration: " + LogTime.getElapsedMillis(startTime));
      }
    } finally {
      loadData.fetcher.cleanup();
    }

    sourceCacheGenerator =
        new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
  }
 
  
该方法主要用于对source数据进行缓存，以及生成对应的sourceCacheGenerator。之后通过sourceCacheGenerator来通加载缓存数据，加载完成后最终还是会调用cb.onDataFetcherReady()方法，也就是DecodeJob的onDataFetcherReady()方法。
 
  
  @Override
  public void onDataFetcherReady(Key sourceKey, Object data, DataFetcher fetcher,
      DataSource dataSource, Key attemptedKey) {
    this.currentSourceKey = sourceKey;
    this.currentData = data;
    this.currentFetcher = fetcher;
    this.currentDataSource = dataSource;
    this.currentAttemptingKey = attemptedKey;
    //判断当前线程是否一致，不一致则修改runReason为DECODE_DATA，再通过reschedule方法重新调用run()
    if (Thread.currentThread() != currentThread) {
      runReason = RunReason.DECODE_DATA;
      callback.reschedule(this);
    } else {
      GlideTrace.beginSection("DecodeJob.decodeFromRetrievedData");
      try {
        decodeFromRetrievedData();
      } finally {
        GlideTrace.endSection();
      }
    }
  }

 
  
在onDataFetcherReady方法中会在赋值操作后通过decodeFromRetrievedData()方法对数据进行解析。decodeFromRetrievedData()方法最终通过层层调用会获取到对应的LoadPath对象并调用其load()方法进行解析。并在最后通过notifyEncodeAndRelease()方法进行回调通知。
 
  
  public Resource load(DataRewinder rewinder, @NonNull Options options, int width,
      int height, DecodePath.DecodeCallback decodeCallback) throws GlideException {
    List throwables = Preconditions.checkNotNull(listPool.acquire());
    try {
      return loadWithExceptionList(rewinder, options, width, height, decodeCallback, throwables);
    } finally {
      listPool.release(throwables);
    }
  }
  
  private Resource loadWithExceptionList(DataRewinder rewinder,
      @NonNull Options options,
      int width, int height, DecodePath.DecodeCallback decodeCallback,
      List exceptions) throws GlideException {
    Resource result = null;
    //循环调用decodePaths中的DecodePath的decode进行解析
    for (int i = 0, size = decodePaths.size(); i < size; i++) {
      DecodePath path = decodePaths.get(i);
      try {
        result = path.decode(rewinder, width, height, options, decodeCallback);
      } catch (GlideException e) {
        exceptions.add(e);
      }
      if (result != null) {
        break;
      }
    }

    if (result == null) {
      throw new GlideException(failureMessage, new ArrayList<>(exceptions));
    }

    return result;
  }

 
  
可见LoadPath的load()方法最终会调用到loadWithExceptionList()方法，并在此方法中循环调用decodePaths中DecodePath的decode进行解析，获取result。
 
  
  public Resource decode(DataRewinder rewinder, int width, int height,
      @NonNull Options options, DecodeCallback callback) throws GlideException {
    Resource decoded = decodeResource(rewinder, width, height, options);
    Resource transformed = callback.onResourceDecoded(decoded);
    return transcoder.transcode(transformed, options);
  }

  @NonNull
  private Resource decodeResource(DataRewinder rewinder, int width,
      int height, @NonNull Options options) throws GlideException {
    List exceptions = Preconditions.checkNotNull(listPool.acquire());
    try {
      return decodeResourceWithList(rewinder, width, height, options, exceptions);
    } finally {
      listPool.release(exceptions);
    }
  }

 
  
DecodePath的decode方法首先与LoadPath的load()方法类似，通过decodeResourceWithList循环调用ResourceDecoder进行解析。之后通过callback.onResourceDecoded()回调方法将对应的结果传入。
 
  
  @Synthetic
  @NonNull
   Resource onResourceDecoded(DataSource dataSource,
      @NonNull Resource decoded) {
    @SuppressWarnings("unchecked")
    Class resourceSubClass = (Class) decoded.get().getClass();
    Transformation appliedTransformation = null;
    Resource transformed = decoded;
    if (dataSource != DataSource.RESOURCE_DISK_CACHE) {
      appliedTransformation = decodeHelper.getTransformation(resourceSubClass);
      transformed = appliedTransformation.transform(glideContext, decoded, width, height);
    }
    if (!decoded.equals(transformed)) {
      decoded.recycle();
    }

    final EncodeStrategy encodeStrategy;
    final ResourceEncoder encoder;
    if (decodeHelper.isResourceEncoderAvailable(transformed)) {
      encoder = decodeHelper.getResultEncoder(transformed);
      encodeStrategy = encoder.getEncodeStrategy(options);
    } else {
      encoder = null;
      encodeStrategy = EncodeStrategy.NONE;
    }

    Resource result = transformed;
    //省略部分代码
    ....
    return result;
  }
  
  
  @SuppressWarnings("unchecked")
   Transformation getTransformation(Class resourceClass) {
    Transformation result = (Transformation) transformations.get(resourceClass);
    if (result == null) {
      for (Entry, Transformation> entry : transformations.entrySet()) {
        if (entry.getKey().isAssignableFrom(resourceClass)) {
          result = (Transformation) entry.getValue();
          break;
        }
      }
    }

    if (result == null) {
      if (transformations.isEmpty() && isTransformationRequired) {
        throw new IllegalArgumentException(
            "Missing transformation for " + resourceClass + ". If you wish to"
                + " ignore unknown resource types, use the optional transformation methods.");
      } else {
        return UnitTransformation.get();
      }
    }
    return result;
  }

 
  
在Engine.load()的时候会将Glide初始化时创建的transformations进行遍历，寻找key对应的Transformation。之后将结果返回到onDataFetcherReady方法中，继续调用notifyEncodeAndRelease()方法，进行回调通知。
 
  
  private void notifyEncodeAndRelease(Resource resource, DataSource dataSource) {
    if (resource instanceof Initializable) {
      ((Initializable) resource).initialize();
    }

    Resource result = resource;
    LockedResource lockedResource = null;
    if (deferredEncodeManager.hasResourceToEncode()) {
      lockedResource = LockedResource.obtain(resource);
      result = lockedResource;
    }

    notifyComplete(result, dataSource);

    stage = Stage.ENCODE;
    try {
      if (deferredEncodeManager.hasResourceToEncode()) {
        deferredEncodeManager.encode(diskCacheProvider, options);
      }
    } finally {
      if (lockedResource != null) {
        lockedResource.unlock();
      }
    }
    onEncodeComplete();
  }
  
  private void notifyComplete(Resource resource, DataSource dataSource) {
    setNotifiedOrThrow();
    callback.onResourceReady(resource, dataSource);
  }

 
  
由上文可见会在此时调用callback(即EngineJob)的onResourceReady方法。
 
  
  @Override
  public void onResourceReady(Resource resource, DataSource dataSource) {
    //对回传的数据进行赋值
    this.resource = resource;
    this.dataSource = dataSource;
    //通过Handle回传调用handleResultOnMainThread，确保该方法运行在UI线程中
    MAIN_THREAD_HANDLER.obtainMessage(MSG_COMPLETE, this).sendToTarget();
  }
  
  @Synthetic
  void handleResultOnMainThread() {
    //省略部分异常判断的代码
    ......
    
    engineResource = engineResourceFactory.build(resource, isCacheable);
    hasResource = true;

    engineResource.acquire();
    listener.onEngineJobComplete(this, key, engineResource);

    //循环触发回调的onResourceReady方法
    for (int i = 0, size = cbs.size(); i < size; i++) {
      ResourceCallback cb = cbs.get(i);
      if (!isInIgnoredCallbacks(cb)) {
        engineResource.acquire();
        cb.onResourceReady(engineResource, dataSource);
      }
    }
    //完成后释放engineResource资源
    engineResource.release();

    release(false /*isRemovedFromQueue*/);
  }

 
  
这样就会触发在Engine.load()时传入callback(即SingleRequest)的onResourceReady方法
 
  
  @Override
  public void onResourceReady(Resource resource, DataSource dataSource) {
    //省略部分代码
    ......
    onResourceReady((Resource) resource, (R) received, dataSource);
  }
  
  private void onResourceReady(Resource resource, R result, DataSource dataSource) {
    //省略部分代码
    ......
    
    try {
      if ((requestListener == null
          || !requestListener.onResourceReady(result, model, target, dataSource, isFirstResource))
          && (targetListener == null
          || !targetListener.onResourceReady(result, model, target, dataSource, isFirstResource))) {
        Transition animation =
            animationFactory.build(dataSource, isFirstResource);
        //调用target的onResourceReady
        target.onResourceReady(result, animation);
      }
    } finally {
      isCallingCallbacks = false;
    }
    
    //调用requestCoordinator的onRequestSuccess方法
    notifyLoadSuccess();
  }

 
  
这里的target我们以上文中的DrawableImageViewTarget为例，先调用它的父类ImageViewTarget的onResourceReady()方法，最终会调用到的DrawableImageViewTarget的setResource()方法中完成资源文件的加载。
 
  
  @Override
  protected void setResource(@Nullable Drawable resource) {
    view.setImageDrawable(resource);
  }

 
  
总结收获
 
  
至此，整个Glide加载图片的主流程分析完成。按照Glide提供的API来划分，整个加载过程分为四步
 with()-load()-apply()-into()
 这四步的作用分别如下：
 
  
     
   
  1. with()主要用于初始化Glide，并将对应context进行处理，完成对生命周期的绑定管理。
    2.  
   
  2. load()用于对所需加载的资源的model进行识别保存，并且创建RequestBuilder
    3.  
   
  3. apply()方法用于对用户设定的RequestOptions通过位运算进行传入赋值。
    4.  
   
  4. into()方法才是整个加载过程的核心，实现了缓存加载，解析，转换等过程，最终通过回调将解析处理完成的资源设置到对应的view中
    5.  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(android)

        

            

                
    
                    
  • android系统selinux中添加新属性property
                        辉色投像

                        
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    
                    
    • 
                    
  • 2.2.6 通知类控件 Toast、Menu
                        常思行

                        
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
    
                    
    • 
                    
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    
                    
    • 
                    
  • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    
                    
    • 
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • Android实现监听事件的方法
                        Amy木婉清

                        
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
    
                    
    • 
                    
  • 高级UI<第二十四篇>：Android中用到的矩阵常识
                        NoBugException

                        
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
    
                    
    • 
                    
  • RK3229_Android9.0_Box 4G模块EC200A调试
                        suifen_
网络
                        
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
    
                    
    • 
                    
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作
                        铭空间
kt文件和java文件
                        
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
    
                    
    • 
                    
  • Android shell 常用 debug 命令
                        晨春计
Audiodebugandroidlinux
                        
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
    
                    
    • 
                    
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    
                    
    • 
                    
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
                        计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
                        
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
    
                    
    • 
                    
  • android ndk 开发jni调用对象方法，数组参数
                        wulongkou
开发问题安卓的事ndkandroidstudiojni
                        
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
    
                    
    • 
                    
  • Android jni中数组参数的传递方式
                        lokeyme
Andriodandroid开发JNINDKjavac语言
                        
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
    
                    
    • 
                    
  • 1-1.Jetpack 之 Navigation 简单编码模板
                        我命由我12345
Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
                        
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
    
                    
    • 
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • Android干净架构MVI模板使用指南
                        井美婵Toby

                        
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
    
                    
    • 
                    
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
                        惊鸿醉
Unityunityandroidxml
                        
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    
                    
    • 
                    
  • 《Android进阶之光》读书笔记
                        soleil雪寂
读书笔记#Android进阶之光
                        
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
    
                    
    • 
                    
  • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    
                    
    • 
                    
  • 《android进阶之光》——多线程编程（上）
                        TAING要一直努力
读书笔记
                        
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
    
                    
    • 
                    
  • android进阶之光！Android面试必备的集合源码详解，系列篇
                        程序员Sunbu
程序员Android
                        
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
    
                    
    • 
                    
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1)
                        egrhef
程序员androidjava开发语言
                        
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
    
                    
    • 
                    
  • Visual Studio中的Android模拟器使用详解
                        wurui8
androidandroidstudioandroidandroid应用
                        
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
    
                    
    • 
                    
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示
                        仙魁XAN
Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
                        
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
    
                    
    • 
                    
  • Android 用线程池实现一个简单的任务队列(Kotlin)
                        深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
                        
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
    
                    
    • 
                    
  • （小白入门）Windows环境下搭建React Native Android开发环境
                        码农老黑
前端ReactNative移动开发Androidstudio
                        
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
    
                    
    • 
                    
  • Android Dialog圆角设置无效的问题
                        ly969434341
android
                        
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
    
                    
    • 
                    
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活
                        技术无疆
Androidandroiduiandroidstudioandroid-studiojavaandroidx
                        
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
    
                    
    • 
                    
  • Android界面特效全汇总
                        小飞鹤
Android开发详解android
                        
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
    
                    
    • 
                                
  • 二分查找排序算法
                                    周凡杨
java二分查找排序算法折半
                                    
     一：概念 二分查找又称
折半查找（
折半搜索/
二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
    
                                
    • 
                                
  • java中的BigDecimal
                                    bijian1013
javaBigDecimal
                                    
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。 
        原文地址：http://blog.csdn.net/ugg/article/de
    
                                
    • 
                                
  • Shell echo命令详解
                                    daizj
echoshell
                                    
    Shell echo命令 
Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： 
echo string 
您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: 
  echo "It is a test" 
这里的双引号完全可以省略，以下命令与上面实例效果一致： 
  echo Itis a test 2.显示转义
    
                                
    • 
                                
  • Oracle DBA 简单操作
                                    周凡杨
oracle dba sql
                                    
     --执行次数多的SQL 
 select sql_text,executions from ( 
     select sql_text,executions from v$sqlarea order by executions desc 
     ) where rownum<81; 
 &nb
    
                                
    • 
                                
  • 画图重绘
                                    朱辉辉33
游戏
                                    
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。 
  在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
    
                                
    • 
                                
  • 线程之初体验
                                    西蜀石兰
线程
                                    
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 
之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 
 
线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 
你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
    
                                
    • 
                                
  • linux集群互相免登陆配置
                                    林鹤霄
linux
                                    
    配置ssh免登陆 
1、生成秘钥和公钥    ssh-keygen -t rsa 
2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub 
   其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
    
                                
    • 
                                
  • mysql : Lock wait timeout exceeded; try restarting transaction
                                    aigo
mysql
                                    
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html 
  
原因是你使用的InnoDB   表类型的时候, 
默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 
因为有的锁等待超过了这个时间,所以抱错. 
  
你可以把这个时间加长,或者优化存储
    
                                
    • 
                                
  • Socket编程 基本的聊天实现。
                                    alleni123
socket
                                    
    public class Server
{

	//用来存储所有连接上来的客户
	private List<ServerThread> clients;
	
	public static void main(String[] args)
	{
		Server s = new Server();
		s.startServer(9988);
	}

	publi
    
                                
    • 
                                
  • 多线程监听器事件模式(一个简单的例子)
                                    百合不是茶
线程监听模式
                                    
        
多线程的事件监听器模式 
  监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到 
  
     创建多线程的事件监听器模式 思路: 
   1, 创建线程并启动,在创建线程的位置设置一个标记 
    2,创建队
    
                                
    • 
                                
  • spring InitializingBean接口
                                    bijian1013
javaspring
                                    
    spring的事务的TransactionTemplate，其源码如下： 
public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{
 ...
} 
TransactionTemplate继承了DefaultT
    
                                
    • 
                                
  • Oracle中询表的权限被授予给了哪些用户
                                    bijian1013
oracle数据库权限
                                    
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 
select t.table_name as "表名",
       t.grantee    as "被授权的属组",
       t.owner      as "对象所在的属组"
    
                                
    • 
                                
  • 【Struts2五】Struts2 参数传值
                                    bit1129
struts2
                                    
    Struts2中参数传值的3种情况 
1.请求参数绑定到Action的实例字段上 
2.Action将值传递到转发的视图上 
3.Action将值传递到重定向的视图上 
  一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上  
Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
    
                                
    • 
                                
  • 【Kafka十四】关于auto.offset.reset[Q/A]
                                    bit1129
kafka
                                    
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or 
    
                                
    • 
                                
  • nginx gzip压缩配置
                                    ronin47
nginx gzip 压缩范例
                                    
    nginx gzip压缩配置   更多 
0      
 nginx      
 gzip      
 配置         
随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ 
gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
    
                                
    • 
                                
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点
                                    bylijinnan
java
                                    
    two cursors. 
Make the first cursor go K steps first. 
 
 

/*
	 * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点
	 */
	public void displayKthItemsBackWard(ListNode head,int k){
		ListNode p1=head,p2=head;

    
                                
    • 
                                
  • Spring源码学习-JdbcTemplate queryForObject
                                    bylijinnan
javaspring
                                    
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 
1. 
Object queryForObject(String sql, Object[] args, Class requiredType) 
2. 
Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 
 
第1个方法是只查
    
                                
    • 
                                
  • [冰川时代]在冰川时代,我们需要什么样的技术?
                                    comsci
技术
                                    
     
 
     看美国那边的气候情况....我有个感觉...是不是要进入小冰期了? 
 
     那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段... 
 
  &nb
    
                                
    • 
                                
  • js 获取浏览器型号
                                    cuityang
js浏览器
                                    
    根据浏览器获取iphone和apk的下载地址 
 
<!DOCTYPE html> 
<html> 
<head> 
    <meta charset="utf-8" content="text/html"/> 
    <meta name=
    
                                
    • 
                                
  • C# socks5详解 转
                                    dalan_123
socketC#
                                    
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html    这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
    
                                
    • 
                                
  • 运维 Centos问题汇总
                                    dcj3sjt126com
云主机
                                    
    一、sh 脚本不执行的原因 
sh脚本不执行的原因 只有2个 
1.权限不够 
2.sh脚本里路径没写完整。 
  
二、解决You have new mail in /var/spool/mail/root 
修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 
MailTo = 
MailFrom 
  
三、查询连接数
    
                                
    • 
                                
  • Yii防注入攻击笔记
                                    dcj3sjt126com
sqlWEB安全yii
                                    
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号  这里有个转义对照表： 
http://blog.csdn.net/xinzhu1990/articl
    
                                
    • 
                                
  • MongoDB简介[一]
                                    eksliang
mongodbMongoDB简介
                                    
    MongoDB简介 
转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用 
       MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。 
       另外，不
    
                                
    • 
                                
  • zookeeper windows 入门安装和测试
                                    greemranqq
zookeeper安装分布式
                                    
    一、序言 
      以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。 
      栗子1号： 
      假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
    
                                
    • 
                                
  • Spring之使用事务缘由(2-注解实现)
                                    ihuning
spring
                                    
      
Spring事务注解实现 
  
1. 依赖包： 
    1.1 spring包： 
          spring-beans-4.0.0.RELEASE.jar 
          spring-context-4.0.0.
    
                                
    • 
                                
  • iOS App Launch Option
                                    啸笑天
option
                                    
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。 
  
launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 
1、若用户直接
    
                                
    • 
                                
  • jdk与jre的区别（_）
                                    macroli
javajvmjdk
                                    
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  
JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
    
                                
    • 
                                
  • Updates were rejected because the tip of your current branch is behind
                                    qiaolevip
学习永无止境每天进步一点点众观千象git
                                    
    $ git push joe prod-2295-1

To [email protected]:joe.le/dr-frontend.git
 ! [rejected]        prod-2295-1 -> prod-2295-1 (non-fast-forward)
error: failed to push some refs to '[email protected]
    
                                
    • 
                                
  • [一起学Hive]之十四-Hive的元数据表结构详解
                                    superlxw1234
hivehive元数据结构
                                    
    关键字：Hive元数据、Hive元数据表结构 
  
之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 
本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。 
  
文章最后面，会以一个示例来全面了解一下，
    
                                
    • 
                                
  • Spring 3.2.14，4.1.7，4.2.RC2发布
                                    wiselyman
Spring 3
                                    
      
Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。 
  
其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。 
  
其中Spring 4.1.7主要包含这些更新内容。 
    
                                
    •