(@gringauz.a) Александр Грингауз

app/build.gradle

@@ -121,6 +121,8 @@ dependencies {
         exclude module: 'recyclerview-v7'
         exclude module: 'support-v4'
     }
+
+    compile libraries.gson
 }
 
 configurations.all {

app/src/main/java/ru/yandex/yamblz/App.java

@@ -6,8 +6,6 @@
 
 import ru.yandex.yamblz.developer_settings.DevMetricsProxy;
 import ru.yandex.yamblz.developer_settings.DeveloperSettingsModel;
-import ru.yandex.yamblz.handler.CriticalSectionsManager;
-import ru.yandex.yamblz.loader.CollageLoaderManager;
 import timber.log.Timber;
 
 public class App extends Application {
@@ -34,8 +32,6 @@ public void onCreate() {
             devMetricsProxy.apply();
         }
 
-        CollageLoaderManager.init(null);  // add implementation
-        CriticalSectionsManager.init(null); // add implementation
     }
 
     @NonNull

app/src/main/java/ru/yandex/yamblz/ApplicationComponent.java

@@ -3,6 +3,8 @@
 import android.os.Handler;
 import android.support.annotation.NonNull;
 
+import java.util.concurrent.ThreadPoolExecutor;
+
 import javax.inject.Named;
 import javax.inject.Singleton;
 
@@ -12,7 +14,10 @@
 import ru.yandex.yamblz.developer_settings.DeveloperSettingsModel;
 import ru.yandex.yamblz.developer_settings.DeveloperSettingsModule;
 import ru.yandex.yamblz.developer_settings.LeakCanaryProxy;
+import ru.yandex.yamblz.images.ImageCache;
 import ru.yandex.yamblz.ui.activities.MainActivity;
+import ru.yandex.yamblz.ui.adapters.GenresAdapter;
+import ru.yandex.yamblz.ui.fragments.ContentFragment;
 
 @Singleton
 @Component(modules = {
@@ -35,5 +40,15 @@ public interface ApplicationComponent {
     @NonNull @Named(ApplicationModule.MAIN_THREAD_HANDLER)
     Handler mainThreadHandler();
 
+    @Named(ApplicationModule.THREAD_POOL_EXECUTOR) @Singleton
+    ThreadPoolExecutor mainExecutor();
+
+    @Named(ApplicationModule.IMAGE_CACHE) @Singleton
+    ImageCache imageCache();
+
+
+
     void inject(@NonNull MainActivity mainActivity);
+    void inject(@NonNull GenresAdapter.GenresHolder genresHolder);
+    void inject(@NonNull ContentFragment contentFragment);
 }

app/src/main/java/ru/yandex/yamblz/ApplicationModule.java

@@ -5,16 +5,26 @@
 import android.os.Looper;
 import android.support.annotation.NonNull;
 
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
 import javax.inject.Named;
 import javax.inject.Singleton;
 
 import dagger.Module;
 import dagger.Provides;
+import ru.yandex.yamblz.handler.CriticalSectionsHandler;
+import ru.yandex.yamblz.handler.CriticalSectionsHandlerImpl;
+import ru.yandex.yamblz.images.ImageCache;
 
 @Module
 public class ApplicationModule {
 
     public static final String MAIN_THREAD_HANDLER = "main_thread_handler";
+    public static final String THREAD_POOL_EXECUTOR = "main_thread_pool_executor";
+    public static final String IMAGE_CACHE = "image_cache";
+    public static final String MAIN_THREAD_CRITICAL_SECTIONS_HANDLER = "image_cache";
 
     @NonNull
     private final Application application;
@@ -33,4 +43,21 @@ public Handler provideMainThreadHandler() {
         return new Handler(Looper.getMainLooper());
     }
 
+    @Provides @Named(ApplicationModule.THREAD_POOL_EXECUTOR) @Singleton
+    ThreadPoolExecutor provideMainExecutor() {
+        int nCores = Runtime.getRuntime().availableProcessors();
+        return new ThreadPoolExecutor(nCores, nCores, 120, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
+    }
+
+    @Provides @Named(ApplicationModule.IMAGE_CACHE) @Singleton
+    public ImageCache provideImageCache() {
+        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
+        return new ImageCache(maxMemory / 8);
+    }
+
+    @Provides @Named(MAIN_THREAD_CRITICAL_SECTIONS_HANDLER) @Singleton
+    public CriticalSectionsHandler provideMainThreadCriticalSectionHandler(@Named(MAIN_THREAD_HANDLER) Handler mainThreadHandler) {
+        return new CriticalSectionsHandlerImpl(mainThreadHandler);
+    }
+
 }

app/src/main/java/ru/yandex/yamblz/handler/CriticalSectionsHandlerImpl.java

@@ -0,0 +1,93 @@
+package ru.yandex.yamblz.handler;
+
+import android.os.Handler;
+import android.os.HandlerThread;
+
+import java.util.HashSet;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+
+public class CriticalSectionsHandlerImpl implements CriticalSectionsHandler {
+
+    private HashSet<Integer> sectionsSet = new HashSet<>();
+    private HashSet<Task> tasksInQueue = new HashSet<>();
+    private Queue<Task> lowPriorityTasksQueue = new LinkedList<>();
+
+    private Handler mainThreadHandler;
+    private Handler waitingHandler;
+
+    public CriticalSectionsHandlerImpl(Handler mainThreadHandler) {
+        this.mainThreadHandler = mainThreadHandler;
+        HandlerThread waitingThread = new HandlerThread("waiting");
+        waitingThread.start();
+        waitingHandler = new Handler(waitingThread.getLooper());
+    }
+
+    @Override
+    public void startSection(int id) {
+        sectionsSet.add(id);
+    }
+
+    @Override
+    public void stopSection(int id) {
+        sectionsSet.remove(id);
+        postQueuedTasks();
+    }
+
+    @Override
+    public void stopSections() {
+        sectionsSet.clear();
+        postQueuedTasks();
+    }
+
+    @Override
+    public void postLowPriorityTask(Task task) {
+        if (isInSection()) {
+            lowPriorityTasksQueue.add(task);
+            tasksInQueue.add(task);
+        }
+        else {
+            mainThreadHandler.post(task::run);
+        }
+    }
+
+    @Override
+    public void postLowPriorityTaskDelayed(Task task, int delay) {
+        waitingHandler.postDelayed(() -> {
+            if (isInSection()) {
+                lowPriorityTasksQueue.add(task);
+            }
+            else {
+                mainThreadHandler.post(task::run);
+            }
+        }, delay);
+        tasksInQueue.add(task);
+    }
+
+    @Override
+    public void removeLowPriorityTask(Task task) {
+        tasksInQueue.remove(task);
+    }
+
+    @Override
+    public void removeLowPriorityTasks() {
+        tasksInQueue.clear();
+        lowPriorityTasksQueue.clear();
+    }
+
+    boolean isInSection() {
+        return sectionsSet.size() > 0;
+    }
+
+    void postQueuedTasks() {
+        while (!lowPriorityTasksQueue.isEmpty()) {
+            Task task = lowPriorityTasksQueue.remove();
+            if (tasksInQueue.contains(task)) {
+                tasksInQueue.remove(task);
+                mainThreadHandler.post(task::run);
+            }
+        }
+    }
+}

app/src/main/java/ru/yandex/yamblz/images/ImageCache.java

@@ -0,0 +1,24 @@
+package ru.yandex.yamblz.images;
+
+import android.graphics.Bitmap;
+import android.support.v4.util.LruCache;
+
+/**
+ * Created by grin3s on 07.08.16.
+ */
+
+public class ImageCache extends LruCache<String, Bitmap> {
+    /**
+     * @param maxSize for caches that do not override {@link #sizeOf}, this is
+     *                the maximum number of entries in the cache. For all other caches,
+     *                this is the maximum sum of the sizes of the entries in this cache.
+     */
+    public ImageCache(int maxSize) {
+        super(maxSize);
+    }
+
+    @Override
+    protected int sizeOf(String key, Bitmap bitmap) {
+        return bitmap.getByteCount() / 1024;
+    }
+}

app/src/main/java/ru/yandex/yamblz/images/ImageDownloadTask.java

@@ -0,0 +1,35 @@
+package ru.yandex.yamblz.images;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.concurrent.Callable;
+
+/**
+ * Created by grin3s on 06.08.16.
+ */
+
+public class ImageDownloadTask implements Callable<Bitmap> {
+    String url;
+
+    public ImageDownloadTask(String url) {
+        this.url = url;
+    }
+
+    @Override
+    public Bitmap call() throws Exception {
+        try {
+            URL url = new URL(this.url);
+            InputStream inputStream = new BufferedInputStream(url.openStream());
+            Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
+            return bitmap;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}

app/src/main/java/ru/yandex/yamblz/loader/AsyncLoader.java

@@ -0,0 +1,9 @@
+package ru.yandex.yamblz.loader;
+
+/**
+ * Created by grin3s on 07.08.16.
+ */
+
+// and interface describing a general class that loads something in the background
+public interface AsyncLoader {
+}

app/src/main/java/ru/yandex/yamblz/loader/CollageLoader.java

@@ -4,14 +4,14 @@
 
 import java.util.List;
 
-public interface CollageLoader {
+public abstract class CollageLoader implements AsyncLoader{
 
-    void loadCollage(List<String> urls, ImageView imageView);
+    public abstract void loadCollage(List<String> urls, ImageView imageView);
 
-    void loadCollage(List<String> urls, ImageTarget imageTarget);
+    public abstract void loadCollage(List<String> urls, ImageTarget imageTarget);
 
-    void loadCollage(List<String> urls, ImageView imageView, CollageStrategy collageStrategy);
+    public abstract void loadCollage(List<String> urls, ImageView imageView, CollageStrategy collageStrategy);
 
-    void loadCollage(List<String> urls, ImageTarget imageTarget, CollageStrategy collageStrategy);
+    public abstract void loadCollage(List<String> urls, ImageTarget imageTarget, CollageStrategy collageStrategy);
 
 }