BackGround Loader+Handler

app/build.gradle

@@ -104,6 +104,8 @@ dependencies {
     compile libraries.tinyDancer
     compile libraries.lynx
     compile libraries.processPhoenix
+    compile 'com.googlecode.json-simple:json-simple:1.1'
+
 
     testCompile libraries.junit
     testCompile libraries.robolectric

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.StubCriticalSectionsHandler;
 import ru.yandex.yamblz.loader.CollageLoaderManager;
+import ru.yandex.yamblz.loader.StubCollageLoader;
 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 StubCollageLoader());  // add implementation
+        CriticalSectionsManager.init(new StubCriticalSectionsHandler()); // add implementation
     }
 
     @NonNull

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

@@ -1,39 +1,97 @@
 package ru.yandex.yamblz.handler;
 
+
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import junit.framework.Test;
+
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
 public class StubCriticalSectionsHandler implements CriticalSectionsHandler {
 
+    private Handler handler = new Handler(Looper.getMainLooper());
+    //private LinkedList<Task> taskList = new LinkedList<>();
+    private Set<Integer> sections = new HashSet<>();
+    private ConcurrentLinkedQueue<Task> taskList = new ConcurrentLinkedQueue<>();
+    private Map<Task, Runnable> delayTasks = new LinkedHashMap<>();
+
+    private Runnable callback = new Runnable(){
+        @Override
+        public void run() {
+            Task taskToExecute = null;
+            if (taskList.isEmpty()) {
+                return;
+            }
+            taskToExecute = taskList.poll();
+            taskToExecute.run();
+            if (sections.isEmpty()){
+                handler.post(callback);
+            }
+        }
+    };
+
     @Override
     public void startSection(int id) {
-
+        Log.i("Section", "start " + taskList.size());
+        sections.add(id);
+        handler.removeCallbacks(callback);
     }
 
     @Override
     public void stopSection(int id) {
-
+        Log.i("Section", "stop " + taskList.size());
+        sections.remove(id);
+        if (sections.isEmpty()) {
+            handler.post(callback);
+        }
     }
 
     @Override
     public void stopSections() {
-
+        Log.i("Sections", "all stop " + taskList.size());
+        sections.clear();
+        handler.post(callback);
     }
 
     @Override
     public void postLowPriorityTask(Task task) {
+        Log.i("LowPriotityTask", "start " + taskList.size());
+        taskList.add(task);
+        if (taskList.size() == 1 && sections.isEmpty()) {
+            handler.post(callback);
+        }
 
     }
 
     @Override
     public void postLowPriorityTaskDelayed(Task task, int delay) {
-
+        Log.i("LowPriorityTaskDelay", "start " + taskList.size());
+        Runnable runnable = () -> postLowPriorityTask(task);
+        delayTasks.put(task, runnable);
+        handler.postDelayed(runnable, delay);
     }
 
     @Override
     public void removeLowPriorityTask(Task task) {
-
+        Log.i("RemoveLwPriotityTask", "start " + taskList.size());
+        taskList.remove(task);
+        handler.removeCallbacks(delayTasks.get(task));
     }
 
     @Override
     public void removeLowPriorityTasks() {
-
+        taskList.clear();
     }
+
+
 }

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

@@ -7,4 +7,5 @@
 public interface CollageStrategy {
 
     Bitmap create(List<Bitmap> bitmaps);
+
 }

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

@@ -0,0 +1,41 @@
+package ru.yandex.yamblz.loader;
+
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.util.Log;
+
+import java.util.List;
+
+/**
+ * Created by dan on 29.07.16.
+ */
+public class CollageStrategyImpl implements CollageStrategy {
+    @Override
+    public Bitmap create(List<Bitmap> bitmaps) {
+        if (bitmaps.size() >= 4) {
+            Log.i("String", "Im here beach with 4 pics");
+            Bitmap bitmap = Bitmap.createBitmap(600, 600, Bitmap.Config.ARGB_8888);
+            Canvas canvas = new Canvas(bitmap);
+            canvas.drawBitmap(bitmaps.get(0), 0, 0, null);
+            canvas.drawBitmap(bitmaps.get(1), 300, 0, null);
+            canvas.drawBitmap(bitmaps.get(2), 0, 300, null);
+            canvas.drawBitmap(bitmaps.get(3), 300, 300, null);
+            canvas.save();
+            return bitmap;
+        }
+        else {
+            Log.i("String", "Im here beach with 1 pic");
+            Bitmap bitmap = Bitmap.createBitmap(600, 600, Bitmap.Config.ARGB_8888);
+            Canvas canvas = new Canvas(bitmap);
+            canvas.drawBitmap(bitmaps.get(0), 0, 0, null);
+            canvas.save();
+            return bitmaps.get(0);
+        }
+
+    }
+
+
+}

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

@@ -1,11 +1,40 @@
 package ru.yandex.yamblz.loader;
 
+import android.app.Activity;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.DrawableContainer;
+import android.util.Log;
 import android.widget.ImageView;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import ru.yandex.yamblz.App;
+import ru.yandex.yamblz.R;
+import ru.yandex.yamblz.handler.CriticalSectionsManager;
+import ru.yandex.yamblz.handler.Task;
+import ru.yandex.yamblz.ui.activities.BaseActivity;
+import ru.yandex.yamblz.ui.activities.MainActivity;
+import ru.yandex.yamblz.ui.fragments.ArtistAdapter;
+import ru.yandex.yamblz.ui.fragments.ArtistListFragment;
+import ru.yandex.yamblz.ui.fragments.BaseFragment;
 
 public class StubCollageLoader implements CollageLoader {
 
+    private static final int THREADS = 4;
+
+    public ExecutorService threadPool = Executors.newFixedThreadPool(THREADS);
+
     @Override
     public void loadCollage(List<String> urls, ImageView imageView) {
 
@@ -20,6 +49,62 @@ public void loadCollage(List<String> urls, ImageTarget imageTarget) {
     public void loadCollage(List<String> urls, ImageView imageView,
                             CollageStrategy collageStrategy) {
 
+
+        UUID uuid = UUID.randomUUID();
+        Object oldCreateImages = imageView.getTag();
+
+
+        if (oldCreateImages != null) {
+            CriticalSectionsManager.getHandler().removeLowPriorityTask((Task) oldCreateImages);
+        }
+
+        Task setter = () -> {
+            threadPool.execute(() -> {
+                loadCollage(urls, imageView, collageStrategy, uuid);
+            });
+        };
+        imageView.setTag(setter);
+        imageView.setTag(R.id.recycler_item_image, uuid);
+        CriticalSectionsManager.getHandler().postLowPriorityTask(setter);
+    }
+
+    public void loadCollage(List<String> urls, ImageView imageView,
+                            CollageStrategy collageStrategy, UUID uuid) {
+        Runnable rr = () -> {
+            List<Bitmap> bitmapList = new ArrayList<>();
+            int len = 1;
+            if (urls.size() >= 4) {
+                len = 4;
+            }
+            for (int i = 0; i < len; i++) {
+                bitmapList.add(getBitmapFromUrl(urls.get(i)));
+            }
+            Bitmap bitmap = collageStrategy.create(bitmapList);
+            if (imageView != null && imageView.getTag(R.id.recycler_item_image).equals(uuid)) {
+                imageView.post(() -> imageView.setImageBitmap(bitmap));
+            }
+        };
+
+        threadPool.submit(rr);
+
+    }
+
+
+
+    public Bitmap getBitmapFromUrl(String link) {
+        try {
+            URL url = new URL(link);
+            HttpURLConnection connection = (HttpURLConnection)url.openConnection();
+            connection.setDoInput(true);
+            connection.connect();
+            InputStream input = connection.getInputStream();
+            return BitmapFactory.decodeStream(input);
+        } catch (MalformedURLException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
     }
 
     @Override
@@ -28,4 +113,6 @@ public void loadCollage(List<String> urls, ImageTarget imageTarget,
 
     }
 
+
+
 }

app/src/main/java/ru/yandex/yamblz/ui/activities/MainActivity.java

@@ -3,14 +3,15 @@
 import android.annotation.SuppressLint;
 import android.os.Bundle;
 import android.support.annotation.Nullable;
+import android.view.View;
 
 import javax.inject.Inject;
 import javax.inject.Named;
 
 import ru.yandex.yamblz.App;
 import ru.yandex.yamblz.R;
 import ru.yandex.yamblz.developer_settings.DeveloperSettingsModule;
-import ru.yandex.yamblz.ui.fragments.ContentFragment;
+import ru.yandex.yamblz.ui.fragments.ArtistListFragment;
 import ru.yandex.yamblz.ui.other.ViewModifier;
 
 public class MainActivity extends BaseActivity {
@@ -27,10 +28,14 @@ protected void onCreate(@Nullable Bundle savedInstanceState) {
         setContentView(viewModifier.modify(getLayoutInflater().inflate(R.layout.activity_main, null)));
 
         if (savedInstanceState == null) {
-            getSupportFragmentManager()
-                    .beginTransaction()
-                    .replace(R.id.main_frame_layout, new ContentFragment())
+            getSupportFragmentManager().beginTransaction().replace(R.id.main_frame_layout, new ArtistListFragment())
                     .commit();
         }
     }
+
+    public void onClick(View v) {
+        return;
+    }
+
+
 }