Shmakova Anastasia - @shmakova

app/build.gradle

@@ -98,6 +98,19 @@ dependencies {
 
     compile libraries.timber
 
+    compile (libraries.retrofit) {
+        exclude module: 'okhttp'
+    }
+    compile libraries.converterGson
+    compile libraries.adapterRxJava
+    compile libraries.gson
+    compile libraries.okhttp
+    compile libraries.glide
+    compile libraries.okhttpLogging
+
+    compile libraries.rxJava
+    compile libraries.rxAndroid
+
     // Developer tools (Developer Settings)
     compile libraries.stetho
     compile libraries.leakCanary

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

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

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

@@ -10,7 +10,7 @@ public static void init(CriticalSectionsHandler criticalSectionsHandler) {
 
     public static CriticalSectionsHandler getHandler() {
         if (sCriticalSectionsHandler == null) {
-            sCriticalSectionsHandler = new StubCriticalSectionsHandler();
+            sCriticalSectionsHandler = new DefaultCriticalSectionsHandler();
         }
         return sCriticalSectionsHandler;
     }

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

@@ -0,0 +1,89 @@
+package ru.yandex.yamblz.handler;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import timber.log.Timber;
+
+public class DefaultCriticalSectionsHandler implements CriticalSectionsHandler {
+    private static int MAX_QUEUE_SIZE = 6; // столько влазит на экран ._.
+    private ConcurrentLinkedQueue<Task> lowPriorityTasksQueue;
+    private CopyOnWriteArrayList<Integer> sections;
+    private Handler mainHandler;
+
+    public DefaultCriticalSectionsHandler() {
+        lowPriorityTasksQueue = new ConcurrentLinkedQueue<>();
+        sections = new CopyOnWriteArrayList<>();
+        mainHandler = new Handler(Looper.getMainLooper());
+    }
+
+    @Override
+    public void startSection(int id) {
+        Timber.d("Start section with id=" + String.valueOf(id));
+        sections.add(id);
+    }
+
+    @Override
+    public void stopSection(int id) {
+        Timber.d("Stop section with id=" + String.valueOf(id));
+        sections.remove(sections.indexOf(id));
+
+        if (sections.isEmpty()) {
+            runLowPriorityTasksQueue();
+        }
+    }
+
+    @Override
+    public void stopSections() {
+        Timber.d("Stop all sections");
+        sections.clear();
+        runLowPriorityTasksQueue();
+    }
+
+    @Override
+    public void postLowPriorityTask(Task task) {
+        if (sections.isEmpty()) {
+            Timber.d("Low priority task running");
+            mainHandler.post(task::run);
+        } else {
+            Timber.d("Add to queue");
+            lowPriorityTasksQueue.add(task);
+
+            if (lowPriorityTasksQueue.size() > MAX_QUEUE_SIZE) {
+                lowPriorityTasksQueue.poll();
+            }
+        }
+    }
+
+    @Override
+    public void postLowPriorityTaskDelayed(Task task, int delay) {
+        Timber.d("Post low priority task with delay");
+        mainHandler.postDelayed(() -> postLowPriorityTask(task), delay);
+    }
+
+    @Override
+    public void removeLowPriorityTask(Task task) {
+        lowPriorityTasksQueue.remove();
+    }
+
+    @Override
+    public void removeLowPriorityTasks() {
+        lowPriorityTasksQueue.clear();
+    }
+
+    private void runLowPriorityTasksQueue() {
+        while (!lowPriorityTasksQueue.isEmpty()) {
+            Timber.d("Get task from queue");
+            Task task = lowPriorityTasksQueue.peek();
+            postLowPriorityTask(task);
+            removeLowPriorityTask(task);
+
+            if (!sections.isEmpty()) {
+                break;
+            }
+        }
+    }
+}

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

@@ -10,7 +10,7 @@ public static void init(CollageLoader collageLoader) {
 
     public static CollageLoader getLoader() {
         if (sCollageLoader == null) {
-            sCollageLoader = new StubCollageLoader();
+            sCollageLoader = new DefaultCollageLoader();
         }
         return sCollageLoader;
     }

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

@@ -0,0 +1,79 @@
+package ru.yandex.yamblz.loader;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.widget.ImageView;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.List;
+
+import rx.Observable;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.schedulers.Schedulers;
+import timber.log.Timber;
+
+public class DefaultCollageLoader implements CollageLoader {
+    private static final int MAX_COLLAGE_SIZE = 4;
+
+
+    @Override
+    public void loadCollage(List<String> urls, ImageView imageView) {
+        loadCollage(urls, new DefaultImageTarget(imageView));
+    }
+
+    @Override
+    public void loadCollage(List<String> urls, ImageTarget imageTarget) {
+        StripCollageStrategy stripCollageStrategy = new StripCollageStrategy(MAX_COLLAGE_SIZE,
+                StripCollageStrategy.HORIZONTAL_STRIPES);
+        loadCollage(urls, imageTarget, stripCollageStrategy);
+    }
+
+    @Override
+    public void loadCollage(List<String> urls, ImageView imageView,
+                            CollageStrategy collageStrategy) {
+        loadCollage(urls, new DefaultImageTarget(imageView), collageStrategy);
+    }
+
+    @Override
+    public void loadCollage(List<String> urls, ImageTarget imageTarget,
+                            CollageStrategy collageStrategy) {
+
+        Subscription subscription = Observable.from(urls)
+                .take(MAX_COLLAGE_SIZE)
+                .flatMap(this::loadBitmap)
+                .toList()
+                .map(collageStrategy::create)
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(imageTarget::onLoadBitmap,
+                        throwable -> Timber.d(throwable.getMessage()),
+                        () -> Timber.d("Completed"));
+
+        imageTarget.setTag(subscription);
+    }
+
+    private Observable<Bitmap> loadBitmap(String urlString) {
+        return Observable.create(subscriber -> {
+                    HttpURLConnection httpURLConnection = null;
+
+                    try {
+                        httpURLConnection = (HttpURLConnection) new URL(urlString).openConnection();
+                        subscriber.onNext(BitmapFactory.decodeStream(
+                                httpURLConnection.getInputStream()));
+                        subscriber.onCompleted();
+                    } catch (IOException e) {
+                        subscriber.onError(e);
+                    } finally {
+                        if (httpURLConnection != null) {
+                            httpURLConnection.disconnect();
+                        }
+                    }
+                }
+        );
+    }
+
+
+}

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

@@ -0,0 +1,39 @@
+package ru.yandex.yamblz.loader;
+
+import android.graphics.Bitmap;
+import android.widget.ImageView;
+
+import java.lang.ref.WeakReference;
+
+import rx.Subscription;
+
+/**
+ * Created by shmakova on 30.07.16.
+ */
+
+public class DefaultImageTarget implements ImageTarget {
+    private WeakReference<ImageView> weakReferenceImageView;
+
+    public DefaultImageTarget(ImageView imageView) {
+        this.weakReferenceImageView = new WeakReference<>(imageView);
+    }
+
+
+    @Override
+    public void onLoadBitmap(Bitmap bitmap) {
+        ImageView imageView = weakReferenceImageView.get();
+
+        if (imageView != null) {
+            imageView.setImageBitmap(bitmap);
+        }
+    }
+
+    @Override
+    public void setTag(Subscription subscription) {
+        ImageView imageView = weakReferenceImageView.get();
+
+        if (imageView != null) {
+            imageView.setTag(subscription);
+        }
+    }
+}

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

@@ -2,7 +2,11 @@
 
 import android.graphics.Bitmap;
 
+import rx.Subscription;
+
 public interface ImageTarget {
 
     void onLoadBitmap(Bitmap bitmap);
+
+    void setTag(Subscription subscription);
 }