Rename project

app/src/main/java/eu/kanade/tachiyomi/data/cache/ChapterCache.java

@@ -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();
+            }
+        }
+
+    }
+
+}
+

app/src/main/java/eu/kanade/tachiyomi/data/cache/CoverCache.java

@@ -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);
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/cache/CoverGlideModule.java

@@ -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) {
+
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/DatabaseHelper.java

@@ -0,0 +1,415 @@
+package eu.kanade.tachiyomi.data.database;
+
+import android.content.Context;
+import android.util.Pair;
+
+import com.pushtorefresh.storio.Queries;
+import com.pushtorefresh.storio.sqlite.StorIOSQLite;
+import com.pushtorefresh.storio.sqlite.impl.DefaultStorIOSQLite;
+import com.pushtorefresh.storio.sqlite.operations.delete.PreparedDeleteByQuery;
+import com.pushtorefresh.storio.sqlite.operations.delete.PreparedDeleteCollectionOfObjects;
+import com.pushtorefresh.storio.sqlite.operations.delete.PreparedDeleteObject;
+import com.pushtorefresh.storio.sqlite.operations.get.PreparedGetListOfObjects;
+import com.pushtorefresh.storio.sqlite.operations.get.PreparedGetObject;
+import com.pushtorefresh.storio.sqlite.operations.put.PreparedPutCollectionOfObjects;
+import com.pushtorefresh.storio.sqlite.operations.put.PreparedPutObject;
+import com.pushtorefresh.storio.sqlite.queries.DeleteQuery;
+import com.pushtorefresh.storio.sqlite.queries.Query;
+import com.pushtorefresh.storio.sqlite.queries.RawQuery;
+
+import java.util.Date;
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.database.models.Category;
+import eu.kanade.tachiyomi.data.database.models.CategorySQLiteTypeMapping;
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.ChapterSQLiteTypeMapping;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.database.models.MangaCategory;
+import eu.kanade.tachiyomi.data.database.models.MangaCategorySQLiteTypeMapping;
+import eu.kanade.tachiyomi.data.database.models.MangaSQLiteTypeMapping;
+import eu.kanade.tachiyomi.data.database.models.MangaSync;
+import eu.kanade.tachiyomi.data.database.models.MangaSyncSQLiteTypeMapping;
+import eu.kanade.tachiyomi.data.database.resolvers.LibraryMangaGetResolver;
+import eu.kanade.tachiyomi.data.database.tables.CategoryTable;
+import eu.kanade.tachiyomi.data.database.tables.ChapterTable;
+import eu.kanade.tachiyomi.data.database.tables.MangaCategoryTable;
+import eu.kanade.tachiyomi.data.database.tables.MangaSyncTable;
+import eu.kanade.tachiyomi.data.database.tables.MangaTable;
+import eu.kanade.tachiyomi.data.mangasync.base.MangaSyncService;
+import eu.kanade.tachiyomi.util.ChapterRecognition;
+import rx.Observable;
+
+public class DatabaseHelper {
+
+    private StorIOSQLite db;
+
+    public DatabaseHelper(Context context) {
+
+        db = DefaultStorIOSQLite.builder()
+                .sqliteOpenHelper(new DbOpenHelper(context))
+                .addTypeMapping(Manga.class, new MangaSQLiteTypeMapping())
+                .addTypeMapping(Chapter.class, new ChapterSQLiteTypeMapping())
+                .addTypeMapping(MangaSync.class, new MangaSyncSQLiteTypeMapping())
+                .addTypeMapping(Category.class, new CategorySQLiteTypeMapping())
+                .addTypeMapping(MangaCategory.class, new MangaCategorySQLiteTypeMapping())
+                .build();
+    }
+
+    // Mangas related queries
+
+    public PreparedGetListOfObjects<Manga> getMangas() {
+        return db.get()
+                .listOfObjects(Manga.class)
+                .withQuery(Query.builder()
+                        .table(MangaTable.TABLE)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedGetListOfObjects<Manga> getLibraryMangas() {
+        return db.get()
+                .listOfObjects(Manga.class)
+                .withQuery(RawQuery.builder()
+                        .query(LibraryMangaGetResolver.QUERY)
+                        .observesTables(MangaTable.TABLE, ChapterTable.TABLE, MangaCategoryTable.TABLE)
+                        .build())
+                .withGetResolver(LibraryMangaGetResolver.INSTANCE)
+                .prepare();
+    }
+
+    public PreparedGetListOfObjects<Manga> getFavoriteMangas() {
+        return db.get()
+                .listOfObjects(Manga.class)
+                .withQuery(Query.builder()
+                        .table(MangaTable.TABLE)
+                        .where(MangaTable.COLUMN_FAVORITE + "=?")
+                        .whereArgs(1)
+                        .orderBy(MangaTable.COLUMN_TITLE)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedGetObject<Manga> getManga(String url, int sourceId) {
+        return db.get()
+                .object(Manga.class)
+                .withQuery(Query.builder()
+                        .table(MangaTable.TABLE)
+                        .where(MangaTable.COLUMN_URL + "=? AND " + MangaTable.COLUMN_SOURCE + "=?")
+                        .whereArgs(url, sourceId)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedGetObject<Manga> getManga(long id) {
+        return db.get()
+                .object(Manga.class)
+                .withQuery(Query.builder()
+                        .table(MangaTable.TABLE)
+                        .where(MangaTable.COLUMN_ID + "=?")
+                        .whereArgs(id)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedPutObject<Manga> insertManga(Manga manga) {
+        return db.put()
+                .object(manga)
+                .prepare();
+    }
+
+    public PreparedPutCollectionOfObjects<Manga> insertMangas(List<Manga> mangas) {
+        return db.put()
+                .objects(mangas)
+                .prepare();
+    }
+
+    public PreparedDeleteObject<Manga> deleteManga(Manga manga) {
+        return db.delete()
+                .object(manga)
+                .prepare();
+    }
+
+    public PreparedDeleteCollectionOfObjects<Manga> deleteMangas(List<Manga> mangas) {
+        return db.delete()
+                .objects(mangas)
+                .prepare();
+    }
+
+    public PreparedDeleteByQuery deleteMangasNotInLibrary() {
+        return db.delete()
+                .byQuery(DeleteQuery.builder()
+                        .table(MangaTable.TABLE)
+                        .where(MangaTable.COLUMN_FAVORITE + "=?")
+                        .whereArgs(0)
+                        .build())
+                .prepare();
+    }
+
+
+    // Chapters related queries
+
+    public PreparedGetListOfObjects<Chapter> getChapters(Manga manga) {
+        return db.get()
+                .listOfObjects(Chapter.class)
+                .withQuery(Query.builder()
+                        .table(ChapterTable.TABLE)
+                        .where(ChapterTable.COLUMN_MANGA_ID + "=?")
+                        .whereArgs(manga.id)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedGetListOfObjects<Chapter> getChapters(long manga_id, boolean sortAToZ, boolean onlyUnread) {
+        Query.CompleteBuilder query = Query.builder()
+                .table(ChapterTable.TABLE)
+
+                .orderBy(ChapterTable.COLUMN_CHAPTER_NUMBER + (sortAToZ ? " ASC" : " DESC"));
+
+        if (onlyUnread) {
+            query = query.where(ChapterTable.COLUMN_MANGA_ID + "=? AND " + ChapterTable.COLUMN_READ + "=?")
+                    .whereArgs(manga_id, 0);
+        } else {
+            query = query.where(ChapterTable.COLUMN_MANGA_ID + "=?")
+                    .whereArgs(manga_id);
+        }
+
+        return db.get()
+                .listOfObjects(Chapter.class)
+                .withQuery(query.build())
+                .prepare();
+    }
+
+    public PreparedGetObject<Chapter> getNextChapter(Chapter chapter) {
+        // Add a delta to the chapter number, because binary decimal representation
+        // can retrieve the same chapter again
+        double chapterNumber = chapter.chapter_number + 0.00001;
+
+        return db.get()
+                .object(Chapter.class)
+                .withQuery(Query.builder()
+                        .table(ChapterTable.TABLE)
+                        .where(ChapterTable.COLUMN_MANGA_ID + "=? AND " +
+                                ChapterTable.COLUMN_CHAPTER_NUMBER + ">? AND " +
+                                ChapterTable.COLUMN_CHAPTER_NUMBER + "<=?")
+                        .whereArgs(chapter.manga_id, chapterNumber, chapterNumber + 1)
+                        .orderBy(ChapterTable.COLUMN_CHAPTER_NUMBER)
+                        .limit(1)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedGetObject<Chapter> getPreviousChapter(Chapter chapter) {
+        // Add a delta to the chapter number, because binary decimal representation
+        // can retrieve the same chapter again
+        double chapterNumber = chapter.chapter_number - 0.00001;
+
+        return db.get()
+                .object(Chapter.class)
+                .withQuery(Query.builder()
+                        .table(ChapterTable.TABLE)
+                        .where(ChapterTable.COLUMN_MANGA_ID + "=? AND " +
+                                ChapterTable.COLUMN_CHAPTER_NUMBER + "<? AND " +
+                                ChapterTable.COLUMN_CHAPTER_NUMBER + ">=?")
+                        .whereArgs(chapter.manga_id, chapterNumber, chapterNumber - 1)
+                        .orderBy(ChapterTable.COLUMN_CHAPTER_NUMBER + " DESC")
+                        .limit(1)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedGetObject<Chapter> getNextUnreadChapter(Manga manga) {
+        return db.get()
+                .object(Chapter.class)
+                .withQuery(Query.builder()
+                        .table(ChapterTable.TABLE)
+                        .where(ChapterTable.COLUMN_MANGA_ID + "=? AND " +
+                                ChapterTable.COLUMN_READ + "=? AND " +
+                                ChapterTable.COLUMN_CHAPTER_NUMBER + ">=?")
+                        .whereArgs(manga.id, 0, 0)
+                        .orderBy(ChapterTable.COLUMN_CHAPTER_NUMBER)
+                        .limit(1)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedPutObject<Chapter> insertChapter(Chapter chapter) {
+        return db.put()
+                .object(chapter)
+                .prepare();
+    }
+
+    public PreparedPutCollectionOfObjects<Chapter> insertChapters(List<Chapter> chapters) {
+        return db.put()
+                .objects(chapters)
+                .prepare();
+    }
+
+    // Add new chapters or delete if the source deletes them
+    public Observable<Pair<Integer, Integer>> insertOrRemoveChapters(Manga manga, List<Chapter> sourceChapters) {
+        List<Chapter> dbChapters = getChapters(manga).executeAsBlocking();
+
+        Observable<List<Chapter>> newChapters = Observable.from(sourceChapters)
+                .filter(c -> !dbChapters.contains(c))
+                .doOnNext(c -> {
+                    c.manga_id = manga.id;
+                    ChapterRecognition.parseChapterNumber(c, manga);
+                })
+                .toList();
+
+        Observable<List<Chapter>> deletedChapters = Observable.from(dbChapters)
+                .filter(c -> !sourceChapters.contains(c))
+                .toList();
+
+        return Observable.zip(newChapters, deletedChapters, (toAdd, toDelete) -> {
+            int added = 0;
+            int deleted = 0;
+            db.internal().beginTransaction();
+            try {
+                if (!toAdd.isEmpty()) {
+                    // Set the date fetch for new items in reverse order to allow another sorting method.
+                    // Sources MUST return the chapters from most to less recent, which is common.
+                    long now = new Date().getTime();
+
+                    for (int i = toAdd.size() - 1; i >= 0; i--) {
+                        toAdd.get(i).date_fetch = now++;
+                    }
+                    added = insertChapters(toAdd).executeAsBlocking().numberOfInserts();
+                }
+
+                if (!toDelete.isEmpty()) {
+                    deleted = deleteChapters(toDelete).executeAsBlocking().results().size();
+                }
+
+                db.internal().setTransactionSuccessful();
+            } finally {
+                db.internal().endTransaction();
+            }
+            return Pair.create(added, deleted);
+        });
+    }
+
+    public PreparedDeleteObject<Chapter> deleteChapter(Chapter chapter) {
+        return db.delete()
+                .object(chapter)
+                .prepare();
+    }
+
+    public PreparedDeleteCollectionOfObjects<Chapter> deleteChapters(List<Chapter> chapters) {
+        return db.delete()
+                .objects(chapters)
+                .prepare();
+    }
+
+    // Manga sync related queries
+
+    public PreparedGetObject<MangaSync> getMangaSync(Manga manga, MangaSyncService sync) {
+        return db.get()
+                .object(MangaSync.class)
+                .withQuery(Query.builder()
+                        .table(MangaSyncTable.TABLE)
+                        .where(MangaSyncTable.COLUMN_MANGA_ID + "=? AND " +
+                                MangaSyncTable.COLUMN_SYNC_ID + "=?")
+                        .whereArgs(manga.id, sync.getId())
+                        .build())
+                .prepare();
+    }
+
+    public PreparedGetListOfObjects<MangaSync> getMangasSync(Manga manga) {
+        return db.get()
+                .listOfObjects(MangaSync.class)
+                .withQuery(Query.builder()
+                        .table(MangaSyncTable.TABLE)
+                        .where(MangaSyncTable.COLUMN_MANGA_ID + "=?")
+                        .whereArgs(manga.id)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedPutObject<MangaSync> insertMangaSync(MangaSync manga) {
+        return db.put()
+                .object(manga)
+                .prepare();
+    }
+
+    public PreparedDeleteObject<MangaSync> deleteMangaSync(MangaSync manga) {
+        return db.delete()
+                .object(manga)
+                .prepare();
+    }
+
+    // Categories related queries
+
+    public PreparedGetListOfObjects<Category> getCategories() {
+        return db.get()
+                .listOfObjects(Category.class)
+                .withQuery(Query.builder()
+                        .table(CategoryTable.TABLE)
+                        .orderBy(CategoryTable.COLUMN_ORDER)
+                        .build())
+                .prepare();
+    }
+
+    public PreparedPutObject<Category> insertCategory(Category category) {
+        return db.put()
+                .object(category)
+                .prepare();
+    }
+
+    public PreparedPutCollectionOfObjects<Category> insertCategories(List<Category> categories) {
+        return db.put()
+                .objects(categories)
+                .prepare();
+    }
+
+    public PreparedDeleteObject<Category> deleteCategory(Category category) {
+        return db.delete()
+                .object(category)
+                .prepare();
+    }
+
+    public PreparedDeleteCollectionOfObjects<Category> deleteCategories(List<Category> categories) {
+        return db.delete()
+                .objects(categories)
+                .prepare();
+    }
+
+    public PreparedPutObject<MangaCategory> insertMangaCategory(MangaCategory mangaCategory) {
+        return db.put()
+                .object(mangaCategory)
+                .prepare();
+    }
+
+    public PreparedPutCollectionOfObjects<MangaCategory> insertMangasCategories(List<MangaCategory> mangasCategories) {
+        return db.put()
+                .objects(mangasCategories)
+                .prepare();
+    }
+
+    public PreparedDeleteByQuery deleteOldMangasCategories(List<Manga> mangas) {
+        List<Long> mangaIds = Observable.from(mangas)
+                .map(manga -> manga.id)
+                .toList().toBlocking().single();
+
+        return db.delete()
+                .byQuery(DeleteQuery.builder()
+                        .table(MangaCategoryTable.TABLE)
+                        .where(MangaCategoryTable.COLUMN_MANGA_ID + " IN ("
+                                + Queries.placeholders(mangas.size()) + ")")
+                        .whereArgs(mangaIds.toArray())
+                        .build())
+                .prepare();
+    }
+
+    public void setMangaCategories(List<MangaCategory> mangasCategories, List<Manga> mangas) {
+        db.internal().beginTransaction();
+        try {
+            deleteOldMangasCategories(mangas).executeAsBlocking();
+            insertMangasCategories(mangasCategories).executeAsBlocking();
+            db.internal().setTransactionSuccessful();
+        } finally {
+            db.internal().endTransaction();
+        }
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/DbOpenHelper.java

@@ -0,0 +1,47 @@
+package eu.kanade.tachiyomi.data.database;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.support.annotation.NonNull;
+
+import eu.kanade.tachiyomi.data.database.tables.CategoryTable;
+import eu.kanade.tachiyomi.data.database.tables.MangaCategoryTable;
+import eu.kanade.tachiyomi.data.database.tables.MangaSyncTable;
+import eu.kanade.tachiyomi.data.database.tables.ChapterTable;
+import eu.kanade.tachiyomi.data.database.tables.MangaTable;
+
+public class DbOpenHelper extends SQLiteOpenHelper {
+
+    public static final String DATABASE_NAME = "tachiyomi.db";
+    public static final int DATABASE_VERSION = 1;
+
+    public DbOpenHelper(@NonNull Context context) {
+        super(context, DATABASE_NAME, null, DATABASE_VERSION);
+    }
+
+    @Override
+    public void onCreate(@NonNull SQLiteDatabase db) {
+        db.execSQL(MangaTable.getCreateTableQuery());
+        db.execSQL(ChapterTable.getCreateTableQuery());
+        db.execSQL(MangaSyncTable.getCreateTableQuery());
+        db.execSQL(CategoryTable.getCreateTableQuery());
+        db.execSQL(MangaCategoryTable.getCreateTableQuery());
+
+        // DB indexes
+        db.execSQL(MangaTable.getCreateUrlIndexQuery());
+        db.execSQL(MangaTable.getCreateFavoriteIndexQuery());
+        db.execSQL(ChapterTable.getCreateMangaIdIndexQuery());
+    }
+
+    @Override
+    public void onUpgrade(@NonNull SQLiteDatabase db, int oldVersion, int newVersion) {
+
+    }
+
+    @Override
+    public void onConfigure(@NonNull SQLiteDatabase db) {
+        db.setForeignKeyConstraintsEnabled(true);
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/models/Category.java

@@ -0,0 +1,38 @@
+package eu.kanade.tachiyomi.data.database.models;
+
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteColumn;
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteType;
+
+import java.io.Serializable;
+
+import eu.kanade.tachiyomi.data.database.tables.CategoryTable;
+
+@StorIOSQLiteType(table = CategoryTable.TABLE)
+public class Category implements Serializable {
+
+    @StorIOSQLiteColumn(name = CategoryTable.COLUMN_ID, key = true)
+    public Integer id;
+
+    @StorIOSQLiteColumn(name = CategoryTable.COLUMN_NAME)
+    public String name;
+
+    @StorIOSQLiteColumn(name = CategoryTable.COLUMN_ORDER)
+    public int order;
+
+    @StorIOSQLiteColumn(name = CategoryTable.COLUMN_FLAGS)
+    public int flags;
+
+    public Category() {}
+
+    public static Category create(String name) {
+        Category c = new Category();
+        c.name = name;
+        return c;
+    }
+
+    public static Category createDefault() {
+        Category c = create("Default");
+        c.id = 0;
+        return c;
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/models/Chapter.java

@@ -0,0 +1,71 @@
+package eu.kanade.tachiyomi.data.database.models;
+
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteColumn;
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteType;
+
+import java.io.Serializable;
+
+import eu.kanade.tachiyomi.data.database.tables.ChapterTable;
+import eu.kanade.tachiyomi.util.UrlUtil;
+
+@StorIOSQLiteType(table = ChapterTable.TABLE)
+public class Chapter implements Serializable {
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_ID, key = true)
+    public Long id;
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_MANGA_ID)
+    public Long manga_id;
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_URL)
+    public String url;
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_NAME)
+    public String name;
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_READ)
+    public boolean read;
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_LAST_PAGE_READ)
+    public int last_page_read;
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_DATE_FETCH)
+    public long date_fetch;
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_DATE_UPLOAD)
+    public long date_upload;
+
+    @StorIOSQLiteColumn(name = ChapterTable.COLUMN_CHAPTER_NUMBER)
+    public float chapter_number;
+
+    public int status;
+
+    public Chapter() {}
+
+    public void setUrl(String url) {
+        this.url = UrlUtil.getPath(url);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Chapter chapter = (Chapter) o;
+
+        return url.equals(chapter.url);
+
+    }
+
+    @Override
+    public int hashCode() {
+        return url.hashCode();
+    }
+
+    public static Chapter create() {
+        Chapter chapter = new Chapter();
+        chapter.chapter_number = -1;
+        return chapter;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/models/Manga.java

@@ -0,0 +1,138 @@
+package eu.kanade.tachiyomi.data.database.models;
+
+import android.content.Context;
+
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteColumn;
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteType;
+
+import java.io.Serializable;
+
+import eu.kanade.tachiyomi.R;
+import eu.kanade.tachiyomi.data.database.tables.MangaTable;
+import eu.kanade.tachiyomi.util.UrlUtil;
+
+@StorIOSQLiteType(table = MangaTable.TABLE)
+public class Manga implements Serializable {
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_ID, key = true)
+    public Long id;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_SOURCE)
+    public int source;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_URL)
+    public String url;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_ARTIST)
+    public String artist;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_AUTHOR)
+    public String author;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_DESCRIPTION)
+    public String description;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_GENRE)
+    public String genre;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_TITLE)
+    public String title;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_STATUS)
+    public int status;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_THUMBNAIL_URL)
+    public String thumbnail_url;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_FAVORITE)
+    public boolean favorite;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_LAST_UPDATE)
+    public long last_update;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_INITIALIZED)
+    public boolean initialized;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_VIEWER)
+    public int viewer;
+
+    @StorIOSQLiteColumn(name = MangaTable.COLUMN_CHAPTER_FLAGS)
+    public int chapter_flags;
+
+    public int unread;
+
+    public int category;
+
+    public static final int UNKNOWN = 0;
+    public static final int ONGOING = 1;
+    public static final int COMPLETED = 2;
+    public static final int LICENSED = 3;
+
+    public Manga() {}
+
+    public static Manga create(String pathUrl) {
+        Manga m = new Manga();
+        m.url = pathUrl;
+        return m;
+    }
+
+    public void setUrl(String url) {
+        this.url = UrlUtil.getPath(url);
+    }
+
+    public void copyFrom(Manga other) {
+        if (other.title != null)
+            title = other.title;
+
+        if (other.author != null)
+            author = other.author;
+
+        if (other.artist != null)
+            artist = other.artist;
+
+        if (other.url != null)
+            url = other.url;
+
+        if (other.description != null)
+            description = other.description;
+
+        if (other.genre != null)
+            genre = other.genre;
+
+        if (other.thumbnail_url != null)
+            thumbnail_url = other.thumbnail_url;
+
+        status = other.status;
+
+        initialized = true;
+    }
+
+    public String getStatus(Context context) {
+        switch (status) {
+            case ONGOING:
+                return context.getString(R.string.ongoing);
+            case COMPLETED:
+                return context.getString(R.string.completed);
+            case LICENSED:
+                return context.getString(R.string.licensed);
+            default:
+                return context.getString(R.string.unknown);
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Manga manga = (Manga) o;
+
+        return url.equals(manga.url);
+
+    }
+
+    @Override
+    public int hashCode() {
+        return url.hashCode();
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/models/MangaCategory.java

@@ -0,0 +1,29 @@
+package eu.kanade.tachiyomi.data.database.models;
+
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteColumn;
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteType;
+
+import eu.kanade.tachiyomi.data.database.tables.MangaCategoryTable;
+
+@StorIOSQLiteType(table = MangaCategoryTable.TABLE)
+public class MangaCategory {
+
+    @StorIOSQLiteColumn(name = MangaCategoryTable.COLUMN_ID, key = true)
+    public Long id;
+
+    @StorIOSQLiteColumn(name = MangaCategoryTable.COLUMN_MANGA_ID)
+    public long manga_id;
+
+    @StorIOSQLiteColumn(name = MangaCategoryTable.COLUMN_CATEGORY_ID)
+    public int category_id;
+
+    public MangaCategory() {}
+
+    public static MangaCategory create(Manga manga, Category category) {
+        MangaCategory mc = new MangaCategory();
+        mc.manga_id = manga.id;
+        mc.category_id = category.id;
+        return mc;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/models/MangaSync.java

@@ -0,0 +1,55 @@
+package eu.kanade.tachiyomi.data.database.models;
+
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteColumn;
+import com.pushtorefresh.storio.sqlite.annotations.StorIOSQLiteType;
+
+import java.io.Serializable;
+
+import eu.kanade.tachiyomi.data.mangasync.base.MangaSyncService;
+import eu.kanade.tachiyomi.data.database.tables.MangaSyncTable;
+
+@StorIOSQLiteType(table = MangaSyncTable.TABLE)
+public class MangaSync implements Serializable {
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_ID, key = true)
+    public Long id;
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_MANGA_ID)
+    public long manga_id;
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_SYNC_ID)
+    public int sync_id;
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_REMOTE_ID)
+    public int remote_id;
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_TITLE)
+    public String title;
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_LAST_CHAPTER_READ)
+    public int last_chapter_read;
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_TOTAL_CHAPTERS)
+    public int total_chapters;
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_SCORE)
+    public float score;
+
+    @StorIOSQLiteColumn(name = MangaSyncTable.COLUMN_STATUS)
+    public int status;
+
+    public boolean update;
+
+    public static MangaSync create(MangaSyncService service) {
+        MangaSync mangasync = new MangaSync();
+        mangasync.sync_id = service.getId();
+        return mangasync;
+    }
+
+    public void copyPersonalFrom(MangaSync other) {
+        last_chapter_read = other.last_chapter_read;
+        score = other.score;
+        status = other.status;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/LibraryMangaGetResolver.java

@@ -0,0 +1,61 @@
+package eu.kanade.tachiyomi.data.database.resolvers;
+
+import android.database.Cursor;
+import android.support.annotation.NonNull;
+
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.database.models.MangaStorIOSQLiteGetResolver;
+import eu.kanade.tachiyomi.data.database.tables.ChapterTable;
+import eu.kanade.tachiyomi.data.database.tables.MangaCategoryTable;
+import eu.kanade.tachiyomi.data.database.tables.MangaTable;
+
+public class LibraryMangaGetResolver extends MangaStorIOSQLiteGetResolver {
+
+    public static final LibraryMangaGetResolver INSTANCE = new LibraryMangaGetResolver();
+
+    public static final String QUERY = String.format(
+            "SELECT M.*, COALESCE(MC.%10$s, 0) AS %12$s " +
+            "FROM (" +
+                "SELECT %1$s.*, COALESCE(C.unread, 0) AS %6$s " +
+                "FROM %1$s " +
+                "LEFT JOIN (" +
+                    "SELECT %5$s, COUNT(*) AS unread " +
+                    "FROM %2$s " +
+                    "WHERE %7$s = 0 " +
+                    "GROUP BY %5$s" +
+                ") AS C " +
+                "ON %4$s = C.%5$s " +
+                "WHERE %8$s = 1 " +
+                "GROUP BY %4$s " +
+                "ORDER BY %9$s" +
+            ") AS M " +
+            "LEFT JOIN (SELECT * FROM %3$s) AS MC ON MC.%11$s = M.%4$s",
+            MangaTable.TABLE,
+            ChapterTable.TABLE,
+            MangaCategoryTable.TABLE,
+            MangaTable.COLUMN_ID,
+            ChapterTable.COLUMN_MANGA_ID,
+            MangaTable.COLUMN_UNREAD,
+            ChapterTable.COLUMN_READ,
+            MangaTable.COLUMN_FAVORITE,
+            MangaTable.COLUMN_TITLE,
+            MangaCategoryTable.COLUMN_CATEGORY_ID,
+            MangaCategoryTable.COLUMN_MANGA_ID,
+            MangaTable.COLUMN_CATEGORY
+    );
+
+    @Override
+    @NonNull
+    public Manga mapFromCursor(@NonNull Cursor cursor) {
+        Manga manga = super.mapFromCursor(cursor);
+
+        int unreadColumn = cursor.getColumnIndex(MangaTable.COLUMN_UNREAD);
+        manga.unread = cursor.getInt(unreadColumn);
+
+        int categoryColumn = cursor.getColumnIndex(MangaTable.COLUMN_CATEGORY);
+        manga.category = cursor.getInt(categoryColumn);
+
+        return manga;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/resolvers/MangaWithUnreadGetResolver.java

@@ -0,0 +1,23 @@
+package eu.kanade.tachiyomi.data.database.resolvers;
+
+import android.database.Cursor;
+import android.support.annotation.NonNull;
+
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.database.models.MangaStorIOSQLiteGetResolver;
+import eu.kanade.tachiyomi.data.database.tables.MangaTable;
+
+public class MangaWithUnreadGetResolver extends MangaStorIOSQLiteGetResolver {
+
+    public static final MangaWithUnreadGetResolver INSTANCE = new MangaWithUnreadGetResolver();
+
+    @Override
+    @NonNull
+    public Manga mapFromCursor(@NonNull Cursor cursor) {
+        Manga manga = super.mapFromCursor(cursor);
+        int unreadColumn = cursor.getColumnIndex(MangaTable.COLUMN_UNREAD);
+        manga.unread = cursor.getInt(unreadColumn);
+        return manga;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/CategoryTable.java

@@ -0,0 +1,39 @@
+package eu.kanade.tachiyomi.data.database.tables;
+
+import android.support.annotation.NonNull;
+
+public class CategoryTable {
+
+    @NonNull
+    public static final String TABLE = "categories";
+
+    @NonNull
+    public static final String COLUMN_ID = "_id";
+
+    @NonNull
+    public static final String COLUMN_NAME = "name";
+
+    @NonNull
+    public static final String COLUMN_ORDER = "sort";
+
+    @NonNull
+    public static final String COLUMN_FLAGS = "flags";
+
+    // This is just class with Meta Data, we don't need instances
+    private CategoryTable() {
+        throw new IllegalStateException("No instances please");
+    }
+
+    // Better than static final field -> allows VM to unload useless String
+    // Because you need this string only once per application life on the device
+    @NonNull
+    public static String getCreateTableQuery() {
+        return "CREATE TABLE " + TABLE + "("
+                + COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY, "
+                + COLUMN_NAME + " TEXT NOT NULL, "
+                + COLUMN_ORDER + " INTEGER NOT NULL, "
+                + COLUMN_FLAGS + " INTEGER NOT NULL"
+                + ");";
+
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/ChapterTable.java

@@ -0,0 +1,59 @@
+package eu.kanade.tachiyomi.data.database.tables;
+
+import android.support.annotation.NonNull;
+
+public class ChapterTable {
+
+    @NonNull
+    public static final String TABLE = "chapters";
+
+	@NonNull
+	public static final String COLUMN_ID = "_id";
+
+	@NonNull
+	public static final String COLUMN_MANGA_ID = "manga_id";
+
+	@NonNull
+	public static final String COLUMN_URL = "url";
+
+	@NonNull
+	public static final String COLUMN_NAME = "name";
+
+	@NonNull
+	public static final String COLUMN_READ = "read";
+
+	@NonNull
+	public static final String COLUMN_DATE_FETCH = "date_fetch";
+
+	@NonNull
+	public static final String COLUMN_DATE_UPLOAD = "date_upload";
+
+	@NonNull
+	public static final String COLUMN_LAST_PAGE_READ = "last_page_read";
+
+	@NonNull
+	public static final String COLUMN_CHAPTER_NUMBER = "chapter_number";
+
+	@NonNull
+	public static String getCreateTableQuery() {
+		return "CREATE TABLE " + TABLE + "("
+				+ COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY, "
+				+ COLUMN_MANGA_ID + " INTEGER NOT NULL, "
+				+ COLUMN_URL + " TEXT NOT NULL, "
+				+ COLUMN_NAME + " TEXT NOT NULL, "
+				+ COLUMN_READ + " BOOLEAN NOT NULL, "
+				+ COLUMN_LAST_PAGE_READ + " INT NOT NULL, "
+				+ COLUMN_CHAPTER_NUMBER + " FLOAT NOT NULL, "
+				+ COLUMN_DATE_FETCH + " LONG NOT NULL, "
+				+ COLUMN_DATE_UPLOAD + " LONG NOT NULL, "
+				+ "FOREIGN KEY(" + COLUMN_MANGA_ID + ") REFERENCES " + MangaTable.TABLE + "(" + MangaTable.COLUMN_ID + ") "
+				+ "ON DELETE CASCADE"
+				+ ");";
+	}
+
+	public static String getCreateMangaIdIndexQuery() {
+		return "CREATE INDEX " + TABLE + "_" + COLUMN_MANGA_ID + "_index ON " + TABLE + "(" + COLUMN_MANGA_ID + ");";
+
+	}
+	
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/MangaCategoryTable.java

@@ -0,0 +1,40 @@
+package eu.kanade.tachiyomi.data.database.tables;
+
+import android.support.annotation.NonNull;
+
+public class MangaCategoryTable {
+
+    @NonNull
+    public static final String TABLE = "mangas_categories";
+
+    @NonNull
+    public static final String COLUMN_ID = "_id";
+
+    @NonNull
+    public static final String COLUMN_MANGA_ID = "manga_id";
+
+    @NonNull
+    public static final String COLUMN_CATEGORY_ID = "category_id";
+
+    // This is just class with Meta Data, we don't need instances
+    private MangaCategoryTable() {
+        throw new IllegalStateException("No instances please");
+    }
+
+    // Better than static final field -> allows VM to unload useless String
+    // Because you need this string only once per application life on the device
+    @NonNull
+    public static String getCreateTableQuery() {
+        return "CREATE TABLE " + TABLE + "("
+                + COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY, "
+                + COLUMN_MANGA_ID + " INTEGER NOT NULL, "
+                + COLUMN_CATEGORY_ID + " INTEGER NOT NULL, "
+                + "FOREIGN KEY(" + COLUMN_CATEGORY_ID + ") REFERENCES " + CategoryTable.TABLE + "(" + CategoryTable.COLUMN_ID + ") "
+                + "ON DELETE CASCADE, "
+                + "FOREIGN KEY(" + COLUMN_MANGA_ID + ") REFERENCES " + MangaTable.TABLE + "(" + MangaTable.COLUMN_ID + ") "
+                + "ON DELETE CASCADE"
+                + ");";
+
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/MangaSyncTable.java

@@ -0,0 +1,45 @@
+package eu.kanade.tachiyomi.data.database.tables;
+
+import android.support.annotation.NonNull;
+
+public class MangaSyncTable {
+
+    public static final String TABLE = "manga_sync";
+
+    public static final String COLUMN_ID = "_id";
+
+    public static final String COLUMN_MANGA_ID = "manga_id";
+
+    public static final String COLUMN_SYNC_ID = "sync_id";
+
+    public static final String COLUMN_REMOTE_ID = "remote_id";
+
+    public static final String COLUMN_TITLE = "title";
+
+    public static final String COLUMN_LAST_CHAPTER_READ = "last_chapter_read";
+
+    public static final String COLUMN_STATUS = "status";
+
+    public static final String COLUMN_SCORE = "score";
+
+    public static final String COLUMN_TOTAL_CHAPTERS = "total_chapters";
+
+    @NonNull
+    public static String getCreateTableQuery() {
+        return "CREATE TABLE " + TABLE + "("
+                + COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY, "
+                + COLUMN_MANGA_ID + " INTEGER NOT NULL, "
+                + COLUMN_SYNC_ID + " INTEGER NOT NULL, "
+                + COLUMN_REMOTE_ID + " INTEGER NOT NULL, "
+                + COLUMN_TITLE + " TEXT NOT NULL, "
+                + COLUMN_LAST_CHAPTER_READ + " INTEGER NOT NULL, "
+                + COLUMN_TOTAL_CHAPTERS + " INTEGER NOT NULL, "
+                + COLUMN_STATUS + " INTEGER NOT NULL, "
+                + COLUMN_SCORE + " FLOAT NOT NULL, "
+                + "UNIQUE (" + COLUMN_MANGA_ID + ", " + COLUMN_SYNC_ID + ") ON CONFLICT REPLACE, "
+                + "FOREIGN KEY(" + COLUMN_MANGA_ID + ") REFERENCES " + MangaTable.TABLE + "(" + MangaTable.COLUMN_ID + ") "
+                + "ON DELETE CASCADE"
+                + ");";
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/database/tables/MangaTable.java

@@ -0,0 +1,98 @@
+package eu.kanade.tachiyomi.data.database.tables;
+
+import android.support.annotation.NonNull;
+
+public class MangaTable {
+
+    @NonNull
+    public static final String TABLE = "mangas";
+
+    @NonNull
+    public static final String COLUMN_ID = "_id";
+
+    @NonNull
+    public static final String COLUMN_SOURCE = "source";
+
+    @NonNull
+    public static final String COLUMN_URL = "url";
+
+    @NonNull
+    public static final String COLUMN_ARTIST = "artist";
+
+    @NonNull
+    public static final String COLUMN_AUTHOR = "author" ;
+
+    @NonNull
+    public static final String COLUMN_DESCRIPTION = "description";
+
+    @NonNull
+    public static final String COLUMN_GENRE = "genre";
+
+    @NonNull
+    public static final String COLUMN_TITLE = "title";
+
+    @NonNull
+    public static final String COLUMN_STATUS = "status";
+
+    @NonNull
+    public static final String COLUMN_THUMBNAIL_URL = "thumbnail_url";
+
+    @NonNull
+    public static final String COLUMN_FAVORITE = "favorite";
+
+    @NonNull
+    public static final String COLUMN_LAST_UPDATE = "last_update";
+
+    @NonNull
+    public static final String COLUMN_INITIALIZED = "initialized";
+
+    @NonNull
+    public static final String COLUMN_VIEWER = "viewer";
+
+    @NonNull
+    public static final String COLUMN_CHAPTER_FLAGS = "chapter_flags";
+
+    @NonNull
+    public static final String COLUMN_UNREAD = "unread";
+
+    @NonNull
+    public static final String COLUMN_CATEGORY = "category";
+
+    // This is just class with Meta Data, we don't need instances
+    private MangaTable() {
+        throw new IllegalStateException("No instances please");
+    }
+
+    // Better than static final field -> allows VM to unload useless String
+    // Because you need this string only once per application life on the device
+    @NonNull
+    public static String getCreateTableQuery() {
+        return "CREATE TABLE " + TABLE + "("
+                + COLUMN_ID + " INTEGER NOT NULL PRIMARY KEY, "
+                + COLUMN_SOURCE + " INTEGER NOT NULL, "
+                + COLUMN_URL + " TEXT NOT NULL, "
+                + COLUMN_ARTIST + " TEXT, "
+                + COLUMN_AUTHOR + " TEXT, "
+                + COLUMN_DESCRIPTION + " TEXT, "
+                + COLUMN_GENRE + " TEXT, "
+                + COLUMN_TITLE + " TEXT NOT NULL, "
+                + COLUMN_STATUS + " INTEGER NOT NULL, "
+                + COLUMN_THUMBNAIL_URL + " TEXT, "
+                + COLUMN_FAVORITE + " INTEGER NOT NULL, "
+                + COLUMN_LAST_UPDATE + " LONG, "
+                + COLUMN_INITIALIZED + " BOOLEAN NOT NULL, "
+                + COLUMN_VIEWER + " INTEGER NOT NULL, "
+                + COLUMN_CHAPTER_FLAGS + " INTEGER NOT NULL"
+                + ");";
+
+    }
+
+    public static String getCreateUrlIndexQuery() {
+        return "CREATE INDEX " + TABLE + "_" + COLUMN_URL + "_index ON " + TABLE + "(" + COLUMN_URL + ");";
+    }
+
+    public static String getCreateFavoriteIndexQuery() {
+        return "CREATE INDEX " + TABLE + "_" + COLUMN_FAVORITE + "_index ON " + TABLE + "(" + COLUMN_FAVORITE + ");";
+
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadManager.java

@@ -0,0 +1,422 @@
+package eu.kanade.tachiyomi.data.download;
+
+import android.content.Context;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.download.model.Download;
+import eu.kanade.tachiyomi.data.download.model.DownloadQueue;
+import eu.kanade.tachiyomi.data.preference.PreferencesHelper;
+import eu.kanade.tachiyomi.data.source.SourceManager;
+import eu.kanade.tachiyomi.data.source.base.Source;
+import eu.kanade.tachiyomi.data.source.model.Page;
+import eu.kanade.tachiyomi.event.DownloadChaptersEvent;
+import eu.kanade.tachiyomi.util.DiskUtils;
+import eu.kanade.tachiyomi.util.DynamicConcurrentMergeOperator;
+import rx.Observable;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.schedulers.Schedulers;
+import rx.subjects.BehaviorSubject;
+import rx.subjects.PublishSubject;
+import timber.log.Timber;
+
+public class DownloadManager {
+
+    private Context context;
+    private SourceManager sourceManager;
+    private PreferencesHelper preferences;
+    private Gson gson;
+
+    private PublishSubject<Download> downloadsQueueSubject;
+    private BehaviorSubject<Integer> threadsNumber;
+    private BehaviorSubject<Boolean> runningSubject;
+    private Subscription downloadsSubscription;
+    private Subscription threadsNumberSubscription;
+
+    private DownloadQueue queue;
+    private volatile boolean isRunning;
+
+    public static final String PAGE_LIST_FILE = "index.json";
+
+    public DownloadManager(Context context, SourceManager sourceManager, PreferencesHelper preferences) {
+        this.context = context;
+        this.sourceManager = sourceManager;
+        this.preferences = preferences;
+
+        gson = new Gson();
+        queue = new DownloadQueue();
+
+        downloadsQueueSubject = PublishSubject.create();
+        threadsNumber = BehaviorSubject.create();
+        runningSubject = BehaviorSubject.create();
+    }
+
+    private void initializeSubscriptions() {
+        if (downloadsSubscription != null && !downloadsSubscription.isUnsubscribed())
+            downloadsSubscription.unsubscribe();
+
+        if (threadsNumberSubscription != null && !threadsNumberSubscription.isUnsubscribed())
+            threadsNumberSubscription.unsubscribe();
+
+        threadsNumberSubscription = preferences.downloadThreads().asObservable()
+                .subscribe(threadsNumber::onNext);
+
+        downloadsSubscription = downloadsQueueSubject
+                .lift(new DynamicConcurrentMergeOperator<>(this::downloadChapter, threadsNumber))
+                .onBackpressureBuffer()
+                .observeOn(AndroidSchedulers.mainThread())
+                .map(download -> areAllDownloadsFinished())
+                .subscribe(finished -> {
+                    if (finished) {
+                        DownloadService.stop(context);
+                    }
+                }, e -> Timber.e(e.getCause(), e.getMessage()));
+
+        if (!isRunning) {
+            isRunning = true;
+            runningSubject.onNext(true);
+        }
+    }
+
+    public void destroySubscriptions() {
+        if (isRunning) {
+            isRunning = false;
+            runningSubject.onNext(false);
+        }
+
+        if (downloadsSubscription != null && !downloadsSubscription.isUnsubscribed()) {
+            downloadsSubscription.unsubscribe();
+            downloadsSubscription = null;
+        }
+
+        if (threadsNumberSubscription != null && !threadsNumberSubscription.isUnsubscribed()) {
+            threadsNumberSubscription.unsubscribe();
+            threadsNumberSubscription = null;
+        }
+    }
+
+    // Create a download object for every chapter in the event and add them to the downloads queue
+    public void onDownloadChaptersEvent(DownloadChaptersEvent event) {
+        final Manga manga = event.getManga();
+        final Source source = sourceManager.get(manga.source);
+
+        for (Chapter chapter : event.getChapters()) {
+            Download download = new Download(source, manga, chapter);
+
+            if (!prepareDownload(download)) {
+                queue.add(download);
+                if (isRunning) downloadsQueueSubject.onNext(download);
+            }
+        }
+    }
+
+    // Public method to check if a chapter is downloaded
+    public boolean isChapterDownloaded(Source source, Manga manga, Chapter chapter) {
+        File directory = getAbsoluteChapterDirectory(source, manga, chapter);
+        if (!directory.exists())
+            return false;
+
+        List<Page> pages = getSavedPageList(source, manga, chapter);
+        return isChapterDownloaded(directory, pages);
+    }
+
+    // Prepare the download. Returns true if the chapter is already downloaded
+    private boolean prepareDownload(Download download) {
+        // If the chapter is already queued, don't add it again
+        for (Download queuedDownload : queue) {
+            if (download.chapter.id.equals(queuedDownload.chapter.id))
+                return true;
+        }
+
+        // Add the directory to the download object for future access
+        download.directory = getAbsoluteChapterDirectory(download);
+
+        // If the directory doesn't exist, the chapter isn't downloaded.
+        if (!download.directory.exists()) {
+            return false;
+        }
+
+        // If the page list doesn't exist, the chapter isn't downloaded
+        List<Page> savedPages = getSavedPageList(download);
+        if (savedPages == null)
+            return false;
+
+        // Add the page list to the download object for future access
+        download.pages = savedPages;
+
+        // If the number of files matches the number of pages, the chapter is downloaded.
+        // We have the index file, so we check one file more
+        return isChapterDownloaded(download.directory, download.pages);
+    }
+
+    // Check that all the images are downloaded
+    private boolean isChapterDownloaded(File directory, List<Page> pages) {
+        return pages != null && !pages.isEmpty() && pages.size() + 1 == directory.listFiles().length;
+    }
+
+    // Download the entire chapter
+    private Observable<Download> downloadChapter(Download download) {
+        try {
+            DiskUtils.createDirectory(download.directory);
+        } catch (IOException e) {
+            return Observable.error(e);
+        }
+
+        Observable<List<Page>> pageListObservable = download.pages == null ?
+                // Pull page list from network and add them to download object
+                download.source
+                        .pullPageListFromNetwork(download.chapter.url)
+                        .doOnNext(pages -> download.pages = pages)
+                        .doOnNext(pages -> savePageList(download)) :
+                // Or if the page list already exists, start from the file
+                Observable.just(download.pages);
+
+        return pageListObservable
+                .subscribeOn(Schedulers.io())
+                .doOnNext(pages -> {
+                    download.downloadedImages = 0;
+                    download.setStatus(Download.DOWNLOADING);
+                })
+                // Get all the URLs to the source images, fetch pages if necessary
+                .flatMap(download.source::getAllImageUrlsFromPageList)
+                // Start downloading images, consider we can have downloaded images already
+                .concatMap(page -> getOrDownloadImage(page, download))
+                // Do after download completes
+                .doOnCompleted(() -> onDownloadCompleted(download))
+                .toList()
+                .map(pages -> download)
+                // If the page list threw, it will resume here
+                .onErrorResumeNext(error -> {
+                    download.setStatus(Download.ERROR);
+                    return Observable.just(download);
+                });
+    }
+
+    // Get the image from the filesystem if it exists or download from network
+    private Observable<Page> getOrDownloadImage(final Page page, Download download) {
+        // If the image URL is empty, do nothing
+        if (page.getImageUrl() == null)
+            return Observable.just(page);
+
+        String filename = getImageFilename(page);
+        File imagePath = new File(download.directory, filename);
+
+        // If the image is already downloaded, do nothing. Otherwise download from network
+        Observable<Page> pageObservable = isImageDownloaded(imagePath) ?
+                Observable.just(page) :
+                downloadImage(page, download.source, download.directory, filename);
+
+        return pageObservable
+                // When the image is ready, set image path, progress (just in case) and status
+                .doOnNext(p -> {
+                    page.setImagePath(imagePath.getAbsolutePath());
+                    page.setProgress(100);
+                    download.downloadedImages++;
+                    page.setStatus(Page.READY);
+                })
+                // Mark this page as error and allow to download the remaining
+                .onErrorResumeNext(e -> {
+                    page.setProgress(0);
+                    page.setStatus(Page.ERROR);
+                    return Observable.just(page);
+                });
+    }
+
+    // Save image on disk
+    private Observable<Page> downloadImage(Page page, Source source, File directory, String filename) {
+        page.setStatus(Page.DOWNLOAD_IMAGE);
+        return source.getImageProgressResponse(page)
+                .flatMap(resp -> {
+                    try {
+                        DiskUtils.saveBufferedSourceToDirectory(resp.body().source(), directory, filename);
+                    } catch (Exception e) {
+                        Timber.e(e.getCause(), e.getMessage());
+                        return Observable.error(e);
+                    }
+                    return Observable.just(page);
+                })
+                .retry(2);
+    }
+
+    // Public method to get the image from the filesystem. It does NOT provide any way to download the image
+    public Observable<Page> getDownloadedImage(final Page page, File chapterDir) {
+        if (page.getImageUrl() == null) {
+            page.setStatus(Page.ERROR);
+            return Observable.just(page);
+        }
+
+        File imagePath = new File(chapterDir, getImageFilename(page));
+
+        // When the image is ready, set image path, progress (just in case) and status
+        if (isImageDownloaded(imagePath)) {
+            page.setImagePath(imagePath.getAbsolutePath());
+            page.setProgress(100);
+            page.setStatus(Page.READY);
+        } else {
+            page.setStatus(Page.ERROR);
+        }
+        return Observable.just(page);
+    }
+
+    // Get the filename for an image given the page
+    private String getImageFilename(Page page) {
+        String url = page.getImageUrl();
+        return url.substring(url.lastIndexOf("/") + 1, url.length());
+    }
+
+    private boolean isImageDownloaded(File imagePath) {
+        return imagePath.exists();
+    }
+
+    // Called when a download finishes. This doesn't mean the download was successful, so we check it
+    private void onDownloadCompleted(final Download download) {
+        checkDownloadIsSuccessful(download);
+        savePageList(download);
+    }
+
+    private void checkDownloadIsSuccessful(final Download download) {
+        int actualProgress = 0;
+        int status = Download.DOWNLOADED;
+        // If any page has an error, the download result will be error
+        for (Page page : download.pages) {
+            actualProgress += page.getProgress();
+            if (page.getStatus() != Page.READY) status = Download.ERROR;
+        }
+        // Ensure that the chapter folder has all the images
+        if (!isChapterDownloaded(download.directory, download.pages)) {
+            status = Download.ERROR;
+        }
+        download.totalProgress = actualProgress;
+        download.setStatus(status);
+        // Delete successful downloads from queue after notifying
+        if (status == Download.DOWNLOADED) {
+            queue.remove(download);
+        }
+    }
+
+    // Return the page list from the chapter's directory if it exists, null otherwise
+    public List<Page> getSavedPageList(Source source, Manga manga, Chapter chapter) {
+        List<Page> pages = null;
+        File chapterDir = getAbsoluteChapterDirectory(source, manga, chapter);
+        File pagesFile = new File(chapterDir, PAGE_LIST_FILE);
+
+        JsonReader reader = null;
+        try {
+            if (pagesFile.exists()) {
+                reader = new JsonReader(new FileReader(pagesFile.getAbsolutePath()));
+                Type collectionType = new TypeToken<List<Page>>() {}.getType();
+                pages = gson.fromJson(reader, collectionType);
+            }
+        } catch (FileNotFoundException e) {
+            Timber.e(e.getCause(), e.getMessage());
+        } finally {
+            if (reader != null) try { reader.close(); } catch (IOException e) { /* Do nothing */ }
+        }
+        return pages;
+    }
+
+    // Shortcut for the method above
+    private List<Page> getSavedPageList(Download download) {
+        return getSavedPageList(download.source, download.manga, download.chapter);
+    }
+
+    // Save the page list to the chapter's directory
+    public void savePageList(Source source, Manga manga, Chapter chapter, List<Page> pages) {
+        File chapterDir = getAbsoluteChapterDirectory(source, manga, chapter);
+        File pagesFile = new File(chapterDir, PAGE_LIST_FILE);
+
+        FileOutputStream out = null;
+        try {
+            out = new FileOutputStream(pagesFile);
+            out.write(gson.toJson(pages).getBytes());
+            out.flush();
+        } catch (IOException e) {
+            Timber.e(e.getCause(), e.getMessage());
+        } finally {
+            if (out != null) try { out.close(); } catch (IOException e) { /* Do nothing */ }
+        }
+    }
+
+    // Shortcut for the method above
+    private void savePageList(Download download) {
+        savePageList(download.source, download.manga, download.chapter, download.pages);
+    }
+
+    // Get the absolute path to the chapter directory
+    public File getAbsoluteChapterDirectory(Source source, Manga manga, Chapter chapter) {
+        String chapterRelativePath = source.getName() +
+                File.separator +
+                manga.title.replaceAll("[^\\sa-zA-Z0-9.-]", "_") +
+                File.separator +
+                chapter.name.replaceAll("[^\\sa-zA-Z0-9.-]", "_") + " (" + chapter.id + ")";
+
+        return new File(preferences.getDownloadsDirectory(), chapterRelativePath);
+    }
+
+    // Shortcut for the method above
+    private File getAbsoluteChapterDirectory(Download download) {
+        return getAbsoluteChapterDirectory(download.source, download.manga, download.chapter);
+    }
+
+    public void deleteChapter(Source source, Manga manga, Chapter chapter) {
+        File path = getAbsoluteChapterDirectory(source, manga, chapter);
+        DiskUtils.deleteFiles(path);
+    }
+
+    public DownloadQueue getQueue() {
+        return queue;
+    }
+
+    public boolean areAllDownloadsFinished() {
+        for (Download download : queue) {
+            if (download.getStatus() <= Download.DOWNLOADING)
+                return false;
+        }
+        return true;
+    }
+
+    public boolean startDownloads() {
+        if (queue.isEmpty())
+            return false;
+
+        boolean hasPendingDownloads = false;
+        if (downloadsSubscription == null)
+            initializeSubscriptions();
+
+        for (Download download : queue) {
+            if (download.getStatus() != Download.DOWNLOADED) {
+                if (download.getStatus() != Download.QUEUE) download.setStatus(Download.QUEUE);
+                if (!hasPendingDownloads) hasPendingDownloads = true;
+                downloadsQueueSubject.onNext(download);
+            }
+        }
+        return hasPendingDownloads;
+    }
+
+    public void stopDownloads() {
+        destroySubscriptions();
+        for (Download download : queue) {
+            if (download.getStatus() == Download.DOWNLOADING) {
+                download.setStatus(Download.ERROR);
+            }
+        }
+    }
+
+    public BehaviorSubject<Boolean> getRunningSubject() {
+        return runningSubject;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadService.java

@@ -0,0 +1,149 @@
+package eu.kanade.tachiyomi.data.download;
+
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.PowerManager;
+
+import com.github.pwittchen.reactivenetwork.library.ReactiveNetwork;
+
+import javax.inject.Inject;
+
+import de.greenrobot.event.EventBus;
+import eu.kanade.tachiyomi.App;
+import eu.kanade.tachiyomi.R;
+import eu.kanade.tachiyomi.data.preference.PreferencesHelper;
+import eu.kanade.tachiyomi.event.DownloadChaptersEvent;
+import eu.kanade.tachiyomi.util.EventBusHook;
+import eu.kanade.tachiyomi.util.ToastUtil;
+import rx.Subscription;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.schedulers.Schedulers;
+
+public class DownloadService extends Service {
+
+    @Inject DownloadManager downloadManager;
+    @Inject PreferencesHelper preferences;
+
+    private PowerManager.WakeLock wakeLock;
+    private Subscription networkChangeSubscription;
+    private Subscription queueRunningSubscription;
+    private boolean isRunning;
+
+    public static void start(Context context) {
+        context.startService(new Intent(context, DownloadService.class));
+    }
+
+    public static void stop(Context context) {
+        context.stopService(new Intent(context, DownloadService.class));
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        App.get(this).getComponent().inject(this);
+
+        createWakeLock();
+
+        listenQueueRunningChanges();
+        EventBus.getDefault().registerSticky(this);
+        listenNetworkChanges();
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        return START_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        EventBus.getDefault().unregister(this);
+        queueRunningSubscription.unsubscribe();
+        networkChangeSubscription.unsubscribe();
+        downloadManager.destroySubscriptions();
+        destroyWakeLock();
+        super.onDestroy();
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    @EventBusHook
+    public void onEvent(DownloadChaptersEvent event) {
+        EventBus.getDefault().removeStickyEvent(event);
+        downloadManager.onDownloadChaptersEvent(event);
+    }
+
+    private void listenNetworkChanges() {
+        networkChangeSubscription = new ReactiveNetwork().enableInternetCheck()
+                .observeConnectivity(getApplicationContext())
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(state -> {
+                    switch (state) {
+                        case WIFI_CONNECTED_HAS_INTERNET:
+                            // If there are no remaining downloads, destroy the service
+                            if (!isRunning && !downloadManager.startDownloads()) {
+                                stopSelf();
+                            }
+                            break;
+                        case MOBILE_CONNECTED:
+                            if (!preferences.downloadOnlyOverWifi()) {
+                                if (!isRunning && !downloadManager.startDownloads()) {
+                                    stopSelf();
+                                }
+                            } else if (isRunning) {
+                                downloadManager.stopDownloads();
+                            }
+                            break;
+                        default:
+                            if (isRunning) {
+                                downloadManager.stopDownloads();
+                            }
+                            break;
+                    }
+                }, error -> {
+                    ToastUtil.showShort(this, R.string.download_queue_error);
+                    stopSelf();
+                });
+    }
+
+    private void listenQueueRunningChanges() {
+        queueRunningSubscription = downloadManager.getRunningSubject()
+                .subscribe(running -> {
+                    isRunning = running;
+                    if (running)
+                        acquireWakeLock();
+                    else
+                        releaseWakeLock();
+                });
+    }
+
+    private void createWakeLock() {
+        wakeLock = ((PowerManager)getSystemService(POWER_SERVICE)).newWakeLock(
+                PowerManager.PARTIAL_WAKE_LOCK, "DownloadService:WakeLock");
+    }
+
+    private void destroyWakeLock() {
+        if (wakeLock != null && wakeLock.isHeld()) {
+            wakeLock.release();
+            wakeLock = null;
+        }
+    }
+
+    public void acquireWakeLock() {
+        if (wakeLock != null && !wakeLock.isHeld()) {
+            wakeLock.acquire();
+        }
+    }
+
+    public void releaseWakeLock() {
+        if (wakeLock != null && wakeLock.isHeld()) {
+            wakeLock.release();
+        }
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/download/model/Download.java

@@ -0,0 +1,55 @@
+package eu.kanade.tachiyomi.data.download.model;
+
+import java.io.File;
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.source.base.Source;
+import eu.kanade.tachiyomi.data.source.model.Page;
+import rx.subjects.PublishSubject;
+
+public class Download {
+    public Source source;
+    public Manga manga;
+    public Chapter chapter;
+    public List<Page> pages;
+    public File directory;
+
+    public transient volatile int totalProgress;
+    public transient volatile int downloadedImages;
+    private transient volatile int status;
+
+    private transient PublishSubject<Download> statusSubject;
+
+    public static final int NOT_DOWNLOADED = 0;
+    public static final int QUEUE = 1;
+    public static final int DOWNLOADING = 2;
+    public static final int DOWNLOADED = 3;
+    public static final int ERROR = 4;
+
+
+    public Download(Source source, Manga manga, Chapter chapter) {
+        this.source = source;
+        this.manga = manga;
+        this.chapter = chapter;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public void setStatus(int status) {
+        this.status = status;
+        notifyStatus();
+    }
+
+    public void setStatusSubject(PublishSubject<Download> subject) {
+        this.statusSubject = subject;
+    }
+
+    private void notifyStatus() {
+        if (statusSubject != null)
+            statusSubject.onNext(this);
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/download/model/DownloadQueue.java

@@ -0,0 +1,78 @@
+package eu.kanade.tachiyomi.data.download.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.source.model.Page;
+import rx.Observable;
+import rx.subjects.PublishSubject;
+
+public class DownloadQueue extends ArrayList<Download> {
+
+    private PublishSubject<Download> statusSubject;
+
+    public DownloadQueue() {
+        super();
+        statusSubject = PublishSubject.create();
+    }
+
+    public boolean add(Download download) {
+        download.setStatusSubject(statusSubject);
+        download.setStatus(Download.QUEUE);
+        return super.add(download);
+    }
+
+    public void remove(Download download) {
+        super.remove(download);
+        download.setStatusSubject(null);
+    }
+
+    public void remove(Chapter chapter) {
+        for (Download download : this) {
+            if (download.chapter.id.equals(chapter.id)) {
+                remove(download);
+                break;
+            }
+        }
+    }
+
+    public Observable<Download> getActiveDownloads() {
+        return Observable.from(this)
+                .filter(download -> download.getStatus() == Download.DOWNLOADING);
+    }
+
+    public Observable<Download> getStatusObservable() {
+        return statusSubject;
+    }
+
+    public Observable<Download> getProgressObservable() {
+        return statusSubject
+                .startWith(getActiveDownloads())
+                .flatMap(download -> {
+                    if (download.getStatus() == Download.DOWNLOADING) {
+                        PublishSubject<Integer> pageStatusSubject = PublishSubject.create();
+                        setPagesSubject(download.pages, pageStatusSubject);
+                        return pageStatusSubject
+                                .filter(status -> status == Page.READY)
+                                .map(status -> download);
+
+                    } else if (download.getStatus() == Download.DOWNLOADED ||
+                            download.getStatus() == Download.ERROR) {
+
+                        setPagesSubject(download.pages, null);
+                    }
+                    return Observable.just(download);
+                })
+                .filter(download -> download.getStatus() == Download.DOWNLOADING);
+    }
+
+    private void setPagesSubject(List<Page> pages, PublishSubject<Integer> subject) {
+        if (pages != null) {
+            for (Page page : pages) {
+                page.setStatusSubject(subject);
+            }
+        }
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/mangasync/MangaSyncManager.java

@@ -0,0 +1,40 @@
+package eu.kanade.tachiyomi.data.mangasync;
+
+import android.content.Context;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.mangasync.base.MangaSyncService;
+import eu.kanade.tachiyomi.data.mangasync.services.MyAnimeList;
+
+public class MangaSyncManager {
+
+    private List<MangaSyncService> services;
+    private MyAnimeList myAnimeList;
+
+    public static final int MYANIMELIST = 1;
+
+    public MangaSyncManager(Context context) {
+        services = new ArrayList<>();
+        myAnimeList = new MyAnimeList(context);
+        services.add(myAnimeList);
+    }
+
+    public MyAnimeList getMyAnimeList() {
+        return myAnimeList;
+    }
+
+    public List<MangaSyncService> getSyncServices() {
+        return services;
+    }
+
+    public MangaSyncService getSyncService(int id) {
+        switch (id) {
+            case MYANIMELIST:
+                return myAnimeList;
+        }
+        return null;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/mangasync/base/MangaSyncService.java

@@ -0,0 +1,28 @@
+package eu.kanade.tachiyomi.data.mangasync.base;
+
+import com.squareup.okhttp.Response;
+
+import eu.kanade.tachiyomi.data.database.models.MangaSync;
+import rx.Observable;
+
+public abstract class MangaSyncService {
+
+    // Name of the manga sync service to display
+    public abstract String getName();
+
+    // Id of the sync service (must be declared and obtained from MangaSyncManager to avoid conflicts)
+    public abstract int getId();
+
+    public abstract Observable<Boolean> login(String username, String password);
+
+    public abstract boolean isLogged();
+
+    public abstract Observable<Response> update(MangaSync manga);
+
+    public abstract Observable<Response> add(MangaSync manga);
+
+    public abstract Observable<Response> bind(MangaSync manga);
+
+    public abstract String getStatus(int status);
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/mangasync/services/MyAnimeList.java

@@ -0,0 +1,264 @@
+package eu.kanade.tachiyomi.data.mangasync.services;
+
+import android.content.Context;
+import android.net.Uri;
+import android.util.Xml;
+
+import com.squareup.okhttp.Credentials;
+import com.squareup.okhttp.FormEncodingBuilder;
+import com.squareup.okhttp.Headers;
+import com.squareup.okhttp.RequestBody;
+import com.squareup.okhttp.Response;
+
+import org.jsoup.Jsoup;
+import org.xmlpull.v1.XmlSerializer;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.List;
+
+import javax.inject.Inject;
+
+import eu.kanade.tachiyomi.App;
+import eu.kanade.tachiyomi.R;
+import eu.kanade.tachiyomi.data.database.models.MangaSync;
+import eu.kanade.tachiyomi.data.mangasync.MangaSyncManager;
+import eu.kanade.tachiyomi.data.mangasync.base.MangaSyncService;
+import eu.kanade.tachiyomi.data.network.NetworkHelper;
+import eu.kanade.tachiyomi.data.preference.PreferencesHelper;
+import rx.Observable;
+
+public class MyAnimeList extends MangaSyncService {
+
+    @Inject PreferencesHelper preferences;
+    @Inject NetworkHelper networkService;
+
+    private Headers headers;
+    private String username;
+
+    public static final String BASE_URL = "http://myanimelist.net";
+
+    private static final String ENTRY_TAG = "entry";
+    private static final String CHAPTER_TAG = "chapter";
+    private static final String SCORE_TAG = "score";
+    private static final String STATUS_TAG = "status";
+
+    public static final int READING = 1;
+    public static final int COMPLETED = 2;
+    public static final int ON_HOLD = 3;
+    public static final int DROPPED = 4;
+    public static final int PLAN_TO_READ = 6;
+
+    public static final int DEFAULT_STATUS = READING;
+    public static final int DEFAULT_SCORE = 0;
+
+    private Context context;
+
+    public MyAnimeList(Context context) {
+        this.context = context;
+        App.get(context).getComponent().inject(this);
+
+        String username = preferences.getMangaSyncUsername(this);
+        String password = preferences.getMangaSyncPassword(this);
+
+        if (!username.isEmpty() && !password.isEmpty()) {
+            createHeaders(username, password);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "MyAnimeList";
+    }
+
+    @Override
+    public int getId() {
+        return MangaSyncManager.MYANIMELIST;
+    }
+
+    public String getLoginUrl() {
+        return Uri.parse(BASE_URL).buildUpon()
+                .appendEncodedPath("api/account/verify_credentials.xml")
+                .toString();
+    }
+
+    public Observable<Boolean> login(String username, String password) {
+        createHeaders(username, password);
+        return networkService.getResponse(getLoginUrl(), headers, null)
+                .map(response -> response.code() == 200);
+    }
+
+    @Override
+    public boolean isLogged() {
+        return !preferences.getMangaSyncUsername(this).isEmpty()
+                && !preferences.getMangaSyncPassword(this).isEmpty();
+    }
+
+    public String getSearchUrl(String query) {
+        return Uri.parse(BASE_URL).buildUpon()
+                .appendEncodedPath("api/manga/search.xml")
+                .appendQueryParameter("q", query)
+                .toString();
+    }
+
+    public Observable<List<MangaSync>> search(String query) {
+        return networkService.getStringResponse(getSearchUrl(query), headers, null)
+                .map(Jsoup::parse)
+                .flatMap(doc -> Observable.from(doc.select("entry")))
+                .filter(entry -> !entry.select("type").text().equals("Novel"))
+                .map(entry -> {
+                    MangaSync manga = MangaSync.create(this);
+                    manga.title = entry.select("title").first().text();
+                    manga.remote_id = Integer.parseInt(entry.select("id").first().text());
+                    manga.total_chapters = Integer.parseInt(entry.select("chapters").first().text());
+                    return manga;
+                })
+                .toList();
+    }
+
+    public String getListUrl(String username) {
+        return Uri.parse(BASE_URL).buildUpon()
+                .appendPath("malappinfo.php")
+                .appendQueryParameter("u", username)
+                .appendQueryParameter("status", "all")
+                .appendQueryParameter("type", "manga")
+                .toString();
+    }
+
+    public Observable<List<MangaSync>> getList() {
+        // TODO cache this list for a few minutes
+        return networkService.getStringResponse(getListUrl(username), headers, null)
+                .map(Jsoup::parse)
+                .flatMap(doc -> Observable.from(doc.select("manga")))
+                .map(entry -> {
+                    MangaSync manga = MangaSync.create(this);
+                    manga.title = entry.select("series_title").first().text();
+                    manga.remote_id = Integer.parseInt(
+                            entry.select("series_mangadb_id").first().text());
+                    manga.last_chapter_read = Integer.parseInt(
+                            entry.select("my_read_chapters").first().text());
+                    manga.status = Integer.parseInt(
+                            entry.select("my_status").first().text());
+                    // MAL doesn't support score with decimals
+                    manga.score = Integer.parseInt(
+                            entry.select("my_score").first().text());
+                    manga.total_chapters = Integer.parseInt(
+                            entry.select("series_chapters").first().text());
+                    return manga;
+                })
+                .toList();
+    }
+
+    public String getUpdateUrl(MangaSync manga) {
+        return Uri.parse(BASE_URL).buildUpon()
+                .appendEncodedPath("api/mangalist/update")
+                .appendPath(manga.remote_id + ".xml")
+                .toString();
+    }
+
+    public Observable<Response> update(MangaSync manga) {
+        try {
+            if (manga.total_chapters != 0 && manga.last_chapter_read == manga.total_chapters) {
+                manga.status = COMPLETED;
+            }
+            RequestBody payload = getMangaPostPayload(manga);
+            return networkService.postData(getUpdateUrl(manga), payload, headers);
+        } catch (IOException e) {
+            return Observable.error(e);
+        }
+    }
+
+    public String getAddUrl(MangaSync manga) {
+        return Uri.parse(BASE_URL).buildUpon()
+                .appendEncodedPath("api/mangalist/add")
+                .appendPath(manga.remote_id + ".xml")
+                .toString();
+    }
+
+    public Observable<Response> add(MangaSync manga) {
+        try {
+            RequestBody payload = getMangaPostPayload(manga);
+            return networkService.postData(getAddUrl(manga), payload, headers);
+        } catch (IOException e) {
+            return Observable.error(e);
+        }
+    }
+
+    private RequestBody getMangaPostPayload(MangaSync manga) throws IOException {
+        XmlSerializer xml = Xml.newSerializer();
+        StringWriter writer = new StringWriter();
+        xml.setOutput(writer);
+        xml.startDocument("UTF-8", false);
+        xml.startTag("", ENTRY_TAG);
+
+        // Last chapter read
+        if (manga.last_chapter_read != 0) {
+            xml.startTag("", CHAPTER_TAG);
+            xml.text(manga.last_chapter_read + "");
+            xml.endTag("", CHAPTER_TAG);
+        }
+        // Manga status in the list
+        xml.startTag("", STATUS_TAG);
+        xml.text(manga.status + "");
+        xml.endTag("", STATUS_TAG);
+        // Manga score
+        xml.startTag("", SCORE_TAG);
+        xml.text(manga.score + "");
+        xml.endTag("", SCORE_TAG);
+
+        xml.endTag("", ENTRY_TAG);
+        xml.endDocument();
+
+        FormEncodingBuilder form = new FormEncodingBuilder();
+        form.add("data", writer.toString());
+        return form.build();
+    }
+
+    public Observable<Response> bind(MangaSync manga) {
+        return getList()
+                .flatMap(list -> {
+                    manga.sync_id = getId();
+                    for (MangaSync remoteManga : list) {
+                        if (remoteManga.remote_id == manga.remote_id) {
+                            // Manga is already in the list
+                            manga.copyPersonalFrom(remoteManga);
+                            return update(manga);
+                        }
+                    }
+                    // Set default fields if it's not found in the list
+                    manga.score = DEFAULT_SCORE;
+                    manga.status = DEFAULT_STATUS;
+                    return add(manga);
+                });
+    }
+
+    @Override
+    public String getStatus(int status) {
+        switch (status) {
+            case READING:
+                return context.getString(R.string.reading);
+            case COMPLETED:
+                return context.getString(R.string.completed);
+            case ON_HOLD:
+                return context.getString(R.string.on_hold);
+            case DROPPED:
+                return context.getString(R.string.dropped);
+            case PLAN_TO_READ:
+                return context.getString(R.string.plan_to_read);
+        }
+        return "";
+    }
+
+    public void createHeaders(String username, String password) {
+        this.username = username;
+        Headers.Builder builder = new Headers.Builder();
+        builder.add("Authorization", Credentials.basic(username, password));
+        builder.add("User-Agent", "api-indiv-9F93C52A963974CF674325391990191C");
+        setHeaders(builder.build());
+    }
+
+    public void setHeaders(Headers headers) {
+        this.headers = headers;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/network/NetworkHelper.java

@@ -0,0 +1,108 @@
+package eu.kanade.tachiyomi.data.network;
+
+
+import com.squareup.okhttp.CacheControl;
+import com.squareup.okhttp.FormEncodingBuilder;
+import com.squareup.okhttp.Headers;
+import com.squareup.okhttp.OkHttpClient;
+import com.squareup.okhttp.Request;
+import com.squareup.okhttp.RequestBody;
+import com.squareup.okhttp.Response;
+
+import java.net.CookieManager;
+import java.net.CookiePolicy;
+import java.net.CookieStore;
+
+import rx.Observable;
+
+public final class NetworkHelper {
+
+    private OkHttpClient client;
+    private CookieManager cookieManager;
+
+    public final CacheControl NULL_CACHE_CONTROL = new CacheControl.Builder().noCache().build();
+    public final Headers NULL_HEADERS = new Headers.Builder().build();
+    public final RequestBody NULL_REQUEST_BODY = new FormEncodingBuilder().build();
+
+    public NetworkHelper() {
+        client = new OkHttpClient();
+        cookieManager = new CookieManager();
+        cookieManager.setCookiePolicy(CookiePolicy.ACCEPT_ALL);
+        client.setCookieHandler(cookieManager);
+    }
+
+    public Observable<Response> getResponse(final String url, final Headers headers, final CacheControl cacheControl) {
+        return Observable.defer(() -> {
+            try {
+                Request request = new Request.Builder()
+                        .url(url)
+                        .cacheControl(cacheControl != null ? cacheControl : NULL_CACHE_CONTROL)
+                        .headers(headers != null ? headers : NULL_HEADERS)
+                        .build();
+
+                return Observable.just(client.newCall(request).execute());
+            } catch (Throwable e) {
+                return Observable.error(e);
+            }
+        }).retry(1);
+    }
+
+    public Observable<String> mapResponseToString(final Response response) {
+        return Observable.defer(() -> {
+            try {
+                return Observable.just(response.body().string());
+            } catch (Throwable e) {
+                return Observable.error(e);
+            }
+        });
+    }
+
+    public Observable<String> getStringResponse(final String url, final Headers headers, final CacheControl cacheControl) {
+        return getResponse(url, headers, cacheControl)
+                .flatMap(this::mapResponseToString);
+    }
+
+    public Observable<Response> postData(final String url, final RequestBody formBody, final Headers headers) {
+        return Observable.defer(() -> {
+            try {
+                Request request = new Request.Builder()
+                        .url(url)
+                        .post(formBody != null ? formBody : NULL_REQUEST_BODY)
+                        .headers(headers != null ? headers : NULL_HEADERS)
+                        .build();
+                return Observable.just(client.newCall(request).execute());
+            } catch (Throwable e) {
+                return Observable.error(e);
+            }
+        }).retry(1);
+    }
+
+    public Observable<Response> getProgressResponse(final String url, final Headers headers, final ProgressListener listener) {
+        return Observable.defer(() -> {
+            try {
+                Request request = new Request.Builder()
+                        .url(url)
+                        .cacheControl(NULL_CACHE_CONTROL)
+                        .headers(headers != null ? headers : NULL_HEADERS)
+                        .build();
+
+                OkHttpClient progressClient = client.clone();
+
+                progressClient.networkInterceptors().add(chain -> {
+                    Response originalResponse = chain.proceed(chain.request());
+                    return originalResponse.newBuilder()
+                            .body(new ProgressResponseBody(originalResponse.body(), listener))
+                            .build();
+                });
+                return Observable.just(progressClient.newCall(request).execute());
+            } catch (Throwable e) {
+                return Observable.error(e);
+            }
+        }).retry(2);
+    }
+
+    public CookieStore getCookies() {
+        return cookieManager.getCookieStore();
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/network/ProgressListener.java

@@ -0,0 +1,5 @@
+package eu.kanade.tachiyomi.data.network;
+
+public interface ProgressListener {
+    void update(long bytesRead, long contentLength, boolean done);
+}

app/src/main/java/eu/kanade/tachiyomi/data/network/ProgressResponseBody.java

@@ -0,0 +1,52 @@
+package eu.kanade.tachiyomi.data.network;
+
+import com.squareup.okhttp.MediaType;
+import com.squareup.okhttp.ResponseBody;
+
+import java.io.IOException;
+
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.ForwardingSource;
+import okio.Okio;
+import okio.Source;
+
+public class ProgressResponseBody extends ResponseBody {
+
+    private final ResponseBody responseBody;
+    private final ProgressListener progressListener;
+    private BufferedSource bufferedSource;
+
+    public ProgressResponseBody(ResponseBody responseBody, ProgressListener progressListener) {
+        this.responseBody = responseBody;
+        this.progressListener = progressListener;
+    }
+
+    @Override public MediaType contentType() {
+        return responseBody.contentType();
+    }
+
+    @Override public long contentLength() throws IOException {
+        return responseBody.contentLength();
+    }
+
+    @Override public BufferedSource source() throws IOException {
+        if (bufferedSource == null) {
+            bufferedSource = Okio.buffer(source(responseBody.source()));
+        }
+        return bufferedSource;
+    }
+
+    private Source source(Source source) {
+        return new ForwardingSource(source) {
+            long totalBytesRead = 0L;
+            @Override public long read(Buffer sink, long byteCount) throws IOException {
+                long bytesRead = super.read(sink, byteCount);
+                // read() returns the number of bytes read, or -1 if this source is exhausted.
+                totalBytesRead += bytesRead != -1 ? bytesRead : 0;
+                progressListener.update(totalBytesRead, responseBody.contentLength(), bytesRead == -1);
+                return bytesRead;
+            }
+        };
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/preference/PreferencesHelper.java

@@ -0,0 +1,172 @@
+package eu.kanade.tachiyomi.data.preference;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Environment;
+import android.preference.PreferenceManager;
+
+import com.f2prateek.rx.preferences.Preference;
+import com.f2prateek.rx.preferences.RxSharedPreferences;
+
+import java.io.File;
+import java.io.IOException;
+
+import eu.kanade.tachiyomi.R;
+import eu.kanade.tachiyomi.data.mangasync.base.MangaSyncService;
+import eu.kanade.tachiyomi.data.source.base.Source;
+
+public class PreferencesHelper {
+
+    private Context context;
+    private SharedPreferences prefs;
+    private RxSharedPreferences rxPrefs;
+
+    private static final String SOURCE_ACCOUNT_USERNAME = "pref_source_username_";
+    private static final String SOURCE_ACCOUNT_PASSWORD = "pref_source_password_";
+    private static final String MANGASYNC_ACCOUNT_USERNAME = "pref_mangasync_username_";
+    private static final String MANGASYNC_ACCOUNT_PASSWORD = "pref_mangasync_password_";
+
+    private File defaultDownloadsDir;
+
+    public PreferencesHelper(Context context) {
+        this.context = context;
+        PreferenceManager.setDefaultValues(context, R.xml.pref_reader, false);
+
+        prefs = PreferenceManager.getDefaultSharedPreferences(context);
+        rxPrefs = RxSharedPreferences.create(prefs);
+
+        defaultDownloadsDir = new File(Environment.getExternalStorageDirectory() +
+                File.separator + context.getString(R.string.app_name), "downloads");
+
+        // Create default directory
+        if (getDownloadsDirectory().equals(defaultDownloadsDir.getAbsolutePath()) &&
+                !defaultDownloadsDir.exists()) {
+            defaultDownloadsDir.mkdirs();
+            try {
+                new File(defaultDownloadsDir, ".nomedia").createNewFile();
+            } catch (IOException e) { /* Ignore */ }
+        }
+    }
+
+    private String getKey(int keyResource) {
+        return context.getString(keyResource);
+    }
+
+    public void clear() {
+        prefs.edit().clear().apply();
+    }
+
+    public Preference<Boolean> lockOrientation() {
+        return rxPrefs.getBoolean(getKey(R.string.pref_lock_orientation_key), true);
+    }
+
+    public Preference<Boolean> enableTransitions() {
+        return rxPrefs.getBoolean(getKey(R.string.pref_enable_transitions_key), true);
+    }
+
+    public Preference<Boolean> showPageNumber() {
+        return rxPrefs.getBoolean(getKey(R.string.pref_show_page_number_key), true);
+    }
+
+    public Preference<Boolean> hideStatusBar() {
+        return rxPrefs.getBoolean(getKey(R.string.pref_hide_status_bar_key), true);
+    }
+
+    public Preference<Boolean> keepScreenOn() {
+        return rxPrefs.getBoolean(getKey(R.string.pref_keep_screen_on_key), true);
+    }
+
+    public Preference<Boolean> customBrightness() {
+        return rxPrefs.getBoolean(getKey(R.string.pref_custom_brightness_key), false);
+    }
+
+    public Preference<Float> customBrightnessValue() {
+        return rxPrefs.getFloat(getKey(R.string.pref_custom_brightness_value_key), 0F);
+    }
+
+    public int getDefaultViewer() {
+        // TODO use IntListPreference
+        return Integer.parseInt(prefs.getString(getKey(R.string.pref_default_viewer_key), "1"));
+    }
+
+    public Preference<Integer> portraitColumns() {
+        return rxPrefs.getInteger(getKey(R.string.pref_library_columns_portrait_key), 0);
+    }
+
+    public Preference<Integer> landscapeColumns() {
+        return rxPrefs.getInteger(getKey(R.string.pref_library_columns_landscape_key), 0);
+    }
+
+    public boolean updateOnlyNonCompleted() {
+        return prefs.getBoolean(getKey(R.string.pref_update_only_non_completed_key), false);
+    }
+
+    public boolean autoUpdateMangaSync() {
+        return prefs.getBoolean(getKey(R.string.pref_auto_update_manga_sync_key), true);
+    }
+
+    public boolean askUpdateMangaSync() {
+        return prefs.getBoolean(getKey(R.string.pref_ask_update_manga_sync_key), false);
+    }
+
+    public Preference<Integer> imageDecoder() {
+        return rxPrefs.getInteger(getKey(R.string.pref_image_decoder_key), 0);
+    }
+
+    public Preference<Integer> readerTheme() {
+        return rxPrefs.getInteger(getKey(R.string.pref_reader_theme_key), 0);
+    }
+
+    public String getSourceUsername(Source source) {
+        return prefs.getString(SOURCE_ACCOUNT_USERNAME + source.getId(), "");
+    }
+
+    public String getSourcePassword(Source source) {
+        return prefs.getString(SOURCE_ACCOUNT_PASSWORD + source.getId(), "");
+    }
+
+    public void setSourceCredentials(Source source, String username, String password) {
+        prefs.edit()
+                .putString(SOURCE_ACCOUNT_USERNAME + source.getId(), username)
+                .putString(SOURCE_ACCOUNT_PASSWORD + source.getId(), password)
+                .apply();
+    }
+
+    public String getMangaSyncUsername(MangaSyncService sync) {
+        return prefs.getString(MANGASYNC_ACCOUNT_USERNAME + sync.getId(), "");
+    }
+
+    public String getMangaSyncPassword(MangaSyncService sync) {
+        return prefs.getString(MANGASYNC_ACCOUNT_PASSWORD + sync.getId(), "");
+    }
+
+    public void setMangaSyncCredentials(MangaSyncService sync, String username, String password) {
+        prefs.edit()
+                .putString(MANGASYNC_ACCOUNT_USERNAME + sync.getId(), username)
+                .putString(MANGASYNC_ACCOUNT_PASSWORD + sync.getId(), password)
+                .apply();
+    }
+
+    public String getDownloadsDirectory() {
+        return prefs.getString(getKey(R.string.pref_download_directory_key),
+                defaultDownloadsDir.getAbsolutePath());
+    }
+
+    public void setDownloadsDirectory(String path) {
+        prefs.edit().putString(getKey(R.string.pref_download_directory_key), path).apply();
+    }
+
+    public Preference<Integer> downloadThreads() {
+        return rxPrefs.getInteger(getKey(R.string.pref_download_slots_key), 1);
+    }
+
+    public boolean downloadOnlyOverWifi() {
+        return prefs.getBoolean(getKey(R.string.pref_download_only_over_wifi_key), true);
+    }
+
+    public static int getLibraryUpdateInterval(Context context) {
+        return PreferenceManager.getDefaultSharedPreferences(context).getInt(
+                context.getString(R.string.pref_library_update_interval_key), 0);
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/SourceManager.java

@@ -0,0 +1,65 @@
+package eu.kanade.tachiyomi.data.source;
+
+import android.content.Context;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.source.base.Source;
+import eu.kanade.tachiyomi.data.source.online.english.Batoto;
+import eu.kanade.tachiyomi.data.source.online.english.Kissmanga;
+import eu.kanade.tachiyomi.data.source.online.english.Mangafox;
+import eu.kanade.tachiyomi.data.source.online.english.Mangahere;
+
+public class SourceManager {
+
+    public static final int BATOTO = 1;
+    public static final int MANGAHERE = 2;
+    public static final int MANGAFOX = 3;
+    public static final int KISSMANGA = 4;
+
+    private HashMap<Integer, Source> sourcesMap;
+    private Context context;
+
+    public SourceManager(Context context) {
+        sourcesMap = new HashMap<>();
+        this.context = context;
+
+        initializeSources();
+    }
+
+    public Source get(int sourceKey) {
+        if (!sourcesMap.containsKey(sourceKey)) {
+            sourcesMap.put(sourceKey, createSource(sourceKey));
+        }
+        return sourcesMap.get(sourceKey);
+    }
+
+    private Source createSource(int sourceKey) {
+        switch (sourceKey) {
+            case BATOTO:
+                return new Batoto(context);
+            case MANGAHERE:
+                return new Mangahere(context);
+            case MANGAFOX:
+                return new Mangafox(context);
+            case KISSMANGA:
+                return new Kissmanga(context);
+        }
+
+        return null;
+    }
+
+    private void initializeSources() {
+        sourcesMap.put(BATOTO, createSource(BATOTO));
+        sourcesMap.put(MANGAHERE, createSource(MANGAHERE));
+        sourcesMap.put(MANGAFOX, createSource(MANGAFOX));
+        sourcesMap.put(KISSMANGA, createSource(KISSMANGA));
+    }
+
+    public List<Source> getSources() {
+        return new ArrayList<>(sourcesMap.values());
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/base/BaseSource.java

@@ -0,0 +1,102 @@
+package eu.kanade.tachiyomi.data.source.base;
+
+import com.squareup.okhttp.Headers;
+import com.squareup.okhttp.Response;
+
+import org.jsoup.nodes.Document;
+
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.source.model.MangasPage;
+import rx.Observable;
+
+public abstract class BaseSource {
+
+    // Name of the source to display
+    public abstract String getName();
+
+    // Id of the source (must be declared and obtained from SourceManager to avoid conflicts)
+    public abstract int getId();
+
+    // Base url of the source, like: http://example.com
+    public abstract String getBaseUrl();
+
+    // True if the source requires a login
+    public abstract boolean isLoginRequired();
+
+    // Return the initial popular mangas URL
+    protected abstract String getInitialPopularMangasUrl();
+
+    // Return the initial search url given a query
+    protected abstract String getInitialSearchUrl(String query);
+
+    // Get the popular list of mangas from the source's parsed document
+    protected abstract List<Manga> parsePopularMangasFromHtml(Document parsedHtml);
+
+    // Get the next popular page URL or null if it's the last
+    protected abstract String parseNextPopularMangasUrl(Document parsedHtml, MangasPage page);
+
+    // Get the searched list of mangas from the source's parsed document
+    protected abstract List<Manga> parseSearchFromHtml(Document parsedHtml);
+
+    // Get the next search page URL or null if it's the last
+    protected abstract String parseNextSearchUrl(Document parsedHtml, MangasPage page, String query);
+
+    // Given the URL of a manga and the result of the request, return the details of the manga
+    protected abstract Manga parseHtmlToManga(String mangaUrl, String unparsedHtml);
+
+    // Given the result of the request to mangas' chapters, return a list of chapters
+    protected abstract List<Chapter> parseHtmlToChapters(String unparsedHtml);
+
+    // Given the result of the request to a chapter, return the list of URLs of the chapter
+    protected abstract List<String> parseHtmlToPageUrls(String unparsedHtml);
+
+    // Given the result of the request to a chapter's page, return the URL of the image of the page
+    protected abstract String parseHtmlToImageUrl(String unparsedHtml);
+
+
+    // Login related methods, shouldn't be overriden if the source doesn't require it
+    public Observable<Boolean> login(String username, String password) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    public boolean isLogged() {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+
+    protected boolean isAuthenticationSuccessful(Response response) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
+    
+
+    // Default fields, they can be overriden by sources' implementation
+
+    // Get the URL to the details of a manga, useful if the source provides some kind of API or fast calls
+    protected String overrideMangaUrl(String defaultMangaUrl) {
+        return defaultMangaUrl;
+    }
+
+    // Get the URL of the first page that contains a source image and the page list
+    protected String overrideChapterUrl(String defaultPageUrl) {
+        return defaultPageUrl;
+    }
+
+    // Get the URL of the pages that contains source images
+    protected String overridePageUrl(String defaultPageUrl) {
+        return defaultPageUrl;
+    }
+
+    // Default headers, it can be overriden by children or just add new keys
+    protected Headers.Builder headersBuilder() {
+        Headers.Builder builder = new Headers.Builder();
+        builder.add("User-Agent", "Mozilla/5.0 (Windows NT 6.3; WOW64)");
+        return builder;
+    }
+
+    @Override
+    public String toString() {
+        return getName();
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/base/LoginSource.java

@@ -0,0 +1,17 @@
+package eu.kanade.tachiyomi.data.source.base;
+
+import android.content.Context;
+
+public abstract class LoginSource extends Source {
+
+    public LoginSource() {}
+
+    public LoginSource(Context context) {
+        super(context);
+    }
+
+    @Override
+    public boolean isLoginRequired() {
+        return true;
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/base/Source.java

@@ -0,0 +1,219 @@
+package eu.kanade.tachiyomi.data.source.base;
+
+import android.content.Context;
+
+import com.bumptech.glide.load.model.LazyHeaders;
+import com.squareup.okhttp.Headers;
+import com.squareup.okhttp.Response;
+
+import org.jsoup.Jsoup;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import javax.inject.Inject;
+
+import eu.kanade.tachiyomi.App;
+import eu.kanade.tachiyomi.data.cache.ChapterCache;
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.network.NetworkHelper;
+import eu.kanade.tachiyomi.data.preference.PreferencesHelper;
+import eu.kanade.tachiyomi.data.source.model.MangasPage;
+import eu.kanade.tachiyomi.data.source.model.Page;
+import rx.Observable;
+import rx.schedulers.Schedulers;
+
+public abstract class Source extends BaseSource {
+
+    @Inject protected NetworkHelper networkService;
+    @Inject protected ChapterCache chapterCache;
+    @Inject protected PreferencesHelper prefs;
+    protected Headers requestHeaders;
+    protected LazyHeaders glideHeaders;
+
+    public Source() {}
+
+    public Source(Context context) {
+        App.get(context).getComponent().inject(this);
+        requestHeaders = headersBuilder().build();
+        glideHeaders = glideHeadersBuilder().build();
+    }
+
+    @Override
+    public boolean isLoginRequired() {
+        return false;
+    }
+
+    // Get the most popular mangas from the source
+    public Observable<MangasPage> pullPopularMangasFromNetwork(MangasPage page) {
+        if (page.page == 1)
+            page.url = getInitialPopularMangasUrl();
+
+        return networkService
+                .getStringResponse(page.url, requestHeaders, null)
+                .map(Jsoup::parse)
+                .doOnNext(doc -> page.mangas = parsePopularMangasFromHtml(doc))
+                .doOnNext(doc -> page.nextPageUrl = parseNextPopularMangasUrl(doc, page))
+                .map(response -> page);
+    }
+
+    // Get mangas from the source with a query
+    public Observable<MangasPage> searchMangasFromNetwork(MangasPage page, String query) {
+        if (page.page == 1)
+            page.url = getInitialSearchUrl(query);
+
+        return networkService
+                .getStringResponse(page.url, requestHeaders, null)
+                .map(Jsoup::parse)
+                .doOnNext(doc -> page.mangas = parseSearchFromHtml(doc))
+                .doOnNext(doc -> page.nextPageUrl = parseNextSearchUrl(doc, page, query))
+                .map(response -> page);
+    }
+
+    // Get manga details from the source
+    public Observable<Manga> pullMangaFromNetwork(final String mangaUrl) {
+        return networkService
+                .getStringResponse(getBaseUrl() + overrideMangaUrl(mangaUrl), requestHeaders, null)
+                .flatMap(unparsedHtml -> Observable.just(parseHtmlToManga(mangaUrl, unparsedHtml)));
+    }
+
+    // Get chapter list of a manga from the source
+    public Observable<List<Chapter>> pullChaptersFromNetwork(final String mangaUrl) {
+        return networkService
+                .getStringResponse(getBaseUrl() + mangaUrl, requestHeaders, null)
+                .flatMap(unparsedHtml -> {
+                    List<Chapter> chapters = parseHtmlToChapters(unparsedHtml);
+                    return !chapters.isEmpty() ?
+                            Observable.just(chapters) :
+                            Observable.error(new Exception("No chapters found"));
+                });
+    }
+
+    public Observable<List<Page>> getCachedPageListOrPullFromNetwork(final String chapterUrl) {
+        return chapterCache.getPageUrlsFromDiskCache(getChapterCacheKey(chapterUrl))
+                .onErrorResumeNext(throwable -> {
+                    return pullPageListFromNetwork(chapterUrl);
+                })
+                .onBackpressureBuffer();
+    }
+
+    public Observable<List<Page>> pullPageListFromNetwork(final String chapterUrl) {
+        return networkService
+                .getStringResponse(getBaseUrl() + overrideChapterUrl(chapterUrl), requestHeaders, null)
+                .flatMap(unparsedHtml -> {
+                    List<Page> pages = convertToPages(parseHtmlToPageUrls(unparsedHtml));
+                    return !pages.isEmpty() ?
+                            Observable.just(parseFirstPage(pages, unparsedHtml)) :
+                            Observable.error(new Exception("Page list is empty"));
+                });
+    }
+
+    public Observable<Page> getAllImageUrlsFromPageList(final List<Page> pages) {
+        return Observable.from(pages)
+                .filter(page -> page.getImageUrl() != null)
+                .mergeWith(getRemainingImageUrlsFromPageList(pages));
+    }
+
+    // Get the URLs of the images of a chapter
+    public Observable<Page> getRemainingImageUrlsFromPageList(final List<Page> pages) {
+        return Observable.from(pages)
+                .filter(page -> page.getImageUrl() == null)
+                .concatMap(this::getImageUrlFromPage);
+    }
+
+    public Observable<Page> getImageUrlFromPage(final Page page) {
+        page.setStatus(Page.LOAD_PAGE);
+        return networkService
+                .getStringResponse(overridePageUrl(page.getUrl()), requestHeaders, null)
+                .flatMap(unparsedHtml -> Observable.just(parseHtmlToImageUrl(unparsedHtml)))
+                .onErrorResumeNext(e -> {
+                    page.setStatus(Page.ERROR);
+                    return Observable.just(null);
+                })
+                .flatMap(imageUrl -> {
+                    page.setImageUrl(imageUrl);
+                    return Observable.just(page);
+                })
+                .subscribeOn(Schedulers.io());
+    }
+
+    public Observable<Page> getCachedImage(final Page page) {
+        Observable<Page> pageObservable = Observable.just(page);
+        if (page.getImageUrl() == null)
+            return pageObservable;
+
+        return pageObservable
+                .flatMap(p -> {
+                    if (!chapterCache.isImageInCache(page.getImageUrl())) {
+                        return cacheImage(page);
+                    }
+                    return Observable.just(page);
+                })
+                .flatMap(p -> {
+                    page.setImagePath(chapterCache.getImagePath(page.getImageUrl()));
+                    page.setStatus(Page.READY);
+                    return Observable.just(page);
+                })
+                .onErrorResumeNext(e -> {
+                    page.setStatus(Page.ERROR);
+                    return Observable.just(page);
+                });
+    }
+
+    private Observable<Page> cacheImage(final Page page) {
+        page.setStatus(Page.DOWNLOAD_IMAGE);
+        return getImageProgressResponse(page)
+                .flatMap(resp -> {
+                    try {
+                        chapterCache.putImageToDiskCache(page.getImageUrl(), resp);
+                    } catch (IOException e) {
+                        return Observable.error(e);
+                    }
+                    return Observable.just(page);
+                });
+    }
+
+    public Observable<Response> getImageProgressResponse(final Page page) {
+        return networkService.getProgressResponse(page.getImageUrl(), requestHeaders, page);
+    }
+
+    public void savePageList(String chapterUrl, List<Page> pages) {
+        if (pages != null)
+            chapterCache.putPageUrlsToDiskCache(getChapterCacheKey(chapterUrl), pages);
+    }
+
+    protected List<Page> convertToPages(List<String> pageUrls) {
+        List<Page> pages = new ArrayList<>();
+        for (int i = 0; i < pageUrls.size(); i++) {
+            pages.add(new Page(i, pageUrls.get(i)));
+        }
+        return pages;
+    }
+
+    protected List<Page> parseFirstPage(List<Page> pages, String unparsedHtml) {
+        String firstImage = parseHtmlToImageUrl(unparsedHtml);
+        pages.get(0).setImageUrl(firstImage);
+        return pages;
+    }
+
+    protected String getChapterCacheKey(String chapterUrl) {
+        return getId() + chapterUrl;
+    }
+
+    protected LazyHeaders.Builder glideHeadersBuilder() {
+        LazyHeaders.Builder builder = new LazyHeaders.Builder();
+        for (Map.Entry<String, List<String>> entry : requestHeaders.toMultimap().entrySet()) {
+            builder.addHeader(entry.getKey(), entry.getValue().get(0));
+        }
+
+        return builder;
+    }
+
+    public LazyHeaders getGlideHeaders() {
+        return glideHeaders;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/model/MangasPage.java

@@ -0,0 +1,18 @@
+package eu.kanade.tachiyomi.data.source.model;
+
+import java.util.List;
+
+import eu.kanade.tachiyomi.data.database.models.Manga;
+
+public class MangasPage {
+
+    public List<Manga> mangas;
+    public int page;
+    public String url;
+    public String nextPageUrl;
+
+    public MangasPage(int page) {
+        this.page = page;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/model/Page.java

@@ -0,0 +1,85 @@
+package eu.kanade.tachiyomi.data.source.model;
+
+import eu.kanade.tachiyomi.data.network.ProgressListener;
+import rx.subjects.PublishSubject;
+
+public class Page implements ProgressListener {
+
+    private int pageNumber;
+    private String url;
+    private String imageUrl;
+    private transient String imagePath;
+    private transient volatile int status;
+    private transient volatile int progress;
+
+    private transient PublishSubject<Integer> statusSubject;
+
+    public static final int QUEUE = 0;
+    public static final int LOAD_PAGE = 1;
+    public static final int DOWNLOAD_IMAGE = 2;
+    public static final int READY = 3;
+    public static final int ERROR = 4;
+
+    public Page(int pageNumber, String url, String imageUrl, String imagePath) {
+        this.pageNumber = pageNumber;
+        this.url = url;
+        this.imageUrl = imageUrl;
+        this.imagePath = imagePath;
+    }
+
+    public Page(int pageNumber, String url) {
+        this(pageNumber, url, null, null);
+    }
+
+    public int getPageNumber() {
+        return pageNumber;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public String getImageUrl() {
+        return imageUrl;
+    }
+
+    public void setImageUrl(String imageUrl) {
+        this.imageUrl = imageUrl;
+    }
+
+    public String getImagePath() {
+        return imagePath;
+    }
+
+    public void setImagePath(String imagePath) {
+        this.imagePath = imagePath;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public void setStatus(int status) {
+        this.status = status;
+        if (statusSubject != null)
+            statusSubject.onNext(status);
+    }
+
+    public int getProgress() {
+        return progress;
+    }
+
+    public void setProgress(int value) {
+        progress = value;
+    }
+
+    @Override
+    public void update(long bytesRead, long contentLength, boolean done) {
+        progress = (int) ((100 * bytesRead) / contentLength);
+    }
+
+    public void setStatusSubject(PublishSubject<Integer> subject) {
+        this.statusSubject = subject;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/online/english/Batoto.java

@@ -0,0 +1,367 @@
+package eu.kanade.tachiyomi.data.source.online.english;
+
+import android.content.Context;
+import android.net.Uri;
+import android.text.TextUtils;
+
+import com.squareup.okhttp.FormEncodingBuilder;
+import com.squareup.okhttp.Headers;
+import com.squareup.okhttp.Response;
+
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+
+import java.net.HttpCookie;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.source.SourceManager;
+import eu.kanade.tachiyomi.data.source.base.LoginSource;
+import eu.kanade.tachiyomi.data.source.model.MangasPage;
+import eu.kanade.tachiyomi.data.source.model.Page;
+import eu.kanade.tachiyomi.util.Parser;
+import rx.Observable;
+
+public class Batoto extends LoginSource {
+
+    public static final String NAME = "Batoto (EN)";
+    public static final String BASE_URL = "http://bato.to";
+    public static final String POPULAR_MANGAS_URL = BASE_URL + "/search_ajax?order_cond=views&order=desc&p=%d";
+    public static final String SEARCH_URL = BASE_URL + "/search_ajax?name=%s&p=%s";
+    public static final String CHAPTER_URL = "/areader?id=%s&p=1";
+    public static final String PAGE_URL = BASE_URL + "/areader?id=%s&p=%s";
+    public static final String MANGA_URL = "/comic_pop?id=%s";
+    public static final String LOGIN_URL = BASE_URL + "/forums/index.php?app=core&module=global&section=login";
+
+    private Pattern datePattern;
+    private Map<String, Integer> dateFields;
+
+    public Batoto(Context context) {
+        super(context);
+
+        datePattern = Pattern.compile("(\\d+|A|An)\\s+(.*?)s? ago.*");
+        dateFields = new HashMap<String, Integer>() {{
+            put("second", Calendar.SECOND);
+            put("minute", Calendar.MINUTE);
+            put("hour",   Calendar.HOUR);
+            put("day",    Calendar.DATE);
+            put("week",   Calendar.WEEK_OF_YEAR);
+            put("month",  Calendar.MONTH);
+            put("year",   Calendar.YEAR);
+        }};
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public int getId() {
+        return SourceManager.BATOTO;
+    }
+
+    @Override
+    public String getBaseUrl() {
+        return BASE_URL;
+    }
+
+    @Override
+    protected Headers.Builder headersBuilder() {
+        Headers.Builder builder = super.headersBuilder();
+        builder.add("Cookie", "lang_option=English");
+        builder.add("Referer", "http://bato.to/reader");
+        return builder;
+    }
+
+    @Override
+    public String getInitialPopularMangasUrl() {
+        return String.format(POPULAR_MANGAS_URL, 1);
+    }
+
+    @Override
+    public String getInitialSearchUrl(String query) {
+        return String.format(SEARCH_URL, Uri.encode(query), 1);
+    }
+
+    @Override
+    protected String overrideMangaUrl(String defaultMangaUrl) {
+        String mangaId = defaultMangaUrl.substring(defaultMangaUrl.lastIndexOf("r") + 1);
+        return String.format(MANGA_URL, mangaId);
+    }
+
+    @Override
+    protected String overrideChapterUrl(String defaultPageUrl) {
+        String id = defaultPageUrl.substring(defaultPageUrl.indexOf("#") + 1);
+        return String.format(CHAPTER_URL, id);
+    }
+
+    @Override
+    protected String overridePageUrl(String defaultPageUrl) {
+        int start = defaultPageUrl.indexOf("#") + 1;
+        int end = defaultPageUrl.indexOf("_", start);
+        String id = defaultPageUrl.substring(start, end);
+        return String.format(PAGE_URL, id, defaultPageUrl.substring(end+1));
+    }
+
+    private List<Manga> parseMangasFromHtml(Document parsedHtml) {
+        List<Manga> mangaList = new ArrayList<>();
+
+        if (!parsedHtml.text().contains("No (more) comics found!")) {
+            for (Element currentHtmlBlock : parsedHtml.select("tr:not([id]):not([class])")) {
+                Manga manga = constructMangaFromHtmlBlock(currentHtmlBlock);
+                mangaList.add(manga);
+            }
+        }
+        return mangaList;
+    }
+
+    @Override
+    protected List<Manga> parsePopularMangasFromHtml(Document parsedHtml) {
+        return parseMangasFromHtml(parsedHtml);
+    }
+
+    @Override
+    protected String parseNextPopularMangasUrl(Document parsedHtml, MangasPage page) {
+        Element next = Parser.element(parsedHtml, "#show_more_row");
+        return next != null ? String.format(POPULAR_MANGAS_URL, page.page + 1) : null;
+    }
+
+    @Override
+    protected List<Manga> parseSearchFromHtml(Document parsedHtml) {
+        return parseMangasFromHtml(parsedHtml);
+    }
+
+    private Manga constructMangaFromHtmlBlock(Element htmlBlock) {
+        Manga manga = new Manga();
+        manga.source = getId();
+
+        Element urlElement = Parser.element(htmlBlock, "a[href^=http://bato.to]");
+        if (urlElement != null) {
+            manga.setUrl(urlElement.attr("href"));
+            manga.title = urlElement.text().trim();
+        }
+        return manga;
+    }
+
+    @Override
+    protected String parseNextSearchUrl(Document parsedHtml, MangasPage page, String query) {
+        Element next = Parser.element(parsedHtml, "#show_more_row");
+        return next != null ? String.format(SEARCH_URL, query, page.page + 1) : null;
+    }
+
+    @Override
+    protected Manga parseHtmlToManga(String mangaUrl, String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+
+        Element tbody = parsedDocument.select("tbody").first();
+        Element artistElement = tbody.select("tr:contains(Author/Artist:)").first();
+        Elements genreElements = tbody.select("tr:contains(Genres:) img");
+
+        Manga manga = Manga.create(mangaUrl);
+        manga.author = Parser.text(artistElement, "td:eq(1)");
+        manga.artist = Parser.text(artistElement, "td:eq(2)", manga.author);
+        manga.description = Parser.text(tbody, "tr:contains(Description:) > td:eq(1)");
+        manga.thumbnail_url = Parser.src(parsedDocument, "img[src^=http://img.bato.to/forums/uploads/]");
+        manga.status = parseStatus(Parser.text(parsedDocument, "tr:contains(Status:) > td:eq(1)"));
+
+        if (!genreElements.isEmpty()) {
+            List<String> genres = new ArrayList<>();
+            for (Element element : genreElements) {
+                genres.add(element.attr("alt"));
+            }
+            manga.genre = TextUtils.join(", ", genres);
+        }
+
+        manga.initialized = true;
+        return manga;
+    }
+
+    private int parseStatus(String status) {
+        switch (status) {
+            case "Ongoing":
+                return Manga.ONGOING;
+            case "Complete":
+                return Manga.COMPLETED;
+            default:
+                return Manga.UNKNOWN;
+        }
+    }
+
+    @Override
+    protected List<Chapter> parseHtmlToChapters(String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+
+        List<Chapter> chapterList = new ArrayList<>();
+
+        Elements chapterElements = parsedDocument.select("tr.row.lang_English.chapter_row");
+        for (Element chapterElement : chapterElements) {
+            Chapter chapter = constructChapterFromHtmlBlock(chapterElement);
+            chapterList.add(chapter);
+        }
+        return chapterList;
+
+    }
+
+    private Chapter constructChapterFromHtmlBlock(Element chapterElement) {
+        Chapter chapter = Chapter.create();
+
+        Element urlElement = chapterElement.select("a[href^=http://bato.to/reader").first();
+        Element dateElement = chapterElement.select("td").get(4);
+
+        if (urlElement != null) {
+            String fieldUrl = urlElement.attr("href");
+            chapter.setUrl(fieldUrl);
+            chapter.name = urlElement.text().trim();
+        }
+        if (dateElement != null) {
+            chapter.date_upload = parseDateFromElement(dateElement);
+        }
+        return chapter;
+    }
+
+    private long parseDateFromElement(Element dateElement) {
+        String dateAsString = dateElement.text();
+
+        Date date;
+        try {
+            date = new SimpleDateFormat("dd MMMMM yyyy - hh:mm a", Locale.ENGLISH).parse(dateAsString);
+        } catch (ParseException e) {
+            Matcher m = datePattern.matcher(dateAsString);
+
+            if (m.matches()) {
+                String number = m.group(1);
+                int amount = number.contains("A") ? 1 : Integer.parseInt(m.group(1));
+                String unit = m.group(2);
+
+                Calendar cal = Calendar.getInstance();
+                // Not an error
+                cal.add(dateFields.get(unit), -amount);
+                date = cal.getTime();
+            } else {
+                return 0;
+            }
+        }
+        return date.getTime();
+    }
+
+    @Override
+    protected List<String> parseHtmlToPageUrls(String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+
+        List<String> pageUrlList = new ArrayList<>();
+
+        Element selectElement = Parser.element(parsedDocument, "#page_select");
+        if (selectElement != null) {
+            for (Element pageUrlElement : selectElement.select("option")) {
+                pageUrlList.add(pageUrlElement.attr("value"));
+            }
+        } else {
+            // For webtoons in one page
+            for (int i = 0; i < parsedDocument.select("div > img").size(); i++) {
+                pageUrlList.add("");
+            }
+        }
+
+        return pageUrlList;
+    }
+
+    @Override
+    protected List<Page> parseFirstPage(List<Page> pages, String unparsedHtml) {
+        if (!unparsedHtml.contains("Want to see this chapter per page instead?")) {
+            String firstImage = parseHtmlToImageUrl(unparsedHtml);
+            pages.get(0).setImageUrl(firstImage);
+        } else {
+            // For webtoons in one page
+            Document parsedDocument = Jsoup.parse(unparsedHtml);
+            Elements imageUrls = parsedDocument.select("div > img");
+            for (int i = 0; i < pages.size(); i++) {
+                pages.get(i).setImageUrl(imageUrls.get(i).attr("src"));
+            }
+        }
+        return pages;
+    }
+
+    @Override
+    protected String parseHtmlToImageUrl(String unparsedHtml) {
+        int beginIndex = unparsedHtml.indexOf("<img id=\"comic_page\"");
+        int endIndex = unparsedHtml.indexOf("</a>", beginIndex);
+        String trimmedHtml = unparsedHtml.substring(beginIndex, endIndex);
+
+        Document parsedDocument = Jsoup.parse(trimmedHtml);
+        Element imageElement = parsedDocument.getElementById("comic_page");
+        return imageElement.attr("src");
+    }
+
+    @Override
+    public Observable<Boolean> login(String username, String password) {
+        return networkService.getStringResponse(LOGIN_URL, requestHeaders, null)
+                .flatMap(response -> doLogin(response, username, password))
+                .map(this::isAuthenticationSuccessful);
+    }
+
+    private Observable<Response> doLogin(String response, String username, String password) {
+        Document doc = Jsoup.parse(response);
+        Element form = doc.select("#login").first();
+        String postUrl = form.attr("action");
+
+        FormEncodingBuilder formBody = new FormEncodingBuilder();
+        Element authKey = form.select("input[name=auth_key]").first();
+
+        formBody.add(authKey.attr("name"), authKey.attr("value"));
+        formBody.add("ips_username", username);
+        formBody.add("ips_password", password);
+        formBody.add("invisible", "1");
+        formBody.add("rememberMe", "1");
+
+        return networkService.postData(postUrl, formBody.build(), requestHeaders);
+    }
+
+    @Override
+    protected boolean isAuthenticationSuccessful(Response response) {
+        return response.priorResponse() != null && response.priorResponse().code() == 302;
+    }
+
+    @Override
+    public boolean isLogged() {
+        try {
+            for ( HttpCookie cookie : networkService.getCookies().get(new URI(BASE_URL)) ) {
+                if (cookie.getName().equals("pass_hash"))
+                    return true;
+            }
+
+        } catch (URISyntaxException e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    @Override
+    public Observable<List<Chapter>> pullChaptersFromNetwork(String mangaUrl) {
+        Observable<List<Chapter>> observable;
+        if (!isLogged()) {
+            observable = login(prefs.getSourceUsername(this), prefs.getSourcePassword(this))
+                    .flatMap(result -> super.pullChaptersFromNetwork(mangaUrl));
+        }
+        else {
+            observable = super.pullChaptersFromNetwork(mangaUrl);
+        }
+        return observable;
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/online/english/Kissmanga.java

@@ -0,0 +1,247 @@
+package eu.kanade.tachiyomi.data.source.online.english;
+
+import android.content.Context;
+import android.net.Uri;
+
+import com.squareup.okhttp.FormEncodingBuilder;
+import com.squareup.okhttp.Headers;
+import com.squareup.okhttp.Response;
+
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.source.SourceManager;
+import eu.kanade.tachiyomi.data.source.base.Source;
+import eu.kanade.tachiyomi.data.source.model.MangasPage;
+import eu.kanade.tachiyomi.data.source.model.Page;
+import eu.kanade.tachiyomi.util.Parser;
+import rx.Observable;
+
+public class Kissmanga extends Source {
+
+    public static final String NAME = "Kissmanga (EN)";
+    public static final String HOST = "kissmanga.com";
+    public static final String IP = "93.174.95.110";
+    public static final String BASE_URL = "http://" + IP;
+    public static final String POPULAR_MANGAS_URL = BASE_URL + "/MangaList/MostPopular?page=%s";
+    public static final String SEARCH_URL = BASE_URL + "/AdvanceSearch";
+
+    public Kissmanga(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected Headers.Builder headersBuilder() {
+        Headers.Builder builder = super.headersBuilder();
+        builder.add("Host", HOST);
+        return builder;
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public int getId() {
+        return SourceManager.KISSMANGA;
+    }
+
+    @Override
+    public String getBaseUrl() {
+        return BASE_URL;
+    }
+
+    @Override
+    protected String getInitialPopularMangasUrl() {
+        return String.format(POPULAR_MANGAS_URL, 1);
+    }
+
+    @Override
+    protected String getInitialSearchUrl(String query) {
+        return SEARCH_URL;
+    }
+
+    @Override
+    protected List<Manga> parsePopularMangasFromHtml(Document parsedHtml) {
+        List<Manga> mangaList = new ArrayList<>();
+
+        for (Element currentHtmlBlock : parsedHtml.select("table.listing tr:gt(1)")) {
+            Manga manga = constructPopularMangaFromHtml(currentHtmlBlock);
+            mangaList.add(manga);
+        }
+
+        return mangaList;
+    }
+
+    private Manga constructPopularMangaFromHtml(Element htmlBlock) {
+        Manga manga = new Manga();
+        manga.source = getId();
+
+        Element urlElement = Parser.element(htmlBlock, "td a:eq(0)");
+
+        if (urlElement != null) {
+            manga.setUrl(urlElement.attr("href"));
+            manga.title = urlElement.text();
+        }
+
+        return manga;
+    }
+
+    @Override
+    protected String parseNextPopularMangasUrl(Document parsedHtml, MangasPage page) {
+        String path = Parser.href(parsedHtml, "li > a:contains(› Next)");
+        return path != null ? BASE_URL + path : null;
+    }
+
+    public Observable<MangasPage> searchMangasFromNetwork(MangasPage page, String query) {
+        if (page.page == 1)
+            page.url = getInitialSearchUrl(query);
+
+        FormEncodingBuilder form = new FormEncodingBuilder();
+        form.add("authorArtist", "");
+        form.add("mangaName", query);
+        form.add("status", "");
+        form.add("genres", "");
+
+        return networkService
+                .postData(page.url, form.build(), requestHeaders)
+                .flatMap(networkService::mapResponseToString)
+                .map(Jsoup::parse)
+                .doOnNext(doc -> page.mangas = parseSearchFromHtml(doc))
+                .doOnNext(doc -> page.nextPageUrl = parseNextSearchUrl(doc, page, query))
+                .map(response -> page);
+    }
+
+    @Override
+    protected List<Manga> parseSearchFromHtml(Document parsedHtml) {
+        return parsePopularMangasFromHtml(parsedHtml);
+    }
+
+    @Override
+    protected String parseNextSearchUrl(Document parsedHtml, MangasPage page, String query) {
+        return null;
+    }
+
+    @Override
+    protected Manga parseHtmlToManga(String mangaUrl, String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+        Element infoElement = parsedDocument.select("div.barContent").first();
+
+        Manga manga = Manga.create(mangaUrl);
+        manga.title = Parser.text(infoElement, "a.bigChar");
+        manga.author = Parser.text(infoElement, "p:has(span:contains(Author:)) > a");
+        manga.genre = Parser.allText(infoElement, "p:has(span:contains(Genres:)) > *:gt(0)");
+        manga.description = Parser.allText(infoElement, "p:has(span:contains(Summary:)) ~ p");
+        manga.status = parseStatus(Parser.text(infoElement, "p:has(span:contains(Status:))"));
+
+        String thumbnail = Parser.src(parsedDocument, ".rightBox:eq(0) img");
+        if (thumbnail != null) {
+            manga.thumbnail_url = Uri.parse(thumbnail).buildUpon().authority(IP).toString();
+        }
+
+        manga.initialized = true;
+        return manga;
+    }
+
+    private int parseStatus(String status) {
+        if (status.contains("Ongoing")) {
+            return Manga.ONGOING;
+        }
+        if (status.contains("Completed")) {
+            return Manga.COMPLETED;
+        }
+        return Manga.UNKNOWN;
+    }
+
+    @Override
+    protected List<Chapter> parseHtmlToChapters(String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+        List<Chapter> chapterList = new ArrayList<>();
+
+        for (Element chapterElement : parsedDocument.select("table.listing tr:gt(1)")) {
+            Chapter chapter = constructChapterFromHtmlBlock(chapterElement);
+            chapterList.add(chapter);
+        }
+
+        return chapterList;
+    }
+
+    private Chapter constructChapterFromHtmlBlock(Element chapterElement) {
+        Chapter chapter = Chapter.create();
+
+        Element urlElement = Parser.element(chapterElement, "a");
+        String date = Parser.text(chapterElement, "td:eq(1)");
+
+        if (urlElement != null) {
+            chapter.setUrl(urlElement.attr("href"));
+            chapter.name = urlElement.text();
+        }
+        if (date != null) {
+            try {
+                chapter.date_upload = new SimpleDateFormat("MM/dd/yyyy", Locale.ENGLISH).parse(date).getTime();
+            } catch (ParseException e) { /* Ignore */ }
+        }
+        return chapter;
+    }
+
+    @Override
+    public Observable<List<Page>> pullPageListFromNetwork(final String chapterUrl) {
+        return networkService
+                .postData(getBaseUrl() + overrideChapterUrl(chapterUrl), null, requestHeaders)
+                .flatMap(networkService::mapResponseToString)
+                .flatMap(unparsedHtml -> {
+                    List<Page> pages = convertToPages(parseHtmlToPageUrls(unparsedHtml));
+                    return !pages.isEmpty() ?
+                            Observable.just(parseFirstPage(pages, unparsedHtml)) :
+                            Observable.error(new Exception("Page list is empty"));
+                });
+    }
+
+    @Override
+    protected List<String> parseHtmlToPageUrls(String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+        List<String> pageUrlList = new ArrayList<>();
+
+        int numImages = parsedDocument.select("#divImage img").size();
+
+        for (int i = 0; i < numImages; i++) {
+            pageUrlList.add("");
+        }
+        return pageUrlList;
+    }
+
+    @Override
+    protected List<Page> parseFirstPage(List<Page> pages, String unparsedHtml) {
+        Pattern p = Pattern.compile("lstImages.push\\(\"(.+?)\"");
+        Matcher m = p.matcher(unparsedHtml);
+
+        int i = 0;
+        while (m.find()) {
+            pages.get(i++).setImageUrl(m.group(1));
+        }
+        return pages;
+    }
+
+    @Override
+    protected String parseHtmlToImageUrl(String unparsedHtml) {
+        return null;
+    }
+
+    @Override
+    public Observable<Response> getImageProgressResponse(final Page page) {
+        return networkService.getProgressResponse(page.getImageUrl(), null, page);
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/online/english/Mangafox.java

@@ -0,0 +1,249 @@
+package eu.kanade.tachiyomi.data.source.online.english;
+
+import android.content.Context;
+import android.net.Uri;
+
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.source.SourceManager;
+import eu.kanade.tachiyomi.data.source.base.Source;
+import eu.kanade.tachiyomi.data.source.model.MangasPage;
+import eu.kanade.tachiyomi.util.Parser;
+
+public class Mangafox extends Source {
+
+    public static final String NAME = "Mangafox (EN)";
+    public static final String BASE_URL = "http://mangafox.me";
+    public static final String POPULAR_MANGAS_URL = BASE_URL + "/directory/%s";
+    public static final String SEARCH_URL =
+            BASE_URL + "/search.php?name_method=cw&advopts=1&order=az&sort=name&name=%s&page=%s";
+
+    public Mangafox(Context context) {
+        super(context);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public int getId() {
+        return SourceManager.MANGAFOX;
+    }
+
+    @Override
+    public String getBaseUrl() {
+        return BASE_URL;
+    }
+
+    @Override
+    protected String getInitialPopularMangasUrl() {
+        return String.format(POPULAR_MANGAS_URL, "");
+    }
+
+    @Override
+    protected String getInitialSearchUrl(String query) {
+        return String.format(SEARCH_URL, Uri.encode(query), 1);
+    }
+
+    @Override
+    protected List<Manga> parsePopularMangasFromHtml(Document parsedHtml) {
+        List<Manga> mangaList = new ArrayList<>();
+
+        for (Element currentHtmlBlock : parsedHtml.select("div#mangalist > ul.list > li")) {
+            Manga currentManga = constructPopularMangaFromHtmlBlock(currentHtmlBlock);
+            mangaList.add(currentManga);
+        }
+        return mangaList;
+    }
+
+    private Manga constructPopularMangaFromHtmlBlock(Element htmlBlock) {
+        Manga manga = new Manga();
+        manga.source = getId();
+
+        Element urlElement = Parser.element(htmlBlock, "a.title");
+        if (urlElement != null) {
+            manga.setUrl(urlElement.attr("href"));
+            manga.title = urlElement.text();
+        }
+        return manga;
+    }
+
+    @Override
+    protected String parseNextPopularMangasUrl(Document parsedHtml, MangasPage page) {
+        Element next = Parser.element(parsedHtml, "a:has(span.next)");
+        return next != null ? String.format(POPULAR_MANGAS_URL, next.attr("href")) : null;
+    }
+
+    @Override
+    protected List<Manga> parseSearchFromHtml(Document parsedHtml) {
+        List<Manga> mangaList = new ArrayList<>();
+
+        for (Element currentHtmlBlock : parsedHtml.select("table#listing > tbody > tr:gt(0)")) {
+            Manga currentManga = constructSearchMangaFromHtmlBlock(currentHtmlBlock);
+            mangaList.add(currentManga);
+        }
+        return mangaList;
+    }
+
+    private Manga constructSearchMangaFromHtmlBlock(Element htmlBlock) {
+        Manga mangaFromHtmlBlock = new Manga();
+        mangaFromHtmlBlock.source = getId();
+
+        Element urlElement = Parser.element(htmlBlock, "a.series_preview");
+        if (urlElement != null) {
+            mangaFromHtmlBlock.setUrl(urlElement.attr("href"));
+            mangaFromHtmlBlock.title = urlElement.text();
+        }
+        return mangaFromHtmlBlock;
+    }
+
+    @Override
+    protected String parseNextSearchUrl(Document parsedHtml, MangasPage page, String query) {
+        Element next = Parser.element(parsedHtml, "a:has(span.next)");
+        return next != null ? BASE_URL + next.attr("href") : null;
+    }
+
+    @Override
+    protected Manga parseHtmlToManga(String mangaUrl, String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+
+        Element infoElement = parsedDocument.select("div#title").first();
+        Element rowElement = infoElement.select("table > tbody > tr:eq(1)").first();
+        Element sideInfoElement = parsedDocument.select("#series_info").first();
+
+        Manga manga = Manga.create(mangaUrl);
+        manga.author = Parser.text(rowElement, "td:eq(1)");
+        manga.artist = Parser.text(rowElement, "td:eq(2)");
+        manga.description = Parser.text(infoElement, "p.summary");
+        manga.genre = Parser.text(rowElement, "td:eq(3)");
+        manga.thumbnail_url = Parser.src(sideInfoElement, "div.cover > img");
+        manga.status = parseStatus(Parser.text(sideInfoElement, ".data"));
+
+        manga.initialized = true;
+        return manga;
+    }
+
+    private int parseStatus(String status) {
+        if (status.contains("Ongoing")) {
+            return Manga.ONGOING;
+        }
+        if (status.contains("Completed")) {
+            return Manga.COMPLETED;
+        }
+        return Manga.UNKNOWN;
+    }
+
+    @Override
+    protected List<Chapter> parseHtmlToChapters(String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+
+        List<Chapter> chapterList = new ArrayList<>();
+
+        for (Element chapterElement : parsedDocument.select("div#chapters li div")) {
+            Chapter currentChapter = constructChapterFromHtmlBlock(chapterElement);
+            chapterList.add(currentChapter);
+        }
+        return chapterList;
+    }
+
+    private Chapter constructChapterFromHtmlBlock(Element chapterElement) {
+        Chapter chapter = Chapter.create();
+
+        Element urlElement = chapterElement.select("a.tips").first();
+        Element dateElement = chapterElement.select("span.date").first();
+
+        if (urlElement != null) {
+            chapter.setUrl(urlElement.attr("href"));
+            chapter.name = urlElement.text();
+        }
+        if (dateElement != null) {
+            chapter.date_upload = parseUpdateFromElement(dateElement);
+        }
+        return chapter;
+    }
+
+    private long parseUpdateFromElement(Element updateElement) {
+        String updatedDateAsString = updateElement.text();
+
+        if (updatedDateAsString.contains("Today")) {
+            Calendar today = Calendar.getInstance();
+            today.set(Calendar.HOUR_OF_DAY, 0);
+            today.set(Calendar.MINUTE, 0);
+            today.set(Calendar.SECOND, 0);
+            today.set(Calendar.MILLISECOND, 0);
+
+            try {
+                Date withoutDay = new SimpleDateFormat("h:mm a", Locale.ENGLISH).parse(updatedDateAsString.replace("Today", ""));
+                return today.getTimeInMillis() + withoutDay.getTime();
+            } catch (ParseException e) {
+                return today.getTimeInMillis();
+            }
+        } else if (updatedDateAsString.contains("Yesterday")) {
+            Calendar yesterday = Calendar.getInstance();
+            yesterday.add(Calendar.DATE, -1);
+            yesterday.set(Calendar.HOUR_OF_DAY, 0);
+            yesterday.set(Calendar.MINUTE, 0);
+            yesterday.set(Calendar.SECOND, 0);
+            yesterday.set(Calendar.MILLISECOND, 0);
+
+            try {
+                Date withoutDay = new SimpleDateFormat("h:mm a", Locale.ENGLISH).parse(updatedDateAsString.replace("Yesterday", ""));
+                return yesterday.getTimeInMillis() + withoutDay.getTime();
+            } catch (ParseException e) {
+                return yesterday.getTimeInMillis();
+            }
+        } else {
+            try {
+                Date specificDate = new SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH).parse(updatedDateAsString);
+
+                return specificDate.getTime();
+            } catch (ParseException e) {
+                // Do Nothing.
+            }
+        }
+
+        return 0;
+    }
+
+    @Override
+    protected List<String> parseHtmlToPageUrls(String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+
+        List<String> pageUrlList = new ArrayList<>();
+
+        Elements pageUrlElements = parsedDocument.select("select.m").first().select("option:not([value=0])");
+        String baseUrl = parsedDocument.select("div#series a").first().attr("href").replace("1.html", "");
+        int counter = 1;
+        for (Element pageUrlElement : pageUrlElements) {
+            if(counter < pageUrlElements.size()) {
+                pageUrlList.add(baseUrl + pageUrlElement.attr("value") + ".html");
+            }
+            counter++;
+        }
+
+        return pageUrlList;
+    }
+
+    @Override
+    protected String parseHtmlToImageUrl(String unparsedHtml) {
+        Document parsedDocument = Jsoup.parse(unparsedHtml);
+
+        Element imageElement = parsedDocument.getElementById("image");
+        return imageElement.attr("src");
+    }
+}

app/src/main/java/eu/kanade/tachiyomi/data/source/online/english/Mangahere.java

@@ -0,0 +1,313 @@
+package eu.kanade.tachiyomi.data.source.online.english;
+
+import android.content.Context;
+import android.net.Uri;
+
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+import eu.kanade.tachiyomi.data.database.models.Chapter;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.source.SourceManager;
+import eu.kanade.tachiyomi.data.source.base.Source;
+import eu.kanade.tachiyomi.data.source.model.MangasPage;
+import eu.kanade.tachiyomi.util.Parser;
+
+public class Mangahere extends Source {
+
+    public static final String NAME = "Mangahere (EN)";
+    public static final String BASE_URL = "http://www.mangahere.co";
+    public static final String POPULAR_MANGAS_URL = BASE_URL + "/directory/%s";
+    public static final String SEARCH_URL = BASE_URL + "/search.php?name=%s&page=%s";
+
+    public Mangahere(Context context) {
+        super(context);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public int getId() {
+        return SourceManager.MANGAHERE;
+    }
+
+    @Override
+    public String getBaseUrl() {
+        return BASE_URL;
+    }
+
+    @Override
+    protected String getInitialPopularMangasUrl() {
+        return String.format(POPULAR_MANGAS_URL, "");
+    }
+
+    @Override
+    protected String getInitialSearchUrl(String query) {
+        return String.format(SEARCH_URL, Uri.encode(query), 1);
+    }
+
+    @Override
+    public List<Manga> parsePopularMangasFromHtml(Document parsedHtml) {
+        List<Manga> mangaList = new ArrayList<>();
+
+        for (Element currentHtmlBlock : parsedHtml.select("div.directory_list > ul > li")) {
+            Manga currentManga = constructPopularMangaFromHtmlBlock(currentHtmlBlock);
+            mangaList.add(currentManga);
+        }
+        return mangaList;
+    }
+
+    private Manga constructPopularMangaFromHtmlBlock(Element htmlBlock) {
+        Manga manga = new Manga();
+        manga.source = getId();
+
+        Element urlElement = Parser.element(htmlBlock, "div.title > a");
+        if (urlElement != null) {
+            manga.setUrl(urlElement.attr("href"));
+            manga.title = urlElement.attr("title");
+        }
+        return manga;
+    }
+
+    @Override
+    protected String parseNextPopularMangasUrl(Document parsedHtml, MangasPage page) {
+        Element next = Parser.element(parsedHtml, "div.next-page > a.next");
+        return next != null ? String.format(POPULAR_MANGAS_URL, next.attr("href")) : null;
+    }
+
+    @Override
+    protected List<Manga> parseSearchFromHtml(Document parsedHtml) {
+        List<Manga> mangaList = new ArrayList<>();
+
+        Elements mangaHtmlBlocks = parsedHtml.select("div.result_search > dl");
+        for (Element currentHtmlBlock : mangaHtmlBlocks) {
+            Manga currentManga = constructSearchMangaFromHtmlBlock(currentHtmlBlock);
+            mangaList.add(currentManga);
+        }
+        return mangaList;
+    }
+
+    private Manga constructSearchMangaFromHtmlBlock(Element htmlBlock) {
+        Manga manga = new Manga();
+        manga.source = getId();
+
+        Element urlElement = Parser.element(htmlBlock, "a.manga_info");
+        if (urlElement != null) {
+            manga.setUrl(urlElement.attr("href"));
+            manga.title = urlElement.text();
+        }
+        return manga;
+    }
+
+    @Override
+    protected String parseNextSearchUrl(Document parsedHtml, MangasPage page, String query) {
+        Element next = Parser.element(parsedHtml, "div.next-page > a.next");
+        return next != null ? BASE_URL + next.attr("href") : null;
+    }
+
+    private long parseUpdateFromElement(Element updateElement) {
+        String updatedDateAsString = updateElement.text();
+
+        if (updatedDateAsString.contains("Today")) {
+            Calendar today = Calendar.getInstance();
+            today.set(Calendar.HOUR_OF_DAY, 0);
+            today.set(Calendar.MINUTE, 0);
+            today.set(Calendar.SECOND, 0);
+            today.set(Calendar.MILLISECOND, 0);
+
+            try {
+                Date withoutDay = new SimpleDateFormat("MMM d, yyyy h:mma", Locale.ENGLISH).parse(updatedDateAsString.replace("Today", ""));
+                return today.getTimeInMillis() + withoutDay.getTime();
+            } catch (ParseException e) {
+                return today.getTimeInMillis();
+            }
+        } else if (updatedDateAsString.contains("Yesterday")) {
+            Calendar yesterday = Calendar.getInstance();
+            yesterday.add(Calendar.DATE, -1);
+            yesterday.set(Calendar.HOUR_OF_DAY, 0);
+            yesterday.set(Calendar.MINUTE, 0);
+            yesterday.set(Calendar.SECOND, 0);
+            yesterday.set(Calendar.MILLISECOND, 0);
+
+            try {
+                Date withoutDay = new SimpleDateFormat("MMM d, yyyy h:mma", Locale.ENGLISH).parse(updatedDateAsString.replace("Yesterday", ""));
+                return yesterday.getTimeInMillis() + withoutDay.getTime();
+            } catch (ParseException e) {
+                return yesterday.getTimeInMillis();
+            }
+        } else {
+            try {
+                Date specificDate = new SimpleDateFormat("MMM d, yyyy h:mma", Locale.ENGLISH).parse(updatedDateAsString);
+
+                return specificDate.getTime();
+            } catch (ParseException e) {
+                // Do Nothing.
+            }
+        }
+
+        return 0;
+    }
+
+    public Manga parseHtmlToManga(String mangaUrl, String unparsedHtml) {
+        int beginIndex = unparsedHtml.indexOf("<ul class=\"detail_topText\">");
+        int endIndex = unparsedHtml.indexOf("</ul>", beginIndex);
+        String trimmedHtml = unparsedHtml.substring(beginIndex, endIndex);
+
+        Document parsedDocument = Jsoup.parse(trimmedHtml);
+        Element detailElement = parsedDocument.select("ul.detail_topText").first();
+
+        Manga manga = Manga.create(mangaUrl);
+        manga.author = Parser.text(parsedDocument, "a[href^=http://www.mangahere.co/author/]");
+        manga.artist = Parser.text(parsedDocument, "a[href^=http://www.mangahere.co/artist/]");
+
+        String description = Parser.text(detailElement, "#show");
+        if (description != null) {
+            manga.description = description.substring(0, description.length() - "Show less".length());
+        }
+        String genres = Parser.text(detailElement, "li:eq(3)");
+        if (genres != null) {
+            manga.genre = genres.substring("Genre(s):".length());
+        }
+        manga.status = parseStatus(Parser.text(detailElement, "li:eq(6)"));
+
+        beginIndex = unparsedHtml.indexOf("<img");
+        endIndex = unparsedHtml.indexOf("/>", beginIndex);
+        trimmedHtml = unparsedHtml.substring(beginIndex, endIndex + 2);
+
+        parsedDocument = Jsoup.parse(trimmedHtml);
+        manga.thumbnail_url = Parser.src(parsedDocument, "img");
+
+        manga.initialized = true;
+        return manga;
+    }
+
+    private int parseStatus(String status) {
+        if (status.contains("Ongoing")) {
+            return Manga.ONGOING;
+        }
+        if (status.contains("Completed")) {
+            return Manga.COMPLETED;
+        }
+        return Manga.UNKNOWN;
+    }
+
+    @Override
+    public List<Chapter> parseHtmlToChapters(String unparsedHtml) {
+        int beginIndex = unparsedHtml.indexOf("<ul>");
+        int endIndex = unparsedHtml.indexOf("</ul>", beginIndex);
+        String trimmedHtml = unparsedHtml.substring(beginIndex, endIndex);
+
+        Document parsedDocument = Jsoup.parse(trimmedHtml);
+
+        List<Chapter> chapterList = new ArrayList<>();
+
+        for (Element chapterElement : parsedDocument.getElementsByTag("li")) {
+            Chapter currentChapter = constructChapterFromHtmlBlock(chapterElement);
+            chapterList.add(currentChapter);
+        }
+        return chapterList;
+    }
+
+    private Chapter constructChapterFromHtmlBlock(Element chapterElement) {
+        Chapter chapter = Chapter.create();
+
+        Element urlElement = chapterElement.select("a").first();
+        Element dateElement = chapterElement.select("span.right").first();
+
+        if (urlElement != null) {
+            chapter.setUrl(urlElement.attr("href"));
+            chapter.name = urlElement.text();
+        }
+        if (dateElement != null) {
+            chapter.date_upload = parseDateFromElement(dateElement);
+        }
+        return chapter;
+    }
+
+    private long parseDateFromElement(Element dateElement) {
+        String dateAsString = dateElement.text();
+
+        if (dateAsString.contains("Today")) {
+            Calendar today = Calendar.getInstance();
+            today.set(Calendar.HOUR_OF_DAY, 0);
+            today.set(Calendar.MINUTE, 0);
+            today.set(Calendar.SECOND, 0);
+            today.set(Calendar.MILLISECOND, 0);
+
+            try {
+                Date withoutDay = new SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH).parse(dateAsString.replace("Today", ""));
+                return today.getTimeInMillis() + withoutDay.getTime();
+            } catch (ParseException e) {
+                return today.getTimeInMillis();
+            }
+        } else if (dateAsString.contains("Yesterday")) {
+            Calendar yesterday = Calendar.getInstance();
+            yesterday.add(Calendar.DATE, -1);
+            yesterday.set(Calendar.HOUR_OF_DAY, 0);
+            yesterday.set(Calendar.MINUTE, 0);
+            yesterday.set(Calendar.SECOND, 0);
+            yesterday.set(Calendar.MILLISECOND, 0);
+
+            try {
+                Date withoutDay = new SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH).parse(dateAsString.replace("Yesterday", ""));
+                return yesterday.getTimeInMillis() + withoutDay.getTime();
+            } catch (ParseException e) {
+                return yesterday.getTimeInMillis();
+            }
+        } else {
+            try {
+                Date date = new SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH).parse(dateAsString);
+
+                return date.getTime();
+            } catch (ParseException e) {
+                // Do Nothing.
+            }
+        }
+        return 0;
+    }
+
+    @Override
+    public List<String> parseHtmlToPageUrls(String unparsedHtml) {
+        int beginIndex = unparsedHtml.indexOf("<div class=\"go_page clearfix\">");
+        int endIndex = unparsedHtml.indexOf("</div>", beginIndex);
+        String trimmedHtml = unparsedHtml.substring(beginIndex, endIndex);
+
+        Document parsedDocument = Jsoup.parse(trimmedHtml);
+
+        List<String> pageUrlList = new ArrayList<>();
+
+        Elements pageUrlElements = parsedDocument.select("select.wid60").first().getElementsByTag("option");
+        for (Element pageUrlElement : pageUrlElements) {
+            pageUrlList.add(pageUrlElement.attr("value"));
+        }
+
+        return pageUrlList;
+    }
+
+    @Override
+    public String parseHtmlToImageUrl(String unparsedHtml) {
+        int beginIndex = unparsedHtml.indexOf("<section class=\"read_img\" id=\"viewer\">");
+        int endIndex = unparsedHtml.indexOf("</section>", beginIndex);
+        String trimmedHtml = unparsedHtml.substring(beginIndex, endIndex);
+
+        Document parsedDocument = Jsoup.parse(trimmedHtml);
+
+        Element imageElement = parsedDocument.getElementById("image");
+
+        return imageElement.attr("src");
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/sync/LibraryUpdateAlarm.java

@@ -0,0 +1,62 @@
+package eu.kanade.tachiyomi.data.sync;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.SystemClock;
+
+import eu.kanade.tachiyomi.data.preference.PreferencesHelper;
+import timber.log.Timber;
+
+public class LibraryUpdateAlarm extends BroadcastReceiver {
+
+    public static final String LIBRARY_UPDATE_ACTION = "eu.kanade.UPDATE_LIBRARY";
+
+    public static void startAlarm(Context context) {
+        startAlarm(context, PreferencesHelper.getLibraryUpdateInterval(context));
+    }
+
+    public static void startAlarm(Context context, int intervalInHours) {
+        stopAlarm(context);
+        if (intervalInHours == 0)
+            return;
+
+        int intervalInMillis = intervalInHours * 60 * 60 * 1000;
+        long nextRun = SystemClock.elapsedRealtime() + intervalInMillis;
+
+        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+        PendingIntent pendingIntent = getPendingIntent(context);
+        alarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                nextRun, intervalInMillis, pendingIntent);
+
+        Timber.i("Alarm set. Library will update on " + nextRun);
+    }
+
+    public static void stopAlarm(Context context) {
+        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+        PendingIntent pendingIntent = getPendingIntent(context);
+        alarmManager.cancel(pendingIntent);
+    }
+
+    private static PendingIntent getPendingIntent(Context context) {
+        Intent intent = new Intent(context, LibraryUpdateAlarm.class);
+        intent.setAction(LIBRARY_UPDATE_ACTION);
+        return PendingIntent.getBroadcast(context, 0, intent, 0);
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (intent.getAction() == null)
+            return;
+
+        if (intent.getAction().equals(Intent.ACTION_BOOT_COMPLETED)) {
+            startAlarm(context);
+        } else if (intent.getAction().equals(LIBRARY_UPDATE_ACTION)) {
+            LibraryUpdateService.start(context);
+        }
+
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/sync/LibraryUpdateService.java

@@ -0,0 +1,232 @@
+package eu.kanade.tachiyomi.data.sync;
+
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.PowerManager;
+import android.support.v4.app.NotificationCompat;
+import android.util.Pair;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.inject.Inject;
+
+import eu.kanade.tachiyomi.App;
+import eu.kanade.tachiyomi.BuildConfig;
+import eu.kanade.tachiyomi.R;
+import eu.kanade.tachiyomi.data.database.DatabaseHelper;
+import eu.kanade.tachiyomi.data.database.models.Manga;
+import eu.kanade.tachiyomi.data.preference.PreferencesHelper;
+import eu.kanade.tachiyomi.data.source.SourceManager;
+import eu.kanade.tachiyomi.ui.main.MainActivity;
+import eu.kanade.tachiyomi.util.AndroidComponentUtil;
+import eu.kanade.tachiyomi.util.NetworkUtil;
+import rx.Observable;
+import rx.Subscription;
+import rx.schedulers.Schedulers;
+import timber.log.Timber;
+
+public class LibraryUpdateService extends Service {
+
+    @Inject DatabaseHelper db;
+    @Inject SourceManager sourceManager;
+    @Inject PreferencesHelper preferences;
+
+    private PowerManager.WakeLock wakeLock;
+    private Subscription subscription;
+
+    public static final int UPDATE_NOTIFICATION_ID = 1;
+
+    public static void start(Context context) {
+        if (!isRunning(context)) {
+            context.startService(getStartIntent(context));
+        }
+    }
+
+    private static Intent getStartIntent(Context context) {
+        return new Intent(context, LibraryUpdateService.class);
+    }
+
+    private static boolean isRunning(Context context) {
+        return AndroidComponentUtil.isServiceRunning(context, LibraryUpdateService.class);
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        App.get(this).getComponent().inject(this);
+        createAndAcquireWakeLock();
+    }
+
+    @Override
+    public void onDestroy() {
+        if (subscription != null)
+            subscription.unsubscribe();
+        // Reset the alarm
+        LibraryUpdateAlarm.startAlarm(this);
+        destroyWakeLock();
+        super.onDestroy();
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, final int startId) {
+        Timber.i("Starting sync...");
+
+        if (!NetworkUtil.isNetworkConnected(this)) {
+            Timber.i("Sync canceled, connection not available");
+            AndroidComponentUtil.toggleComponent(this, SyncOnConnectionAvailable.class, true);
+            stopSelf(startId);
+            return START_NOT_STICKY;
+        }
+
+        subscription = Observable.fromCallable(() -> db.getFavoriteMangas().executeAsBlocking())
+                .subscribeOn(Schedulers.io())
+                .flatMap(this::updateLibrary)
+                .subscribe(next -> {},
+                        error -> {
+                            showNotification(getString(R.string.notification_update_error), "");
+                            stopSelf(startId);
+                        }, () -> {
+                            Timber.i("Library updated");
+                            stopSelf(startId);
+                        });
+
+        return START_STICKY;
+    }
+
+    private Observable<MangaUpdate> updateLibrary(List<Manga> allLibraryMangas) {
+        final AtomicInteger count = new AtomicInteger(0);
+        final List<MangaUpdate> updates = new ArrayList<>();
+        final List<Manga> failedUpdates = new ArrayList<>();
+
+        final List<Manga> mangas = !preferences.updateOnlyNonCompleted() ? allLibraryMangas :
+            Observable.from(allLibraryMangas)
+                    .filter(manga -> manga.status != Manga.COMPLETED)
+                    .toList().toBlocking().single();
+
+        return Observable.from(mangas)
+                .doOnNext(manga -> showNotification(
+                        getString(R.string.notification_update_progress,
+                                count.incrementAndGet(), mangas.size()), manga.title))
+                .concatMap(manga -> updateManga(manga)
+                        .onErrorReturn(error -> {
+                            failedUpdates.add(manga);
+                            return Pair.create(0, 0);
+                        })
+                        // Filter out mangas without new chapters
+                        .filter(pair -> pair.first > 0)
+                        .map(pair -> new MangaUpdate(manga, pair.first)))
+                .doOnNext(updates::add)
+                .doOnCompleted(() -> showBigNotification(getString(R.string.notification_update_completed),
+                        getUpdatedMangas(updates, failedUpdates)));
+    }
+
+    private Observable<Pair<Integer, Integer>> updateManga(Manga manga) {
+        return sourceManager.get(manga.source)
+                .pullChaptersFromNetwork(manga.url)
+                .flatMap(chapters -> db.insertOrRemoveChapters(manga, chapters));
+    }
+
+    private String getUpdatedMangas(List<MangaUpdate> updates, List<Manga> failedUpdates) {
+        final StringBuilder result = new StringBuilder();
+        if (updates.isEmpty()) {
+            result.append(getString(R.string.notification_no_new_chapters)).append("\n");
+        } else {
+            result.append(getString(R.string.notification_new_chapters));
+
+            for (MangaUpdate update : updates) {
+                result.append("\n").append(update.manga.title);
+            }
+        }
+        if (!failedUpdates.isEmpty()) {
+            result.append("\n");
+            result.append(getString(R.string.notification_manga_update_failed));
+            for (Manga manga : failedUpdates) {
+                result.append("\n").append(manga.title);
+            }
+        }
+
+        return result.toString();
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    private void createAndAcquireWakeLock() {
+        wakeLock = ((PowerManager)getSystemService(POWER_SERVICE)).newWakeLock(
+                PowerManager.PARTIAL_WAKE_LOCK, "LibraryUpdateService:WakeLock");
+        wakeLock.acquire();
+    }
+
+    private void destroyWakeLock() {
+        if (wakeLock != null && wakeLock.isHeld()) {
+            wakeLock.release();
+            wakeLock = null;
+        }
+    }
+
+    private void showNotification(String title, String body) {
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
+                .setSmallIcon(R.drawable.ic_action_refresh)
+                .setContentTitle(title)
+                .setContentText(body);
+
+        NotificationManager notificationManager =
+                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+
+        notificationManager.notify(UPDATE_NOTIFICATION_ID, builder.build());
+    }
+
+    private void showBigNotification(String title, String body) {
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(this)
+                .setSmallIcon(R.drawable.ic_action_refresh)
+                .setContentTitle(title)
+                .setStyle(new NotificationCompat.BigTextStyle().bigText(body))
+                .setContentIntent(getNotificationIntent())
+                .setAutoCancel(true);
+
+        NotificationManager notificationManager =
+                (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+
+        notificationManager.notify(UPDATE_NOTIFICATION_ID, builder.build());
+    }
+
+    private PendingIntent getNotificationIntent() {
+        Intent intent = new Intent(this, MainActivity.class);
+        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+        return PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
+    }
+
+    public static class SyncOnConnectionAvailable extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (NetworkUtil.isNetworkConnected(context)) {
+                if (BuildConfig.DEBUG) {
+                    Timber.i("Connection is now available, triggering sync...");
+                }
+                AndroidComponentUtil.toggleComponent(context, this.getClass(), false);
+                context.startService(getStartIntent(context));
+            }
+        }
+    }
+
+    private static class MangaUpdate {
+        public Manga manga;
+        public int newChapters;
+
+        public MangaUpdate(Manga manga, int newChapters) {
+            this.manga = manga;
+            this.newChapters = newChapters;
+        }
+    }
+
+}

app/src/main/java/eu/kanade/tachiyomi/data/sync/UpdateMangaSyncService.java

@@ -0,0 +1,79 @@
+package eu.kanade.tachiyomi.data.sync;
+
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+
+import javax.inject.Inject;
+
+import eu.kanade.tachiyomi.App;
+import eu.kanade.tachiyomi.data.database.DatabaseHelper;
+import eu.kanade.tachiyomi.data.database.models.MangaSync;
+import eu.kanade.tachiyomi.data.mangasync.MangaSyncManager;
+import eu.kanade.tachiyomi.data.mangasync.base.MangaSyncService;
+import rx.Observable;
+import rx.android.schedulers.AndroidSchedulers;
+import rx.schedulers.Schedulers;
+import rx.subscriptions.CompositeSubscription;
+
+public class UpdateMangaSyncService extends Service {
+
+    @Inject MangaSyncManager syncManager;
+    @Inject DatabaseHelper db;
+
+    private CompositeSubscription subscriptions;
+
+    private static final String EXTRA_MANGASYNC = "extra_mangasync";
+
+    public static void start(Context context, MangaSync mangaSync) {
+        Intent intent = new Intent(context, UpdateMangaSyncService.class);
+        intent.putExtra(EXTRA_MANGASYNC, mangaSync);
+        context.startService(intent);
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        App.get(this).getComponent().inject(this);
+        subscriptions = new CompositeSubscription();
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        MangaSync mangaSync = (MangaSync) intent.getSerializableExtra(EXTRA_MANGASYNC);
+        updateLastChapterRead(mangaSync, startId);
+        return START_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        subscriptions.unsubscribe();
+        super.onDestroy();
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    private void updateLastChapterRead(MangaSync mangaSync, int startId) {
+        MangaSyncService sync = syncManager.getSyncService(mangaSync.sync_id);
+
+        subscriptions.add(Observable.defer(() -> sync.update(mangaSync))
+                .flatMap(response -> {
+                    if (response.isSuccessful()) {
+                        return db.insertMangaSync(mangaSync).createObservable();
+                    }
+                    return Observable.error(new Exception("Could not update MAL"));
+                })
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(result -> {
+                    stopSelf(startId);
+                }, error -> {
+                    stopSelf(startId);
+                }));
+    }
+
+}