BookmarkQuery

src/org/geometerplus/android/fbreader/BookmarksActivity.java

@@ -86,25 +86,20 @@ public class BookmarksActivity extends TabActivity implements MenuItem.OnMenuIte
 		public void run() {
 			long id = 0;
 			if (myBook != null) {
-				while (true) {
+				for (BookmarkQuery query = new BookmarkQuery(myBook, 20); ; query = query.next()) {
-					final List<Bookmark> thisBookBookmarks =
+					final List<Bookmark> thisBookBookmarks = myCollection.bookmarks(query);
-						myCollection.bookmarksForBook(myBook, id, 20);
 					if (thisBookBookmarks.isEmpty()) {
 						break;
-					} else {
-						id = thisBookBookmarks.get(thisBookBookmarks.size() - 1).getId() + 1;
 					}
 					myThisBookAdapter.addAll(thisBookBookmarks);
 					myAllBooksAdapter.addAll(thisBookBookmarks);
 				}
 			}
 			id = 0;
-			while (true) {
+			for (BookmarkQuery query = new BookmarkQuery(20); ; query = query.next()) {
-				final List<Bookmark> allBookmarks = myCollection.bookmarks(id, 20);
+				final List<Bookmark> allBookmarks = myCollection.bookmarks(query);
 				if (allBookmarks.isEmpty()) {
 					break;
-				} else {
-					id = allBookmarks.get(allBookmarks.size() - 1).getId() + 1;
 				}
 				myAllBooksAdapter.addAll(allBookmarks);
 			}

src/org/geometerplus/android/fbreader/libraryService/BookCollectionShadow.java

@@ -375,43 +375,19 @@ public class BookCollectionShadow extends AbstractBookCollection implements Serv
 		}
 	}
 
-	public synchronized List<Bookmark> invisibleBookmarks(Book book) {
+	public synchronized List<Bookmark> bookmarks(BookmarkQuery query) {
 		if (myInterface == null) {
 			return Collections.emptyList();
 		}
 		try {
 			return SerializerUtil.deserializeBookmarkList(
-				myInterface.invisibleBookmarks(SerializerUtil.serialize(book))
+				myInterface.bookmarks(SerializerUtil.serialize(query))
 			);
 		} catch (RemoteException e) {
 			return Collections.emptyList();
 		}
 	}
 
-	public synchronized List<Bookmark> bookmarks(long fromId, int limitCount) {
-		if (myInterface == null) {
-			return Collections.emptyList();
-		}
-		try {
-			return SerializerUtil.deserializeBookmarkList(myInterface.bookmarks(fromId, limitCount));
-		} catch (RemoteException e) {
-			return Collections.emptyList();
-		}
-	}
-
-	public synchronized List<Bookmark> bookmarksForBook(Book book, long fromId, int limitCount) {
-		if (myInterface == null) {
-			return Collections.emptyList();
-		}
-		try {
-			return SerializerUtil.deserializeBookmarkList(myInterface.bookmarksForBook(
-				SerializerUtil.serialize(book), fromId, limitCount
-			));
-		} catch (RemoteException e) {
-			return Collections.emptyList();
-		}
-	}
-
 	public synchronized void saveBookmark(Bookmark bookmark) {
 		if (myInterface != null) {
 			try {

src/org/geometerplus/android/fbreader/libraryService/LibraryInterface.aidl

@@ -41,9 +41,7 @@ interface LibraryInterface {
 	boolean isHyperlinkVisited(in String book, in String linkId);
 	void markHyperlinkAsVisited(in String book, in String linkId);
 
-	List<String> invisibleBookmarks(in String book);
+	List<String> bookmarks(in String query);
-	List<String> bookmarks(in long fromId, in int limitCount);
-	List<String> bookmarksForBook(in String book, in long fromId, in int limitCount);
 	String saveBookmark(in String bookmark);
 	void deleteBookmark(in String bookmark);
 }

src/org/geometerplus/android/fbreader/libraryService/LibraryService.java

@@ -246,19 +246,9 @@ public class LibraryService extends Service {
 			myCollection.markHyperlinkAsVisited(SerializerUtil.deserializeBook(book), linkId);
 		}
 
-		public List<String> invisibleBookmarks(String book) {
+		public List<String> bookmarks(String query) {
-			return SerializerUtil.serializeBookmarkList(
+			return SerializerUtil.serializeBookmarkList(myCollection.bookmarks(
-				myCollection.invisibleBookmarks(SerializerUtil.deserializeBook(book))
+				SerializerUtil.deserializeBookmarkQuery(query)
-			);
-		}
-
-		public List<String> bookmarks(long fromId, int limitCount) {
-			return SerializerUtil.serializeBookmarkList(myCollection.bookmarks(fromId, limitCount));
-		}
-
-		public List<String> bookmarksForBook(String book, long fromId, int limitCount) {
-			return SerializerUtil.serializeBookmarkList(myCollection.bookmarksForBook(
-				SerializerUtil.deserializeBook(book), fromId, limitCount
 			));
 		}
 

src/org/geometerplus/android/fbreader/libraryService/SQLiteBooksDatabase.java

@@ -782,77 +782,22 @@ final class SQLiteBooksDatabase extends BooksDatabase {
 	}
 
 	@Override
-	protected List<Bookmark> loadInvisibleBookmarks(long bookId) {
+	protected List<Bookmark> loadBookmarks(BookmarkQuery query) {
-		LinkedList<Bookmark> list = new LinkedList<Bookmark>();
+		final LinkedList<Bookmark> list = new LinkedList<Bookmark>();
-		Cursor cursor = myDatabase.rawQuery(
+		final StringBuilder sql = new StringBuilder("SELECT")
-			"SELECT bm.bookmark_id,bm.book_id,b.title,bm.bookmark_text,bm.creation_time,bm.modification_time,bm.access_time,bm.access_counter,bm.model_id,bm.paragraph,bm.word,bm.char FROM Bookmarks AS bm INNER JOIN Books AS b ON b.book_id = bm.book_id WHERE bm.book_id = ? AND bm.visible = 0", new String[] { String.valueOf(bookId) }
+			.append(" bm.bookmark_id,bm.book_id,b.title,bm.bookmark_text,")
-		);
+			.append("bm.creation_time,bm.modification_time,bm.access_time,bm.access_counter,")
-		while (cursor.moveToNext()) {
+			.append("bm.model_id,bm.paragraph,bm.word,bm.char")
-			list.add(createBookmark(
+			.append(" FROM Bookmarks AS bm INNER JOIN Books AS b ON b.book_id = bm.book_id")
-				cursor.getLong(0),
+			.append(" WHERE");
-				cursor.getLong(1),
+		if (query.Book != null) {
-				cursor.getString(2),
+			sql.append(" b.book_id = " + query.Book.getId() +" AND");
-				cursor.getString(3),
-				SQLiteUtil.getDate(cursor, 4),
-				SQLiteUtil.getDate(cursor, 5),
-				SQLiteUtil.getDate(cursor, 6),
-				(int)cursor.getLong(7),
-				cursor.getString(8),
-				(int)cursor.getLong(9),
-				(int)cursor.getLong(10),
-				(int)cursor.getLong(11),
-				false
-			));
 		}
-		cursor.close();
+		sql
-		return list;
+			.append(" bm.visible = " + (query.Visible ? 1 : 0))
-	}
+			.append(" ORDER BY bm.bookmark_id")
-
+			.append(" LIMIT " + query.Limit * query.Page + "," + query.Limit);
-	@Override
+		Cursor cursor = myDatabase.rawQuery(sql.toString(), null);
-	protected List<Bookmark> loadVisibleBookmarks(long fromId, int limitCount) {
-		LinkedList<Bookmark> list = new LinkedList<Bookmark>();
-		Cursor cursor = myDatabase.rawQuery("SELECT" +
-			" bm.bookmark_id,bm.book_id,b.title,bm.bookmark_text," +
-			"bm.creation_time,bm.modification_time,bm.access_time,bm.access_counter," +
-			"bm.model_id,bm.paragraph,bm.word,bm.char" +
-			" FROM Bookmarks AS bm INNER JOIN Books AS b ON b.book_id = bm.book_id" +
-			" WHERE bm.bookmark_id >= ? AND bm.visible = 1 ORDER BY bm.bookmark_id LIMIT ?",
-			new String[] { String.valueOf(fromId), String.valueOf(limitCount) }
-		);
-		while (cursor.moveToNext()) {
-			list.add(createBookmark(
-				cursor.getLong(0),
-				cursor.getLong(1),
-				cursor.getString(2),
-				cursor.getString(3),
-				SQLiteUtil.getDate(cursor, 4),
-				SQLiteUtil.getDate(cursor, 5),
-				SQLiteUtil.getDate(cursor, 6),
-				(int)cursor.getLong(7),
-				cursor.getString(8),
-				(int)cursor.getLong(9),
-				(int)cursor.getLong(10),
-				(int)cursor.getLong(11),
-				true
-			));
-		}
-		cursor.close();
-		return list;
-	}
-
-
-	@Override
-	protected List<Bookmark> loadVisibleBookmarks(long bookId, long fromId, int limitCount) {
-		LinkedList<Bookmark> list = new LinkedList<Bookmark>();
-		Cursor cursor = myDatabase.rawQuery("SELECT" +
-			" bm.bookmark_id,bm.book_id,b.title,bm.bookmark_text," +
-			"bm.creation_time,bm.modification_time,bm.access_time,bm.access_counter," +
-			"bm.model_id,bm.paragraph,bm.word,bm.char" +
-			" FROM Bookmarks AS bm INNER JOIN Books AS b ON b.book_id = bm.book_id" +
-			" WHERE b.book_id = ? AND bm.bookmark_id >= ? AND bm.visible = 1" +
-			" ORDER BY bm.bookmark_id LIMIT ?",
-			new String[] { String.valueOf(bookId), String.valueOf(fromId), String.valueOf(limitCount) }
-		);
 		while (cursor.moveToNext()) {
 			list.add(createBookmark(
 				cursor.getLong(0),

src/org/geometerplus/fbreader/book/AbstractSerializer.java

@@ -23,6 +23,9 @@ abstract class AbstractSerializer {
 	public abstract String serialize(BookQuery query);
 	public abstract BookQuery deserializeBookQuery(String data);
 
+	public abstract String serialize(BookmarkQuery query);
+	public abstract BookmarkQuery deserializeBookmarkQuery(String data);
+
 	public abstract String serialize(Book book);
 	public abstract Book deserializeBook(String data);
 

src/org/geometerplus/fbreader/book/BookCollection.java

@@ -605,18 +605,8 @@ public class BookCollection extends AbstractBookCollection {
 		}
 	}
 
-	public List<Bookmark> bookmarks(long fromId, int limitCount) {
+	public List<Bookmark> bookmarks(BookmarkQuery query) {
-		return myDatabase.loadVisibleBookmarks(fromId, limitCount);
+		return myDatabase.loadBookmarks(query);
-	}
-
-	public List<Bookmark> bookmarksForBook(Book book, long fromId, int limitCount) {
-		return myDatabase.loadVisibleBookmarks(book.getId(), fromId, limitCount);
-	}
-
-	public List<Bookmark> invisibleBookmarks(Book book) {
-		final List<Bookmark> list = myDatabase.loadInvisibleBookmarks(book.getId());
-		Collections.sort(list, new Bookmark.ByTimeComparator());
-		return list;
 	}
 
 	public void saveBookmark(Bookmark bookmark) {

src/org/geometerplus/fbreader/book/BookQuery.java

@@ -19,7 +19,7 @@
 
 package org.geometerplus.fbreader.book;
 
-public class BookQuery {
+public final class BookQuery {
 	public final Filter Filter;
 	public final int Limit;
 	public final int Page;

src/org/geometerplus/fbreader/book/BookmarkQuery.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2007-2013 Geometer Plus <contact@geometerplus.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+package org.geometerplus.fbreader.book;
+
+public final class BookmarkQuery {
+	public final Book Book;
+	public final boolean Visible;
+	public final int Limit;
+	public final int Page;
+
+	public BookmarkQuery(int limit) {
+		this(null, limit);
+	}
+
+	public BookmarkQuery(Book book, int limit) {
+		this(book, true, limit);
+	}
+
+	public BookmarkQuery(Book book, boolean visible, int limit) {
+		this(book, visible, limit, 0);
+	}
+
+	BookmarkQuery(Book book, boolean visible, int limit, int page) {
+		Book = book;
+		Visible = visible;
+		Limit = limit;
+		Page = page;
+	}
+
+	public BookmarkQuery next() {
+		return new BookmarkQuery(Book, Visible, Limit, Page + 1);
+	}
+}

src/org/geometerplus/fbreader/book/BooksDatabase.java

@@ -89,9 +89,7 @@ public abstract class BooksDatabase {
 		return new Bookmark(id, bookId, bookTitle, text, creationDate, modificationDate, accessDate, accessCounter, modelId, paragraphIndex, wordIndex, charIndex, isVisible);
 	}
 
-	protected abstract List<Bookmark> loadInvisibleBookmarks(long bookId);
+	protected abstract List<Bookmark> loadBookmarks(BookmarkQuery query);
-	protected abstract List<Bookmark> loadVisibleBookmarks(long fromId, int limitCount);
-	protected abstract List<Bookmark> loadVisibleBookmarks(long bookId, long fromId, int limitCount);
 	protected abstract long saveBookmark(Bookmark bookmark);
 	protected abstract void deleteBookmark(Bookmark bookmark);
 

src/org/geometerplus/fbreader/book/IBookCollection.java

@@ -79,9 +79,7 @@ public interface IBookCollection {
 	boolean isHyperlinkVisited(Book book, String linkId);
 	void markHyperlinkAsVisited(Book book, String linkId);
 
-	List<Bookmark> bookmarks(long fromId, int limitCount);
+	List<Bookmark> bookmarks(BookmarkQuery query);
-	List<Bookmark> bookmarksForBook(Book book, long fromId, int limitCount);
-	List<Bookmark> invisibleBookmarks(Book book);
 	void saveBookmark(Bookmark bookmark);
 	void deleteBookmark(Bookmark bookmark);
 }

src/org/geometerplus/fbreader/book/SerializerUtil.java

@@ -35,6 +35,14 @@ public abstract class SerializerUtil {
 		return xml != null ? defaultSerializer.deserializeBookQuery(xml) : null;
 	}
 
+	public static String serialize(BookmarkQuery query) {
+		return query != null ? defaultSerializer.serialize(query) : null;
+	}
+
+	public static BookmarkQuery deserializeBookmarkQuery(String xml) {
+		return xml != null ? defaultSerializer.deserializeBookmarkQuery(xml) : null;
+	}
+
 	public static String serialize(Book book) {
 		return book != null ? defaultSerializer.serialize(book) : null;
 	}

src/org/geometerplus/fbreader/book/XMLSerializer.java

@@ -123,9 +123,42 @@ class XMLSerializer extends AbstractSerializer {
 		}
 	}
 
+	@Override
+	public String serialize(BookmarkQuery query) {
+		final StringBuilder buffer = new StringBuilder();
+		appendTag(buffer, "query", false,
+			"visible", String.valueOf(query.Visible),
+			"limit", String.valueOf(query.Limit),
+			"page", String.valueOf(query.Page)
+		);
+		if (query.Book != null) {
+			serialize(buffer, query.Book);
+		}
+		closeTag(buffer, "query");
+		return buffer.toString();
+	}
+
+	@Override
+	public BookmarkQuery deserializeBookmarkQuery(String xml) {
+		try {
+			final BookmarkQueryDeserializer deserializer = new BookmarkQueryDeserializer();
+			Xml.parse(xml, deserializer);
+			return deserializer.getQuery();
+		} catch (SAXException e) {
+			System.err.println(xml);
+			e.printStackTrace();
+			return null;
+		}
+	}
+
 	@Override
 	public String serialize(Book book) {
 		final StringBuilder buffer = new StringBuilder();
+		serialize(buffer, book);
+		return buffer.toString();
+	}
+
+	private void serialize(StringBuilder buffer, Book book) {
 		appendTag(
 			buffer, "entry", false,
 			"xmlns:dc", XMLNamespaces.DublinCore,
@@ -187,7 +220,6 @@ class XMLSerializer extends AbstractSerializer {
 		);
 
 		closeTag(buffer, "entry");
-		return buffer.toString();
 	}
 
 	@Override
@@ -571,7 +603,7 @@ class XMLSerializer extends AbstractSerializer {
 						myLimit = Integer.parseInt(attributes.getValue("limit"));
 						myPage = Integer.parseInt(attributes.getValue("page"));
 					} catch (Exception e) {
-						throw new SAXException("XML parsing error");
+						throw new SAXException("XML parsing error", e);
 					}
 					myStateStack.add(State.READ_QUERY);
 				} else {
@@ -649,6 +681,57 @@ class XMLSerializer extends AbstractSerializer {
 		}
 	}
 
+	private static final class BookmarkQueryDeserializer extends DefaultHandler {
+		private boolean myVisible;
+		private int myLimit;
+		private int myPage;
+		private final BookDeserializer myBookDeserializer = new BookDeserializer();
+		private BookmarkQuery myQuery;
+
+		BookmarkQuery getQuery() {
+			return myQuery;
+		}
+
+		@Override
+		public void startDocument() {
+			myQuery = null;
+			myBookDeserializer.startDocument();
+		}
+
+		@Override
+		public void endDocument() {
+			myBookDeserializer.endDocument();
+			myQuery = new BookmarkQuery(myBookDeserializer.getBook(), myVisible, myLimit, myPage);
+		}
+
+		@Override
+		public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
+			if ("query".equals(localName)) {
+				try {
+					myVisible = Boolean.parseBoolean(attributes.getValue("visible"));
+					myLimit = Integer.parseInt(attributes.getValue("limit"));
+					myPage = Integer.parseInt(attributes.getValue("page"));
+				} catch (Exception e) {
+					throw new SAXException("XML parsing error", e);
+				}
+			} else {
+				myBookDeserializer.startElement(uri, localName, qName, attributes);
+			}
+		}
+
+		@Override
+		public void endElement(String uri, String localName, String qName) throws SAXException {
+			if (!"query".equals(localName)) {
+				myBookDeserializer.endElement(uri, localName, qName);
+			}
+		}
+
+		@Override
+		public void characters(char[] ch, int start, int length) {
+			myBookDeserializer.characters(ch, start, length);
+		}
+	}
+
 	private static final class BookmarkDeserializer extends DefaultHandler {
 		private static enum State {
 			READ_NOTHING,

src/org/geometerplus/fbreader/fbreader/FBReaderApp.java

@@ -285,6 +285,14 @@ public final class FBReaderApp extends ZLApplication {
 		getViewWidget().repaint();
 	}
 
+	private List<Bookmark> invisibleBookmarks() {
+		final List<Bookmark> bookmarks = Collection.bookmarks(
+			new BookmarkQuery(Model.Book, false, 10)
+		);
+		Collections.sort(bookmarks, new Bookmark.ByTimeComparator());
+		return bookmarks;
+	}
+
 	public boolean jumpBack() {
 		try {
 			if (getTextView() != BookTextView) {
@@ -303,7 +311,7 @@ public final class FBReaderApp extends ZLApplication {
 				return false;
 			}
 
-			final List<Bookmark> bookmarks = Collection.invisibleBookmarks(Model.Book);
+			final List<Bookmark> bookmarks = invisibleBookmarks();
 			if (bookmarks.isEmpty()) {
 				return false;
 			}
@@ -400,7 +408,7 @@ public final class FBReaderApp extends ZLApplication {
 		}
 		if (ShowPositionsInCancelMenuOption.getValue()) {
 			if (Model != null && Model.Book != null) {
-				for (Bookmark bookmark : Collection.invisibleBookmarks(Model.Book)) {
+				for (Bookmark bookmark : invisibleBookmarks()) {
 					myCancelActionsList.add(new BookmarkDescription(bookmark));
 				}
 			}
@@ -442,13 +450,13 @@ public final class FBReaderApp extends ZLApplication {
 
 	private synchronized void updateInvisibleBookmarksList(Bookmark b) {
 		if (Model != null && Model.Book != null && b != null) {
-			for (Bookmark bm : Collection.invisibleBookmarks(Model.Book)) {
+			for (Bookmark bm : invisibleBookmarks()) {
 				if (b.equals(bm)) {
 					Collection.deleteBookmark(bm);
 				}
 			}
 			Collection.saveBookmark(b);
-			final List<Bookmark> bookmarks = Collection.invisibleBookmarks(Model.Book);
+			final List<Bookmark> bookmarks = invisibleBookmarks();
 			for (int i = 3; i < bookmarks.size(); ++i) {
 				Collection.deleteBookmark(bookmarks.get(i));
 			}