Fixed couchbase/couchbase-lite-java-core#1207

### TTL support

Implemented methods for TTL features

Author: hideki

src/main/java/com/couchbase/lite/Database.java

@@ -61,9 +61,10 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
+import java.util.Timer;
+import java.util.TimerTask;
 import java.util.concurrent.CopyOnWriteArraySet;
 import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
@@ -126,6 +127,7 @@ public class Database implements StoreDelegate {
     private boolean postingChangeNotifications;
     private final Object lockPostingChangeNotifications = new Object();
     private final long startTime;
+    private Timer purgeTimer;
 
     /**
      * Each database can have an associated PersistentCookieStore,
@@ -1402,6 +1404,9 @@ public boolean close() {
         // Clear all replicators:
         allReplicators.clear();
 
+        // cancel purge timer
+        cancelPurgeTimer();
+
         // Close Store:
         if (store != null)
             store.close();
@@ -2264,42 +2269,43 @@ private void installAttachment(AttachmentInternal attachment) throws CouchbaseLi
     // #pragma mark - EXPIRATION:
 
     /* package */void setExpirationDate(Date date, String docID) {
-        long timestamp = date != null ? date.getTime() : 0;
-        store.setExpirationOfDocument(timestamp, docID);
+        long unixTime = date != null ? date.getTime() / 1000 : 0;
+        store.setExpirationOfDocument(unixTime, docID);
         scheduleDocumentExpiration(0);
     }
 
     private void scheduleDocumentExpiration(long minimumDelay) {
+        if (store == null) return;
+
         long nextExpiration = store.nextDocumentExpiry();
         if (nextExpiration > 0) {
-            long delay = Math.max(nextExpiration - System.currentTimeMillis() + 1, minimumDelay);
-            Log.v(TAG, "Scheduling next doc expiration in %d sec", delay / 1000);
-            manager.getWorkExecutor().schedule(new Runnable() {
+            long delay = Math.max((nextExpiration - System.currentTimeMillis()) / 1000 + 1, minimumDelay);
+            Log.v(TAG, "Scheduling next doc expiration in %d sec", delay);
+            cancelPurgeTimer();
+            purgeTimer = new Timer();
+            purgeTimer.schedule(new TimerTask() {
                 @Override
                 public void run() {
-                    if(isOpen())
+                    if (isOpen())
                         purgeExpiredDocuments();
                 }
-            }, delay, TimeUnit.MILLISECONDS);
-        } else {
+            }, delay * 1000);
+        } else
             Log.v(TAG, "No pending doc expirations");
-        }
     }
 
     private void purgeExpiredDocuments() {
-        Log.v(TAG, "Purging expired documents...");
+        if (store == null) return;
         int nPurged = store.purgeExpiredDocuments();
         Log.v(TAG, "Purged %d expired documents", nPurged);
         scheduleDocumentExpiration(1);
     }
 
-    private void purgeExpiredDocumentsAsync() {
-        runAsync(new AsyncTask() {
-            @Override
-            public void run(Database database) {
-                purgeExpiredDocuments();
-            }
-        });
+    private void cancelPurgeTimer() {
+        if (purgeTimer != null) {
+            purgeTimer.cancel();
+            purgeTimer = null;
+        }
     }
 
     // #pragma mark - LOOKING UP ATTACHMENTS:

src/main/java/com/couchbase/lite/store/SQLiteStore.java

@@ -1911,18 +1911,21 @@ private boolean purgeSequences(Set<Long> seqsToPurge) {
     // EXPIRATION:
     ///////////////////////////////////////////////////////////////////////////
 
+    /**
+     * @return Java Time
+     */
     @Override
     public long expirationOfDocument(String docID) {
         return SQLiteUtils.longForQuery(storageEngine,
                 "SELECT expiry_timestamp FROM docs WHERE docid=?",
-                new String[]{docID});
+                new String[]{docID}) * 1000L;
     }
 
     @Override
-    public boolean setExpirationOfDocument(long timestamp, String docID) {
+    public boolean setExpirationOfDocument(long unixTime, String docID) {
         try {
             ContentValues values = new ContentValues();
-            values.put("expiry_timestamp", timestamp);
+            values.put("expiry_timestamp", unixTime);
             String[] whereArgs = {docID};
             int rowsUpdated = storageEngine.update("docs", values, "docid=?", whereArgs);
             return rowsUpdated > 0 ? true : false;
@@ -1932,11 +1935,14 @@ public boolean setExpirationOfDocument(long timestamp, String docID) {
         }
     }
 
+    /**
+     * @return Java Time
+     */
     @Override
     public long nextDocumentExpiry() {
         return SQLiteUtils.longForQuery(storageEngine,
                 "SELECT MIN(expiry_timestamp) FROM docs WHERE expiry_timestamp not null and expiry_timestamp != 0",
-                null);
+                null) * 1000L;
     }
 
     @Override
@@ -1948,37 +1954,33 @@ public boolean run() {
                 if (storageEngine == null)
                     return false;
 
-                long now = System.currentTimeMillis();
+                long nowUnixTime = System.currentTimeMillis() / 1000L;
                 invalidateDocNumericIDs();
 
-                String[] args = {String.valueOf(now)};
+                String[] args = {String.valueOf(nowUnixTime)};
 
                 // First capture the docIDs to be purged, so we can notify about them:
                 List<String> purgedIDs = new ArrayList<String>();
-                String queryString = "SELECT docid FROM docs WHERE expiry_timestamp <= ?";
+                String queryString = "SELECT docid FROM docs WHERE expiry_timestamp <= ? and expiry_timestamp != 0";
                 Cursor cursor = storageEngine.rawQuery(queryString, args);
                 try {
-                    if (cursor.moveToNext())
+                    cursor.moveToNext();
+                    while (!cursor.isAfterLast()) {
                         purgedIDs.add(cursor.getString(0));
+                        cursor.moveToNext();
+                    }
                 } finally {
                     cursor.close();
                 }
 
                 // Now delete the docs:
-                for (String docID : purgedIDs) {
-                    String[] arg = {docID};
-                    storageEngine.delete("docs", "docid = ?", arg);
-                }
-                /* NOTE: following codes are more efficient, but sometimes docIDs do not match with
-                         previous query results.
                 try {
-                    int count = storageEngine.delete("docs", "expiry_timestamp <= ?", args);
-                    Log.e(TAG, "purged doc count: %d/%d", count, purgedIDs.size());
+                    int count = storageEngine.delete("docs", "expiry_timestamp <= ? and expiry_timestamp != 0", args);
+                    Log.v(TAG, "purged doc count: %d/%d", count, purgedIDs.size());
                 } catch (SQLException e) {
-                    Log.w(TAG, "Failed to delete from docs expiry_timestamp <= %d", e, now);
+                    Log.w(TAG, "Failed to delete from docs expiry_timestamp <= %d", e, nowUnixTime);
                     return false;
                 }
-                */
 
                 // Finally notify:
                 for (String docID : purgedIDs)
@@ -1991,10 +1993,7 @@ public boolean run() {
         return nPurged.get();
     }
 
-    int i = 0;
-
     private void notifyPurgedDocument(String docID) {
-        Log.e(TAG, "notifyPurgedDocument() [%d] docID=%s", i++, docID);
         delegate.databaseStorageChanged(new DocumentChange(docID));
     }