Made Realm.compactRealmFile() more failure resilient.

changelog.txt

@@ -1,3 +1,6 @@
+0.81
+ * Realm.compactRealmFile() now also works for encrypted Realms.
+
 0.80
 * Queries on relationships can be case sensitive.
 * Fixed bug when importing JSONObjects containing NULL values.

realm-jni/src/io_realm_internal_SharedGroup.cpp

@@ -268,3 +268,14 @@ JNIEXPORT jstring JNICALL Java_io_realm_internal_SharedGroup_nativeGetDefaultRep
     return 0;
 #endif
 }
+
+JNIEXPORT jboolean JNICALL Java_io_realm_internal_SharedGroup_nativeCompact(
+    JNIEnv* env, jobject, jlong native_ptr)
+{
+    TR_ENTER_PTR(native_ptr)
+    try {
+        return SG(native_ptr)->compact(); // throws
+    }
+    CATCH_STD()
+    return false;
+}

realm/src/androidTest/java/io/realm/RealmTest.java

@@ -917,11 +917,32 @@ public void testWriteCopyTo() throws IOException {
         }
     }
 
+
+    public void testCompactRealmFileThrowsIfOpen() throws IOException {
+        try {
+            Realm.compactRealmFile(getContext());
+        } catch (IllegalStateException expected) {
+            return;
+        }
+        fail();
+    }
+
+    public void testCompactEncryptedRealmFile() {
+        String REALM_NAME = "enc.realm";
+        Realm.deleteRealmFile(getContext(), REALM_NAME);
+        byte[] key = new byte[64];
+        new Random(42).nextBytes(key);
+        Realm realm = Realm.getInstance(getContext(), REALM_NAME, key);
+        realm.close();
+        assertTrue(Realm.compactRealmFile(getContext(), REALM_NAME, key));
+    }
+
     public void testCompactRealmFile() throws IOException {
         final String copyRealm = "copy.realm";
         fileCopy(
-                new File(getContext().getFilesDir(), Realm.DEFAULT_REALM_NAME),
-                new File(getContext().getFilesDir(), copyRealm));
+            new File(getContext().getFilesDir(), Realm.DEFAULT_REALM_NAME),
+            new File(getContext().getFilesDir(), copyRealm)
+        );
         long before = new File(getContext().getFilesDir(), copyRealm).length();
         assertTrue(Realm.compactRealmFile(getContext()));
         long after = new File(getContext().getFilesDir(), copyRealm).length();

realm/src/main/java/io/realm/Realm.java

@@ -24,7 +24,6 @@
 import android.os.Looper;
 import android.os.Message;
 import android.util.JsonReader;
-import android.util.Log;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -1699,7 +1698,7 @@ public static synchronized boolean deleteRealmFile(Context context, String fileN
                 boolean deleteResult = fileToDelete.delete();
                 if (!deleteResult) {
                     result = false;
-                    Log.w(TAG, "Could not delete the file " + fileToDelete);
+                    RealmLog.w("Could not delete the file " + fileToDelete);
                 }
             }
         }
@@ -1717,32 +1716,28 @@ public static synchronized boolean deleteRealmFile(Context context, String fileN
      *
      * @param context an Android {@link android.content.Context}
      * @param fileName the name of the file to compact
+     * @param key Key for opening a encrypted Realm.
      * @return true if successful, false if any file operation failed
+     *
+     * @throws IllegalStateException if trying to compact a Realm that is already open
      */
-    public static synchronized boolean compactRealmFile(Context context, String fileName) {
+    public static synchronized boolean compactRealmFile(Context context, String fileName, byte[] key) {
         File realmFile = new File(context.getFilesDir(), fileName);
-        File tmpFile = new File(
-                context.getFilesDir(),
-                String.valueOf(System.currentTimeMillis()) + UUID.randomUUID() + ".realm");
-
-        Realm realm = null;
+        String path = realmFile.getAbsolutePath();
+        if (openRealms.get(path.hashCode()).get() > 0) {
+            throw new IllegalStateException("Cannot compact a open Realm");
+        }
+        SharedGroup sharedGroup = null;
+        boolean result = false;
         try {
-            realm = Realm.getInstance(context, fileName);
-            realm.writeCopyTo(tmpFile);
-            if (!realmFile.delete()) {
-                return false;
-            }
-            if (!tmpFile.renameTo(realmFile)) {
-                return false;
-            }
-        } catch (IOException e) {
-            return false;
+            sharedGroup = new SharedGroup(path, false, key);
+            result = sharedGroup.compact();
         } finally {
-            if (realm != null) {
-                realm.close();
+            if (sharedGroup != null) {
+                sharedGroup.close();
             }
         }
-        return true;
+        return result;
     }
 
     /**
@@ -1756,9 +1751,30 @@ public static synchronized boolean compactRealmFile(Context context, String file
      *
      * @param context an Android {@link android.content.Context}
      * @return true if successful, false if any file operation failed
+     *
+     * @throws IllegalStateException if trying to compact a Realm that is already open
      */
     public static boolean compactRealmFile(Context context) {
-        return compactRealmFile(context, DEFAULT_REALM_NAME);
+        return compactRealmFile(context, DEFAULT_REALM_NAME, null);
+    }
+
+    /**
+     * Compact a realm file. A realm file usually contain free/unused space.
+     * This method removes this free space and the file size is thereby reduced.
+     * Objects within the realm files are untouched.
+     * <p>
+     * The file must be closed before this method is called.<br>
+     * The file system should have free space for at least a copy of the realm file.<br>
+     * The realm file is left untouched if any file operation fails.<br>
+     *
+     * @param context an Android {@link android.content.Context}
+     * @param fileName the name of the file to compact
+     * @return true if successful, false if any file operation failed
+     *
+     * @throws IllegalStateException if trying to compact a Realm that is already open
+     */
+    public static synchronized boolean compactRealmFile(Context context, String fileName) {
+        return compactRealmFile(context, fileName, null);
     }
 
     /**

realm/src/main/java/io/realm/internal/SharedGroup.java

@@ -223,6 +223,16 @@ public void reserve(long bytes) {
         nativeReserve(nativePtr, bytes);
     }
 
+    /**
+     * Compacts a shared group. This will block access to the shared group until done.
+     *
+     * @return True if compaction succeded, false otherwise.
+     * @throws RuntimeException if using this within either a read or or write transaction.
+     */
+    public boolean compact() {
+        return nativeCompact(nativePtr);
+    }
+
     private native void nativeReserve(long nativePtr, long bytes);
 
     private native boolean nativeHasChanged(long nativePtr);
@@ -243,6 +253,8 @@ private native long nativeCreate(String databaseFile,
                                      boolean enableReplication,
                                      byte[] key);
 
+    private native boolean nativeCompact(long nativePtr);
+
     private void checkNativePtrNotZero() {
         if (this.nativePtr == 0) {
             throw new IOError(new RealmIOException("Realm could not be opened"));