Fix notifications on Linux 5.5 and above (#7488)

cmelchior · web-flow · commit 6eb3de8d7128 · 2021-06-04T10:50:05.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,22 @@
+## 10.5.1 (YYYY-MM-DD)
+
+### Enhancements
+* None.
+
+### Fixes
+* [RealmApp] Errors related to "uncaught exception in notifier thread: N5realm11KeyNotFoundE: No such object". This could happen in a sync'd app when a linked object was deleted by another client.
+* Notifications now trigger correctly on Linux kernel 5.5 and above. So far this only impacted the preview emulator image for Android 12. (Issue[#7321](https://github.com/realm/realm-java/issues/7321))  
+
+
+### Compatibility
+* File format: Generates Realms with format v20. Unsynced Realms will be upgraded from Realm Java 2.0 and later. Synced Realms can only be read and upgraded if created with Realm Java v10.0.0-BETA.1.
+* APIs are backwards compatible with all previous release of realm-java in the 10.x.y series.
+* Realm Studio 10.0.0 or above is required to open Realms created by this version.
+
+### Internal
+* Updated to Realm Core 10.7.2, commit ae14e6be382a72a9252d4e6710c2710c1ea4e688.
+
+
 ## 10.5.0 (2021-05-07)
 
 ### Breaking Changes
diff --git a/realm/realm-library/src/androidTest/java/io/realm/RealmInterprocessTest.java b/realm/realm-library/src/androidTest/java/io/realm/RealmInterprocessTest.java
@@ -30,22 +30,25 @@
 import android.os.Messenger;
 import android.os.RemoteException;
 import androidx.test.platform.app.InstrumentationRegistry;
-import androidx.test.annotation.UiThreadTest;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import io.realm.entities.AllTypes;
 import io.realm.entities.AllTypesModelModule;
+import io.realm.log.RealmLog;
+import io.realm.rule.BlockingLooperThread;
 import io.realm.services.RemoteProcessService;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -64,7 +67,6 @@
 //      1. Open two Realms
 //      B. Open three Realms
 //      2. assertTrue("OK, remote process win. You can open more Realms than I do in the main local process", false);
-@Ignore // FIXME Needs to be upgraded to support JUnit4: https://github.com/realm/realm-java/issues/6452
 @RunWith(AndroidJUnit4.class)
 public class RealmInterprocessTest {
 
@@ -76,7 +78,9 @@ public class RealmInterprocessTest {
         @Override
         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
             remoteMessenger = new Messenger(iBinder);
-            serviceStartLatch.countDown();
+            if (serviceStartLatch != null) {
+                serviceStartLatch.countDown();
+            }
         }
 
         @Override
@@ -88,45 +92,14 @@ public void onServiceDisconnected(ComponentName componentName) {
         }
     };
 
-    // It is necessary to overload this method.
-    // AndroidTestRunner does call Looper.prepare() and we can have a looper in the case. The problem is all the test
-    // cases are running in a single thread!!! And after Looper.quit() called, it cannot start again. That means we
-    // can only have one case in this class LoL.
-    // By overloading this method, we create a new thread and looper to run the real case. And use latch to wait until
-    // it is finished. Then we can get rid of creating the thread in the test method, using array to store exception, many
-    // levels of nested code. Make the test case more nature.
-//    @Override
-//    public void runBare() throws Throwable {
-//        final Throwable[] throwableArray = new Throwable[1];
-//        final CountDownLatch latch = new CountDownLatch(1);
-//        Thread thread = new Thread(new Runnable() {
-//            @Override
-//            public void run() {
-//                Looper.prepare();
-//                try {
-//                    RealmInterprocessTest.super.runBare();
-//                } catch (Throwable throwable) {
-//                    throwableArray[0] = throwable;
-//                } finally {
-//                    latch.countDown();
-//                }
-//            }
-//        });
-//
-//        thread.start();
-//        TestHelper.awaitOrFail(latch);
-//
-//        if (throwableArray[0] != null) {
-//            throw throwableArray[0];
-//        }
-//    }
+    BlockingLooperThread looperThread = new BlockingLooperThread();
 
     // Helper handler to make it easy to interact with remote service process.
     @SuppressLint("HandlerLeak") // SuppressLint bug, doesn't work
     private class InterprocessHandler extends Handler {
         // Timeout Watchdog. In case the service crashed or expected response is not returned.
         // It is very important to feed the dog after the expected message arrived.
-        private final static int timeout = 5000;
+        private final static int timeout = 10_000;
         private volatile boolean isTimeout = true;
         private Runnable timeoutRunnable = new Runnable() {
             @Override
@@ -170,6 +143,7 @@ public void handleMessage(Message msg) {
 
     @Before
     public void setUp() throws Exception {
+        Realm.init(InstrumentationRegistry.getInstrumentation().getTargetContext());
         Realm.deleteRealm(getConfiguration());
 
         // Starts the testing service.
@@ -186,10 +160,6 @@ private RealmConfiguration getConfiguration() {
     @After
     public void tearDown() throws Exception {
         int counter = 10;
-        if (testRealm != null) {
-            testRealm.close();
-        }
-
         getContext().unbindService(serviceConnection);
         remoteMessenger = null;
 
@@ -253,81 +223,139 @@ private ActivityManager.RunningAppProcessInfo getRemoteProcessInfo() {
     // A. Opens a realm, closes it, then calls Runtime.getRuntime().exit(0).
     // 1. Waits 3 seconds to see if the service process existed.
     @Test
-    @UiThreadTest
     public void exitProcess() {
-        new InterprocessHandler(new Runnable() {
+        looperThread.runBlocking("testThread", true, new Function0<Unit>() {
             @Override
-            public void run() {
-                // Step A
-                triggerServiceStep(RemoteProcessService.stepExitProcess_A);
-            }
-        }) {
-
-            @SuppressWarnings("ConstantConditions")
-            final int servicePid = getServiceInfo().pid;
-
-            @Override
-            public void handleMessage(Message msg) {
-                super.handleMessage(msg);
-                if (msg.what == RemoteProcessService.stepExitProcess_A.message) {
-                    // Step 1
-                    clearTimeoutFlag();
-                    try {
-                        // Timeout is 5 seconds. 3 (6x500ms) seconds should be enough to quit the process.
-                        for (int i = 1; i <= 6; i++) {
-                            // We need to retrieve the service's pid again since the system might restart it automatically.
-                            ActivityManager.RunningAppProcessInfo processInfo = getRemoteProcessInfo();
-                            if (processInfo != null && processInfo.pid == servicePid && i >= 6) {
-                                // The process is still alive.
-                                fail("Process is still alive");
-                            } else if (processInfo == null || processInfo.pid != servicePid) {
-                                // The process is gone.
-                                break;
+            public Unit invoke() {
+                new InterprocessHandler(new Runnable() {
+                    @Override
+                    public void run() {
+                        // Step A
+                        triggerServiceStep(RemoteProcessService.stepExitProcess_A);
+                    }
+                }) {
+
+                    @SuppressWarnings("ConstantConditions")
+                    final int servicePid = getServiceInfo().pid;
+
+                    @Override
+                    public void handleMessage(Message msg) {
+                        super.handleMessage(msg);
+                        if (msg.what == RemoteProcessService.stepExitProcess_A.message) {
+                            // Step 1
+                            clearTimeoutFlag();
+                            try {
+                                // Timeout is 5 seconds. 3 (6x500ms) seconds should be enough to quit the process.
+                                for (int i = 1; i <= 6; i++) {
+                                    // We need to retrieve the service's pid again since the system might restart it automatically.
+                                    ActivityManager.RunningAppProcessInfo processInfo = getRemoteProcessInfo();
+                                    if (processInfo != null && processInfo.pid == servicePid && i >= 6) {
+                                        // The process is still alive.
+                                        fail("Process is still alive");
+                                    } else if (processInfo == null || processInfo.pid != servicePid) {
+                                        // The process is gone.
+                                        break;
+                                    }
+                                    Thread.sleep(500);
+                                }
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                                assertTrue(false);
                             }
-                            Thread.sleep(500);
+                            looperThread.testComplete();
                         }
-                    } catch (InterruptedException e) {
-                        e.printStackTrace();
-                        assertTrue(false);
                     }
-                    done();
-                }
+                };
+                return Unit.INSTANCE;
             }
-        };
-        Looper.loop();
+        });
     }
 
     // 1. Main process creates Realm, write one object.
     // A. Service process opens Realm, check if there is one and only one object.
     @Test
-    @UiThreadTest
     public void createInitialRealm() throws InterruptedException {
-        new InterprocessHandler(new Runnable() {
+        looperThread.runBlocking("testThread", true, new Function0<Unit>() {
             @Override
-            public void run() {
-                // Step 1
-                testRealm = Realm.getInstance(getConfiguration());
-                assertEquals(0, testRealm.where(AllTypes.class).count());
-                testRealm.beginTransaction();
-                testRealm.createObject(AllTypes.class);
-                testRealm.commitTransaction();
-
-                // Step A
-                triggerServiceStep(RemoteProcessService.stepCreateInitialRealm_A);
+            public Unit invoke() {
+                new InterprocessHandler(new Runnable() {
+                    @Override
+                    public void run() {
+                        // Step 1
+                        testRealm = Realm.getInstance(getConfiguration());
+                        looperThread.closeAfterTest(testRealm);
+                        assertEquals(0, testRealm.where(AllTypes.class).count());
+                        testRealm.beginTransaction();
+                        testRealm.createObject(AllTypes.class);
+                        testRealm.commitTransaction();
+
+                        // Step A
+                        triggerServiceStep(RemoteProcessService.stepCreateInitialRealm_A);
+                    }
+                }) {
+
+                    @Override
+                    public void handleMessage(Message msg) {
+                        super.handleMessage(msg);
+                        if (msg.what == RemoteProcessService.stepCreateInitialRealm_A.message) {
+                            clearTimeoutFlag();
+                            looperThread.testComplete();
+                        } else {
+                            assertTrue(false);
+                        }
+                    }
+                };
+                return Unit.INSTANCE;
             }
-        }) {
+        });
+    }
+
+    @Test
+    public void interprocessNotifications() {
+        looperThread.runBlocking("testThread", true, new Function0<Unit>() {
+            private RealmResults<AllTypes> results;
+            private AtomicInteger updateCount = new AtomicInteger(0);
 
             @Override
-            public void handleMessage(Message msg) {
-                super.handleMessage(msg);
-                if (msg.what == RemoteProcessService.stepCreateInitialRealm_A.message) {
-                    clearTimeoutFlag();
-                    done();
-                } else {
-                    assertTrue(false);
-                }
+            public Unit invoke() {
+                new InterprocessHandler(new Runnable() {
+                    @Override
+                    public void run() {
+                        testRealm = Realm.getInstance(getConfiguration());
+                        looperThread.closeAfterTest(testRealm);
+                        results = testRealm.where(AllTypes.class).findAll();
+                        assertEquals(0, results.size());
+                        results.addChangeListener(new RealmChangeListener<RealmResults<AllTypes>>() {
+                            @Override
+                            public void onChange(RealmResults<AllTypes> allTypes) {
+                                switch(updateCount.incrementAndGet()) {
+                                    case 1: {
+                                        assertEquals(1, results.size());
+                                        break;
+                                    }
+                                    case 2: {
+                                        assertEquals(2, results.size());
+                                        looperThread.testComplete();
+                                        break;
+                                    }
+                                }
+                            }
+                        });
+                        triggerServiceStep(RemoteProcessService.stepCreateObjects);
+                    }
+                }) {
+                    @Override
+                    public void handleMessage(Message msg) {
+                        super.handleMessage(msg);
+                        if (msg.what == RemoteProcessService.stepCreateObjects.message) {
+                            clearTimeoutFlag();
+                        } else {
+                            assertTrue(false);
+                        }
+                    }
+                };
+                return Unit.INSTANCE;
             }
-        };
-        Looper.loop();
+        });
     }
 }
diff --git a/realm/realm-library/src/main/cpp/CMakeLists.txt b/realm/realm-library/src/main/cpp/CMakeLists.txt
@@ -197,10 +197,11 @@ endif()
 #FIXME maybe-uninitialized is reported by table_view.cpp:272:15:
 #     'best.m_nanoseconds' was declared here
 #     -Wno-missing-field-initializers disable in object store as well.
+# FIXME See https://github.com/realm/realm-core/issues/4732
 set(WARNING_CXX_FLAGS "-Werror -Wall -Wextra -pedantic -Wmissing-declarations \
     -Wempty-body -Wparentheses -Wunknown-pragmas -Wunreachable-code \
     -Wno-missing-field-initializers -Wno-unevaluated-expression -Wno-unreachable-code \
-    -Wno-c99-extensions")
+    -Wno-c99-extensions -Wno-dtor-name")
 set(REALM_COMMON_CXX_FLAGS "${REALM_COMMON_CXX_FLAGS} -DREALM_ANDROID -DREALM_HAVE_CONFIG -DPIC -fdata-sections -pthread -frtti -fvisibility=hidden -fsigned-char -fno-stack-protector -std=c++17")
 if (REALM_ENABLE_SYNC)
     set(REALM_COMMON_CXX_FLAGS "${REALM_COMMON_CXX_FLAGS} -DREALM_ENABLE_SYNC=1")
diff --git a/realm/realm-library/src/main/cpp/realm-core b/realm/realm-library/src/main/cpp/realm-core
@@ -1 +1 @@
-Subproject commit 5043c25e1d8f5971002e0fec85dea5ea3d7eb3d7
+Subproject commit ae14e6be382a72a9252d4e6710c2710c1ea4e688
diff --git a/realm/realm-library/src/testUtils/java/io/realm/services/RemoteProcessService.java b/realm/realm-library/src/testUtils/java/io/realm/services/RemoteProcessService.java
@@ -24,6 +24,7 @@
 import android.os.Message;
 import android.os.Messenger;
 import android.os.RemoteException;
+import android.os.SystemClock;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -152,8 +153,35 @@ void run() {
         }
     };
 
+    public final static Step stepCreateObjects = new Step(30) {
+
+        @Override
+        void run() {
+            thiz.testRealm = Realm.getInstance(getConfiguration());
+            thiz.testRealm.executeTransaction(new Realm.Transaction() {
+                @Override
+                public void execute(Realm realm) {
+                    realm.createObject(AllTypes.class);
+                }
+            });
+            SystemClock.sleep(1000);
+            thiz.testRealm.executeTransaction(new Realm.Transaction() {
+                @Override
+                public void execute(Realm realm) {
+                    realm.createObject(AllTypes.class);
+                }
+            });
+            thiz.testRealm.close();
+            response(null);
+            Runtime.getRuntime().exit(0);
+        }
+    };
+
     private static RealmConfiguration getConfiguration() {
-        return new RealmConfiguration.Builder().modules(new AllTypesModelModule()).build();
+        return new RealmConfiguration.Builder()
+                .allowQueriesOnUiThread(true)
+                .allowWritesOnUiThread(true)
+                .modules(new AllTypesModelModule()).build();
     }
 
 }
