content: package com.alium.orin.glide;
  
  import android.content.Context;
  import android.graphics.Bitmap;
  import android.support.annotation.NonNull;
  
  import com.alium.orin.model.Song;
  import com.alium.orin.util.MusicUtil;
  import com.bumptech.glide.BitmapRequestBuilder;
  import com.bumptech.glide.DrawableRequestBuilder;
  import com.bumptech.glide.DrawableTypeRequest;
  import com.bumptech.glide.RequestManager;
  import com.bumptech.glide.load.Key;
  import com.bumptech.glide.load.engine.DiskCacheStrategy;
  import com.bumptech.glide.load.resource.drawable.GlideDrawable;
  import com.bumptech.glide.signature.MediaStoreSignature;
  import com.alium.orin.R;
  import com.alium.orin.glide.audiocover.AudioFileCover;
  import com.alium.orin.glide.palette.BitmapPaletteTranscoder;
  import com.alium.orin.glide.palette.BitmapPaletteWrapper;
  import com.alium.orin.util.PreferenceUtil;
  
  /**
   * @author Karim Abou Zeid (kabouzeid)
   */
  public class SongGlideRequest {
  
      public static final DiskCacheStrategy DEFAULT_DISK_CACHE_STRATEGY = DiskCacheStrategy.NONE;
      public static final int DEFAULT_ERROR_IMAGE = R.drawable.default_album_art;
      public static final int DEFAULT_ANIMATION = android.R.anim.fade_in;
  
      public static class Builder {
          final RequestManager requestManager;
          final Song song;
          boolean ignoreMediaStore;
  
          public static Builder from(@NonNull RequestManager requestManager, Song song) {
              return new Builder(requestManager, song);
          }
  
          private Builder(@NonNull RequestManager requestManager, Song song) {
              this.requestManager = requestManager;
              this.song = song;
          }
  
          public PaletteBuilder generatePalette(Context context) {
              return new PaletteBuilder(this, context);
          }
  
          public BitmapBuilder asBitmap() {
              return new BitmapBuilder(this);
          }
  
          public Builder checkIgnoreMediaStore(Context context) {
              return ignoreMediaStore(PreferenceUtil.getInstance(context).ignoreMediaStoreArtwork());
          }
  
          public Builder ignoreMediaStore(boolean ignoreMediaStore) {
              this.ignoreMediaStore = ignoreMediaStore;
              return this;
          }
  
          public DrawableRequestBuilder<GlideDrawable> build() {
              //noinspection unchecked
              return createBaseRequest(requestManager, song, ignoreMediaStore)
                      .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
                      .error(DEFAULT_ERROR_IMAGE)
                      .animate(DEFAULT_ANIMATION)
                      .signature(createSignature(song));
          }
      }
  
      public static class BitmapBuilder {
          private final Builder builder;
  
          public BitmapBuilder(Builder builder) {
              this.builder = builder;
          }
  
          public BitmapRequestBuilder<?, Bitmap> build() {
              //noinspection unchecked
              return createBaseRequest(builder.requestManager, builder.song, builder.ignoreMediaStore)
                      .asBitmap()
                      .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
                      .error(DEFAULT_ERROR_IMAGE)
                      .animate(DEFAULT_ANIMATION)
                      .signature(createSignature(builder.song));
          }
      }
  
      public static class PaletteBuilder {
          final Context context;
          private final Builder builder;
  
          public PaletteBuilder(Builder builder, Context context) {
              this.builder = builder;
              this.context = context;
          }
  
          public BitmapRequestBuilder<?, BitmapPaletteWrapper> build() {
              //noinspection unchecked
              return createBaseRequest(builder.requestManager, builder.song, builder.ignoreMediaStore)
                      .asBitmap()
                      .transcode(new BitmapPaletteTranscoder(context), BitmapPaletteWrapper.class)
                      .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
                      .error(DEFAULT_ERROR_IMAGE)
                      .animate(DEFAULT_ANIMATION)
                      .signature(createSignature(builder.song));
          }
      }
  
      public static DrawableTypeRequest createBaseRequest(RequestManager requestManager, Song song, boolean ignoreMediaStore) {
          if (ignoreMediaStore) {
              return requestManager.load(new AudioFileCover(song.data));
          } else {
              return requestManager.loadFromMediaStore(MusicUtil.getMediaStoreAlbumCoverUri(song.albumId));
          }
      }
  
      public static Key createSignature(Song song) {
          return new MediaStoreSignature("", song.dateModified, 0);
      }
  }
  