Use priorities for requests fulfilled from cache.

library/src/main/java/com/bumptech/glide/load/engine/DefaultResourceRunnerFactory.java

@@ -15,19 +15,19 @@ import java.io.InputStream;
 import java.util.concurrent.ExecutorService;
 
 class DefaultResourceRunnerFactory implements ResourceRunnerFactory {
-    private final Handler bgHandler;
     private MemoryCache memoryCache;
     private DiskCache diskCache;
     private Handler mainHandler;
+    private ExecutorService diskCacheService;
     private ExecutorService service;
 
     public DefaultResourceRunnerFactory(MemoryCache memoryCache, DiskCache diskCache, Handler mainHandler,
-            ExecutorService service, Handler bgHandler ) {
+            ExecutorService diskCacheService, ExecutorService resizeService) {
         this.memoryCache = memoryCache;
         this.diskCache = diskCache;
         this.mainHandler = mainHandler;
-        this.service = service;
-        this.bgHandler = bgHandler;
+        this.diskCacheService = diskCacheService;
+        this.service = resizeService;
     }
 
     @Override
@@ -42,6 +42,6 @@ class DefaultResourceRunnerFactory implements ResourceRunnerFactory {
                 decoder, transformation, encoder, transcoder, diskCache, priority, engineJob);
 
         return new ResourceRunner<Z, R>(key, width, height, diskCache, cacheDecoder, transformation, transcoder,
-                sourceRunner, service, bgHandler, engineJob);
+                sourceRunner, diskCacheService, service, engineJob, priority);
     }
 }

library/src/main/java/com/bumptech/glide/load/engine/EngineBuilder.java

@@ -3,6 +3,7 @@ package com.bumptech.glide.load.engine;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
+import android.os.Message;
 import com.bumptech.glide.load.engine.executor.FifoPriorityThreadPoolExecutor;
 import com.bumptech.glide.load.engine.cache.DiskCache;
 import com.bumptech.glide.load.engine.cache.MemoryCache;
@@ -13,7 +14,8 @@ public class EngineBuilder {
     final MemoryCache memoryCache;
     final DiskCache diskCache;
 
-    private ExecutorService service;
+    private ExecutorService diskCacheService;
+    private ExecutorService resizeService;
     private Handler bgHandler;
 
     ResourceRunnerFactory factory;
@@ -24,8 +26,13 @@ public class EngineBuilder {
         this.diskCache = diskCache;
     }
 
-    public EngineBuilder setExecutorService(ExecutorService service) {
-        this.service = service;
+    public EngineBuilder setResizeService(ExecutorService service) {
+        resizeService = service;
+        return this;
+    }
+
+    public EngineBuilder setDiskCacheService(ExecutorService service) {
+        diskCacheService = service;
         return this;
     }
 
@@ -35,9 +42,12 @@ public class EngineBuilder {
     }
 
     public Engine build() {
-        if (service == null) {
+        if (resizeService == null) {
             final int cores = Math.max(1, Runtime.getRuntime().availableProcessors());
-            service = new FifoPriorityThreadPoolExecutor(cores);
+            resizeService = new FifoPriorityThreadPoolExecutor(cores);
+        }
+        if (diskCacheService == null) {
+            diskCacheService = new FifoPriorityThreadPoolExecutor(1);
         }
 
         if (bgHandler == null) {
@@ -49,14 +59,23 @@ public class EngineBuilder {
                 }
             };
             handlerThread.start();
-            bgHandler = new Handler(handlerThread.getLooper());
+            bgHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() {
+                @Override
+                public boolean handleMessage(Message message) {
+                    if (message.what == 0) {
+                        ((Runnable) message.obj).run();
+                        return true;
+                    }
+                    return false;
+                }
+            });
         }
 
 
         keyFactory = new EngineKeyFactory();
 
-        factory = new DefaultResourceRunnerFactory(memoryCache, diskCache, new Handler(Looper.getMainLooper()), service,
-                bgHandler);
+        factory = new DefaultResourceRunnerFactory(memoryCache, diskCache, new Handler(Looper.getMainLooper()),
+                diskCacheService, resizeService);
 
         return new Engine(this);
     }

library/src/main/java/com/bumptech/glide/load/engine/ResourceRunner.java

 package com.bumptech.glide.load.engine;
 
-import android.os.Handler;
 import android.os.SystemClock;
 import android.util.Log;
+import com.bumptech.glide.Priority;
 import com.bumptech.glide.Resource;
 import com.bumptech.glide.load.Key;
 import com.bumptech.glide.load.ResourceDecoder;
 import com.bumptech.glide.load.Transformation;
 import com.bumptech.glide.load.engine.cache.DiskCache;
+import com.bumptech.glide.load.engine.executor.Prioritized;
 import com.bumptech.glide.load.resource.transcode.ResourceTranscoder;
 
 import java.io.IOException;
@@ -20,27 +21,28 @@ import java.util.concurrent.Future;
  * @param <Z> The type of the resource that will be decoded.
  * @param <R> the type of the resource the decoded resource will be transcoded to.
  */
-public class ResourceRunner<Z, R> implements Runnable {
+public class ResourceRunner<Z, R> implements Runnable, Prioritized {
     private static final String TAG = "ResourceRunner";
 
     private final Key key;
-    private Transformation<Z> transformation;
-    private ResourceTranscoder<Z, R> transcoder;
+    private final Transformation<Z> transformation;
+    private final ResourceTranscoder<Z, R> transcoder;
     private final SourceResourceRunner sourceRunner;
-    private final ExecutorService executorService;
     private final EngineJob job;
+    private final Priority priority;
     private final ResourceDecoder<InputStream, Z> cacheDecoder;
     private final int width;
     private final int height;
     private final DiskCache diskCache;
-    private final Handler bgHandler;
+    private final ExecutorService diskCacheService;
+    private final ExecutorService resizeService;
     private volatile Future<?> future;
     private volatile boolean isCancelled;
 
     public ResourceRunner(Key key, int width, int height, DiskCache diskCache,
             ResourceDecoder<InputStream, Z> cacheDecoder, Transformation<Z> transformation,
-            ResourceTranscoder<Z, R> transcoder, SourceResourceRunner sourceRunner, ExecutorService executorService,
-            Handler bgHandler, EngineJob job) {
+            ResourceTranscoder<Z, R> transcoder, SourceResourceRunner sourceRunner, ExecutorService diskCacheService,
+            ExecutorService resizeService, EngineJob job, Priority priority) {
         this.key = key;
         this.width = width;
         this.height = height;
@@ -49,9 +51,10 @@ public class ResourceRunner<Z, R> implements Runnable {
         this.transformation = transformation;
         this.transcoder = transcoder;
         this.sourceRunner = sourceRunner;
-        this.executorService = executorService;
-        this.bgHandler = bgHandler;
+        this.diskCacheService = diskCacheService;
+        this.resizeService = resizeService;
         this.job = job;
+        this.priority = priority;
     }
 
     public EngineJob getJob() {
@@ -60,7 +63,6 @@ public class ResourceRunner<Z, R> implements Runnable {
 
     public void cancel() {
         isCancelled = true;
-        bgHandler.removeCallbacks(this);
         if (future != null) {
             future.cancel(false);
         }
@@ -68,7 +70,7 @@ public class ResourceRunner<Z, R> implements Runnable {
     }
 
     public void queue() {
-        bgHandler.post(this);
+        future = diskCacheService.submit(this);
     }
 
     @Override
@@ -90,7 +92,7 @@ public class ResourceRunner<Z, R> implements Runnable {
             Resource<R> transcoded = transcoder.transcode(transformed);
             job.onResourceReady(transcoded);
         } else {
-            future = executorService.submit(sourceRunner);
+            future = resizeService.submit(sourceRunner);
         }
     }
 
@@ -114,4 +116,9 @@ public class ResourceRunner<Z, R> implements Runnable {
         }
         return result;
     }
+
+    @Override
+    public int getPriority() {
+        return priority.ordinal();
+    }
 }

library/src/main/java/com/bumptech/glide/request/ThumbnailRequestCoordinator.java

@@ -30,12 +30,12 @@ public class ThumbnailRequestCoordinator implements RequestCoordinator, Request
 
     @Override
     public void run() {
+        if (!thumb.isRunning()) {
+            thumb.run();
+        }
         if (!full.isRunning()) {
             full.run();
         }
-        if (!full.isComplete() && !thumb.isRunning()) {
-            thumb.run();
-        }
     }
 
     @Override

library/src/test/java/com/bumptech/glide/GlideTest.java

@@ -127,7 +127,8 @@ public class GlideTest {
         requestQueue.start();
         Glide.setup(new GlideBuilder(Robolectric.application)
                 .setEngine(new EngineBuilder(mock(MemoryCache.class), mock(DiskCache.class))
-                        .setExecutorService(service)
+                        .setDiskCacheService(service)
+                        .setResizeService(service)
                         .setBackgroundHandler(bgHandler)
                         .build())
                 .setRequestQueue(requestQueue));

library/src/test/java/com/bumptech/glide/load/engine/DefaultResourceRunnerFactoryTest.java

@@ -41,14 +41,14 @@ public class DefaultResourceRunnerFactoryTest {
         EngineJobListener listener = mock(EngineJobListener.class);
         DiskCache diskCache = mock(DiskCache.class);
         Handler mainHandler = new Handler();
-        Handler bgHandler = mock(Handler.class);
-        ExecutorService service = mock(ExecutorService.class);
+        ExecutorService diskCacheService = mock(ExecutorService.class);
+        ExecutorService resizeService = mock(ExecutorService.class);
         Transformation<Object> transformation = mock(Transformation.class);
         int width = 100;
         int height = 100;
 
         DefaultResourceRunnerFactory factory = new DefaultResourceRunnerFactory(memoryCache, diskCache,
-                mainHandler, service, bgHandler);
+                mainHandler, diskCacheService, resizeService);
 
         ResourceDecoder<InputStream, Object> cacheDecoder = mock(ResourceDecoder.class);
         DataFetcher<Object> fetcher = mock(DataFetcher.class);

library/src/test/java/com/bumptech/glide/load/engine/ResourceRunnerTest.java

 package com.bumptech.glide.load.engine;
 
-import android.os.Handler;
+import com.bumptech.glide.Priority;
 import com.bumptech.glide.Resource;
 import com.bumptech.glide.load.Key;
 import com.bumptech.glide.load.ResourceDecoder;
@@ -18,6 +18,7 @@ import java.io.InputStream;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 
+import static junit.framework.Assert.assertEquals;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Matchers.anyInt;
@@ -46,7 +47,7 @@ public class ResourceRunnerTest {
 
         harness.runner.run();
 
-        verify(harness.service).submit(eq(harness.sourceRunner));
+        verify(harness.resizeService).submit(eq(harness.sourceRunner));
     }
 
     @Test
@@ -166,7 +167,7 @@ public class ResourceRunnerTest {
 
         harness.runner.run();
 
-        verify(harness.service).submit(eq(harness.sourceRunner));
+        verify(harness.resizeService).submit(eq(harness.sourceRunner));
     }
 
     @Test
@@ -176,7 +177,7 @@ public class ResourceRunnerTest {
 
         harness.runner.run();
 
-        verify(harness.service).submit(eq(harness.sourceRunner));
+        verify(harness.resizeService).submit(eq(harness.sourceRunner));
     }
 
     @Test
@@ -186,22 +187,24 @@ public class ResourceRunnerTest {
 
         harness.runner.run();
 
-        verify(harness.service).submit(eq(harness.sourceRunner));
+        verify(harness.resizeService).submit(eq(harness.sourceRunner));
     }
 
     @Test
-    public void testPostedToBackgroundHandlerWhenQueued() {
+    public void testPostedToDiskCacheSerciceWhenQueued() {
         harness.runner.queue();
 
-        verify(harness.bgHandler).post(eq(harness.runner));
+        verify(harness.diskCacheService).submit(eq(harness.runner));
     }
 
     @Test
-    public void testRemovedFromBackgroundHandlerWhenCancelled() {
+    public void testCancelsFutureFromDiskCacheServiceWhenCancelledIfNotYetQueuedToResizeService() {
+        Future future = mock(Future.class);
+        when(harness.diskCacheService.submit(eq(harness.runner))).thenReturn(future);
         harness.runner.queue();
         harness.runner.cancel();
 
-        verify(harness.bgHandler).removeCallbacks(eq(harness.runner));
+        verify(future).cancel(eq(false));
     }
 
     @Test
@@ -257,6 +260,11 @@ public class ResourceRunnerTest {
         verify(harness.decoded, never()).recycle();
     }
 
+    @Test
+    public void testReturnsGivenPriority() {
+        assertEquals(harness.priority.ordinal(), harness.runner.getPriority());
+    }
+
     @SuppressWarnings("unchecked")
     private static class ResourceRunnerHarness {
         Key key = mock(Key.class);
@@ -264,14 +272,15 @@ public class ResourceRunnerTest {
         ResourceDecoder<Object, Object> decoder = mock(ResourceDecoder.class);
         SourceResourceRunner<Object, Object, Object> sourceRunner = mock(SourceResourceRunner.class);
         ResourceTranscoder<Object, Object> transcoder = mock(ResourceTranscoder.class);
-        ExecutorService service = mock(ExecutorService.class);
+        ExecutorService resizeService = mock(ExecutorService.class);
+        ExecutorService diskCacheService = mock(ExecutorService.class);
         EngineJob engineJob = mock(EngineJob.class);
-        Handler bgHandler = mock(Handler.class);
         Transformation<Object> tranformation = mock(Transformation.class);
         int width = 100;
         int height = 100;
+        Priority priority = Priority.HIGH;
         ResourceRunner<Object, Object> runner = new ResourceRunner(key, width, height, diskCache, decoder,
-                tranformation, transcoder, sourceRunner, service, bgHandler, engineJob);
+                tranformation, transcoder, sourceRunner, diskCacheService, resizeService,engineJob, priority);
         Future future = mock(Future.class);
         Future sourceFuture = mock(Future.class);
         Resource<Object> decoded = mock(Resource.class);
@@ -280,8 +289,8 @@ public class ResourceRunnerTest {
 
         public ResourceRunnerHarness() {
             when(key.toString()).thenReturn(ID);
-            when(service.submit(eq(runner))).thenReturn(future);
-            when(service.submit(eq(sourceRunner))).thenReturn(sourceFuture);
+            when(resizeService.submit(eq(runner))).thenReturn(future);
+            when(resizeService.submit(eq(sourceRunner))).thenReturn(sourceFuture);
         }
     }
 }

library/src/test/java/com/bumptech/glide/request/ThumbnailRequestCoordinatorTest.java

@@ -57,14 +57,6 @@ public class ThumbnailRequestCoordinatorTest {
         verify(thumb).run();
     }
 
-    @Test
-    public void testDoesNotStartThumbOnRunIfFullCompletesSynchronously() {
-        when(full.isComplete()).thenReturn(true);
-        coordinator.run();
-
-        verify(thumb, never()).run();
-    }
-
     @Test
     public void testDoesNotStartFullOnRunIfRunning() {
         when(full.isRunning()).thenReturn(true);