com.bumptech.glide.load.model.ModelLoaderRegistry Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of glide Show documentation
A fast and efficient image loading library for Android focused on smooth scrolling.
There is a newer version: 5.0.0-rc01
package com.bumptech.glide.load.model;

import android.support.v4.util.Pools.Pool;
import com.bumptech.glide.util.Synthetic;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Maintains an ordered put of {@link ModelLoader}s and the model and data types they handle in
 * order from highest priority to lowest.
 */
public class ModelLoaderRegistry {

  private final MultiModelLoaderFactory multiModelLoaderFactory;
  private final ModelLoaderCache cache = new ModelLoaderCache();

  public ModelLoaderRegistry(Pool> exceptionListPool) {
    this(new MultiModelLoaderFactory(exceptionListPool));
  }

  // Visible for testing.
  ModelLoaderRegistry(MultiModelLoaderFactory multiModelLoaderFactory) {
    this.multiModelLoaderFactory = multiModelLoaderFactory;
  }

  public synchronized  void append(Class modelClass, Class dataClass,
      ModelLoaderFactory factory) {
    multiModelLoaderFactory.append(modelClass, dataClass, factory);
    cache.clear();
  }

  public synchronized  void prepend(Class modelClass, Class dataClass,
      ModelLoaderFactory factory) {
    multiModelLoaderFactory.prepend(modelClass, dataClass, factory);
    cache.clear();
  }

  public synchronized  void remove(Class modelClass, Class dataClass) {
    tearDown(multiModelLoaderFactory.remove(modelClass, dataClass));
    cache.clear();
  }

  public synchronized  void replace(Class modelClass, Class dataClass,
      ModelLoaderFactory factory) {
    tearDown(multiModelLoaderFactory.replace(modelClass, dataClass, factory));
    cache.clear();
  }

  private  void tearDown(List> factories) {
    for (ModelLoaderFactory factory : factories) {
      factory.teardown();
    }
  }

  public synchronized  List> getModelLoaders(A model) {
    List> modelLoaders = getModelLoadersForClass(getClass(model));
    int size = modelLoaders.size();
    List> filteredLoaders = new ArrayList<>(size);
    for (int i = 0; i < size; i++) {
      ModelLoader loader = modelLoaders.get(i);
      if (loader.handles(model)) {
        filteredLoaders.add(loader);
      }
    }
    return filteredLoaders;
  }

  public synchronized  ModelLoader build(Class modelClass,
      Class dataClass) {
    return multiModelLoaderFactory.build(modelClass, dataClass);
  }

  public synchronized List> getDataClasses(Class modelClass) {
    return multiModelLoaderFactory.getDataClasses(modelClass);
  }

  private  List> getModelLoadersForClass(Class modelClass) {
    List> loaders = cache.get(modelClass);
    if (loaders == null) {
      loaders = Collections.unmodifiableList(multiModelLoaderFactory.build(modelClass));
      cache.put(modelClass, loaders);
    }
    return loaders;
  }

  @SuppressWarnings("unchecked")
  private static  Class getClass(A model) {
    return (Class) model.getClass();
  }

  private static class ModelLoaderCache {
    private final Map, Entry> cachedModelLoaders = new HashMap<>();

    @Synthetic
    ModelLoaderCache() { }

    public void clear() {
      cachedModelLoaders.clear();
    }

    public  void put(Class modelClass, List> loaders) {
      Entry previous = cachedModelLoaders.put(modelClass, new Entry<>(loaders));
      if (previous != null) {
        throw new IllegalStateException("Already cached loaders for model: " + modelClass);
      }
    }

    @SuppressWarnings("unchecked")
    public  List> get(Class modelClass) {
      Entry entry = (Entry) cachedModelLoaders.get(modelClass);
      return entry == null ? null : entry.loaders;
    }

    private static class Entry {
      @Synthetic final List> loaders;

      public Entry(List> loaders) {
        this.loaders = loaders;
      }
    }
  }
}