Rename project

2016-01-15 15:18:19 +01:00
parent 1508bf42fb
commit 70f4c7fcc3
167 changed files with 647 additions and 654 deletions
@@ -0,0 +1,197 @@
+package eu.kanade.tachiyomi.data.cache;
+
+import android.content.Context;
+import android.text.format.Formatter;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.jakewharton.disklrucache.DiskLruCache;
+import com.squareup.okhttp.Response;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Type;
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.source.model.Page;
+import eu.kanade.tachiyomi.util.DiskUtils;
+import okio.BufferedSink;
+import okio.Okio;
+import rx.Observable;
+
+public class ChapterCache {
+
+    private static final String PARAMETER_CACHE_DIRECTORY = "chapter_disk_cache";
+    private static final int PARAMETER_APP_VERSION = 1;
+    private static final int PARAMETER_VALUE_COUNT = 1;
+    private static final int PARAMETER_CACHE_SIZE = 75 * 1024 * 1024;
+
+    private Context context;
+    private Gson gson;
+
+    private DiskLruCache diskCache;
+
+    public ChapterCache(Context context) {
+        this.context = context;
+        gson = new Gson();
+
+        try {
+            diskCache = DiskLruCache.open(
+                    new File(context.getCacheDir(), PARAMETER_CACHE_DIRECTORY),
+                    PARAMETER_APP_VERSION,
+                    PARAMETER_VALUE_COUNT,
+                    PARAMETER_CACHE_SIZE
+            );
+        } catch (IOException e) {
+            // Do Nothing.
+        }
+    }
+
+    public boolean remove(String file) {
+        if (file.equals("journal") || file.startsWith("journal."))
+            return false;
+
+        try {
+            String key = file.substring(0, file.lastIndexOf("."));
+            return diskCache.remove(key);
+        } catch (IOException e) {
+            return false;
+        }
+    }
+
+    public File getCacheDir() {
+        return diskCache.getDirectory();
+    }
+
+    public long getRealSize() {
+        return DiskUtils.getDirectorySize(getCacheDir());
+    }
+
+    public String getReadableSize() {
+        return Formatter.formatFileSize(context, getRealSize());
+    }
+
+    public void setSize(int value) {
+        diskCache.setMaxSize(value * 1024 * 1024);
+    }
+
+    public Observable<List<Page>> getPageUrlsFromDiskCache(final String chapterUrl) {
+        return Observable.create(subscriber -> {
+            try {
+                List<Page> pages = getPageUrlsFromDiskCacheImpl(chapterUrl);
+                subscriber.onNext(pages);
+                subscriber.onCompleted();
+            } catch (Throwable e) {
+                subscriber.onError(e);
+            }
+        });
+    }
+
+    private List<Page> getPageUrlsFromDiskCacheImpl(String chapterUrl) throws IOException {
+        DiskLruCache.Snapshot snapshot = null;
+        List<Page> pages = null;
+
+        try {
+            String key = DiskUtils.hashKeyForDisk(chapterUrl);
+            snapshot = diskCache.get(key);
+
+            Type collectionType = new TypeToken<List<Page>>() {}.getType();
+            pages = gson.fromJson(snapshot.getString(0), collectionType);
+        } catch (IOException e) {
+            // Do Nothing.
+        } finally {
+            if (snapshot != null) {
+                snapshot.close();
+            }
+        }
+        return pages;
+    }
+
+    public void putPageUrlsToDiskCache(final String chapterUrl, final List<Page> pages) {
+        String cachedValue = gson.toJson(pages);
+
+        DiskLruCache.Editor editor = null;
+        OutputStream outputStream = null;
+        try {
+            String key = DiskUtils.hashKeyForDisk(chapterUrl);
+            editor = diskCache.edit(key);
+            if (editor == null) {
+                return;
+            }
+
+            outputStream = new BufferedOutputStream(editor.newOutputStream(0));
+            outputStream.write(cachedValue.getBytes());
+            outputStream.flush();
+
+            diskCache.flush();
+            editor.commit();
+        } catch (Exception e) {
+            // Do Nothing.
+        } finally {
+            if (editor != null) {
+                editor.abortUnlessCommitted();
+            }
+            if (outputStream != null) {
+                try {
+                    outputStream.close();
+                } catch (IOException ignore) {
+                    // Do Nothing.
+                }
+            }
+        }
+    }
+
+    public boolean isImageInCache(final String imageUrl) {
+        try {
+            return diskCache.get(DiskUtils.hashKeyForDisk(imageUrl)) != null;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    public String getImagePath(final String imageUrl) {
+        try {
+            String imageName = DiskUtils.hashKeyForDisk(imageUrl) + ".0";
+            File file = new File(diskCache.getDirectory(), imageName);
+            return file.getCanonicalPath();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public void putImageToDiskCache(final String imageUrl, final Response response) throws IOException {
+        DiskLruCache.Editor editor = null;
+        BufferedSink sink = null;
+
+        try {
+            String key = DiskUtils.hashKeyForDisk(imageUrl);
+            editor = diskCache.edit(key);
+            if (editor == null) {
+                throw new IOException("Unable to edit key");
+            }
+
+            OutputStream outputStream = new BufferedOutputStream(editor.newOutputStream(0));
+            sink = Okio.buffer(Okio.sink(outputStream));
+            sink.writeAll(response.body().source());
+
+            diskCache.flush();
+            editor.commit();
+        } catch (Exception e) {
+            throw new IOException("Unable to save image");
+        } finally {
+            if (editor != null) {
+                editor.abortUnlessCommitted();
+            }
+            if (sink != null) {
+                sink.close();
+            }
+        }
+
+    }
+
+}
+
@@ -0,0 +1,148 @@
+package eu.kanade.tachiyomi.data.cache;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.widget.ImageView;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.load.engine.DiskCacheStrategy;
+import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.load.model.LazyHeaders;
+import com.bumptech.glide.request.animation.GlideAnimation;
+import com.bumptech.glide.request.target.SimpleTarget;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import eu.kanade.tachiyomi.util.DiskUtils;
+
+public class CoverCache {
+
+    private static final String PARAMETER_CACHE_DIRECTORY = "cover_disk_cache";
+
+    private Context context;
+    private File cacheDir;
+
+    public CoverCache(Context context) {
+        this.context = context;
+        cacheDir = new File(context.getCacheDir(), PARAMETER_CACHE_DIRECTORY);
+        createCacheDir();
+    }
+
+    private boolean createCacheDir() {
+        return !cacheDir.exists() && cacheDir.mkdirs();
+    }
+
+    public void save(String thumbnailUrl, LazyHeaders headers) {
+        save(thumbnailUrl, headers, null);
+    }
+
+    // Download the cover with Glide (it can avoid repeating requests) and save the file on this cache
+    // Optionally, load the image in the given image view when the resource is ready, if not null
+    public void save(String thumbnailUrl, LazyHeaders headers, ImageView imageView) {
+        if (TextUtils.isEmpty(thumbnailUrl))
+            return;
+
+        GlideUrl url = new GlideUrl(thumbnailUrl, headers);
+        Glide.with(context)
+                .load(url)
+                .downloadOnly(new SimpleTarget<File>() {
+                    @Override
+                    public void onResourceReady(File resource, GlideAnimation<? super File> anim) {
+                        try {
+                            add(thumbnailUrl, resource);
+                            if (imageView != null) {
+                                loadFromCache(imageView, resource);
+                            }
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                });
+    }
+
+    // Copy the cover from Glide's cache to this cache
+    public void add(String thumbnailUrl, File source) throws IOException {
+        createCacheDir();
+        File dest = new File(cacheDir, DiskUtils.hashKeyForDisk(thumbnailUrl));
+        if (dest.exists())
+            dest.delete();
+
+        InputStream in = new FileInputStream(source);
+        try {
+            OutputStream out = new FileOutputStream(dest);
+            try {
+                // Transfer bytes from in to out
+                byte[] buf = new byte[1024];
+                int len;
+                while ((len = in.read(buf)) > 0) {
+                    out.write(buf, 0, len);
+                }
+            } finally {
+                out.close();
+            }
+        } finally {
+            in.close();
+        }
+    }
+
+    // Get the cover from cache
+    public File get(String thumbnailUrl) {
+        return new File(cacheDir, DiskUtils.hashKeyForDisk(thumbnailUrl));
+    }
+
+    // Delete the cover from cache
+    public boolean delete(String thumbnailUrl) {
+        if (TextUtils.isEmpty(thumbnailUrl))
+            return false;
+
+        File file = new File(cacheDir, DiskUtils.hashKeyForDisk(thumbnailUrl));
+        return file.exists() && file.delete();
+    }
+
+    // Save and load the image from cache
+    public void saveAndLoadFromCache(ImageView imageView, String thumbnailUrl, LazyHeaders headers) {
+        File localCover = get(thumbnailUrl);
+        if (localCover.exists()) {
+            loadFromCache(imageView, localCover);
+        } else {
+            save(thumbnailUrl, headers, imageView);
+        }
+    }
+
+    // If the image is already in our cache, use it. If not, load it with glide
+    public void loadFromCacheOrNetwork(ImageView imageView, String thumbnailUrl, LazyHeaders headers) {
+        File localCover = get(thumbnailUrl);
+        if (localCover.exists()) {
+            loadFromCache(imageView, localCover);
+        } else {
+            loadFromNetwork(imageView, thumbnailUrl, headers);
+        }
+    }
+
+    // Helper method to load the cover from the cache directory into the specified image view
+    // The file must exist
+    private void loadFromCache(ImageView imageView, File file) {
+        Glide.with(context)
+                .load(file)
+                .diskCacheStrategy(DiskCacheStrategy.NONE)
+                .centerCrop()
+                .into(imageView);
+    }
+
+    // Helper method to load the cover from network into the specified image view.
+    // It does NOT save the image in cache
+    public void loadFromNetwork(ImageView imageView, String thumbnailUrl, LazyHeaders headers) {
+        GlideUrl url = new GlideUrl(thumbnailUrl, headers);
+        Glide.with(context)
+                .load(url)
+                .diskCacheStrategy(DiskCacheStrategy.SOURCE)
+                .centerCrop()
+                .into(imageView);
+    }
+
+}
@@ -0,0 +1,21 @@
+package eu.kanade.tachiyomi.data.cache;
+
+import android.content.Context;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.GlideBuilder;
+import com.bumptech.glide.load.DecodeFormat;
+import com.bumptech.glide.module.GlideModule;
+
+public class CoverGlideModule implements GlideModule {
+
+    @Override
+    public void applyOptions(Context context, GlideBuilder builder) {
+        builder.setDecodeFormat(DecodeFormat.PREFER_ARGB_8888);
+    }
+
+    @Override
+    public void registerComponents(Context context, Glide glide) {
+
+    }
+}