[Android] Harden JNI resource ownership

lib/android_build/app/src/androidTest/java/com/microsoft/applications/events/maesdktest/LogManagerDDVUnitTest.java

@@ -511,6 +511,10 @@ public void onDebugEvent(DebugEvent evt) {
 
     ListenForFilter listener = new ListenForFilter();
     manager.addEventListener(DebugEventType.EVT_FILTERED, listener);
+    long listenerIdentity = listener.nativeIdentity;
+    assertThat(listenerIdentity, is(not(-1L)));
+    manager.addEventListener(DebugEventType.EVT_REJECTED, listener);
+    assertThat(listener.nativeIdentity, is(listenerIdentity));
     logger.logEvent("noprops");
     manager.uploadNow();
     try {
@@ -531,6 +535,9 @@ public void onDebugEvent(DebugEvent evt) {
       assertThat(listener.filteredCount, is(1L));
     }
     manager.removeEventListener(DebugEventType.EVT_FILTERED, listener);
+    assertThat(listener.nativeIdentity, is(listenerIdentity));
+    manager.removeEventListener(DebugEventType.EVT_REJECTED, listener);
+    assertThat(listener.nativeIdentity, is(-1L));
     int[] everything = { DiagLevel.DIAG_LEVEL_REQUIRED.value(), DiagLevel.DIAG_LEVEL_OPTIONAL.value() };
     manager.setLevelFilter(DiagLevel.DIAG_LEVEL_OPTIONAL.value(), everything);
   }

lib/android_build/maesdk/src/main/java/com/microsoft/applications/events/LogManagerProvider.java

@@ -272,11 +272,13 @@ public void addEventListener(DebugEventType eventType, DebugEventListener listen
       listener.nativeIdentity = nativeAddEventListener(nativeLogManager, eventType.value(), listener, listener.nativeIdentity);
     }
 
-    public native void nativeRemoveEventListener(long nativeLogManager, long eventType, long identity);
+    public native long nativeRemoveEventListener(
+        long nativeLogManager, long eventType, long identity, DebugEventListener listener);
 
     @Override
     public void removeEventListener(DebugEventType eventType, DebugEventListener listener) {
-      nativeRemoveEventListener(nativeLogManager, eventType.value(), listener.nativeIdentity);
+      listener.nativeIdentity = nativeRemoveEventListener(
+          nativeLogManager, eventType.value(), listener.nativeIdentity, listener);
     }
 
     private native boolean nativeRegisterPrivacyGuard(long nativeLogManager);

lib/callbacks/DebugSource.cpp

@@ -3,14 +3,88 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 #include "mat/config.h"
+#include "callbacks/DebugSourceInternal.hpp"
 #include "DebugEvents.hpp"
 #include "utils/Utils.hpp"
 #include "pal/PAL.hpp"
 
 #include <atomic>
+#include <iterator>
 
 namespace MAT_NS_BEGIN {
 
+    namespace
+    {
+        thread_local std::vector<DebugEventListener*> pendingListeners;
+        std::atomic<DebugEventListenerPendingReleaseCallback>
+            pendingReleaseCallback{nullptr};
+
+        class PendingListenersScope
+        {
+        public:
+            explicit PendingListenersScope(const std::vector<DebugEventListener*>& listeners) :
+                remaining(listeners)
+            {
+                pendingListeners.insert(
+                    pendingListeners.end(),
+                    listeners.begin(),
+                    listeners.end());
+            }
+
+            ~PendingListenersScope()
+            {
+                for (auto listener : remaining)
+                {
+                    RemovePending(listener);
+                    auto callback = pendingReleaseCallback.load();
+                    if (callback != nullptr)
+                    {
+                        callback(listener);
+                    }
+                }
+            }
+
+            void BeginCallback(DebugEventListener* listener)
+            {
+                auto current = std::find(remaining.begin(), remaining.end(), listener);
+                if (current != remaining.end())
+                {
+                    remaining.erase(current);
+                }
+                RemovePending(listener);
+            }
+
+        private:
+            static void RemovePending(DebugEventListener* listener)
+            {
+                auto pending = std::find(
+                    pendingListeners.rbegin(),
+                    pendingListeners.rend(),
+                    listener);
+                if (pending != pendingListeners.rend())
+                {
+                    pendingListeners.erase(std::next(pending).base());
+                }
+            }
+
+            std::vector<DebugEventListener*> remaining;
+        };
+    }
+
+    bool IsDebugEventListenerPending(const DebugEventListener* listener) noexcept
+    {
+        return std::find(
+                   pendingListeners.begin(),
+                   pendingListeners.end(),
+                   listener) != pendingListeners.end();
+    }
+
+    void SetDebugEventListenerPendingReleaseCallback(
+        DebugEventListenerPendingReleaseCallback callback) noexcept
+    {
+        pendingReleaseCallback.store(callback);
+    }
+
     /// <summary>Add event listener for specific debug event type.</summary>
     void DebugEventSource::AddEventListener(DebugEventType type, DebugEventListener &listener)
     {
@@ -45,8 +119,10 @@ namespace MAT_NS_BEGIN {
 
             if (listeners.size()) {
                 // Events filter handlers list
-                auto &v = listeners[evt.type];
-                for (auto listener : v) {
+                auto eventListeners = listeners[evt.type];
+                PendingListenersScope pendingScope(eventListeners);
+                for (auto listener : eventListeners) {
+                    pendingScope.BeginCallback(listener);
                     listener->OnDebugEvent(evt);
                     dispatched = true;
                 }
@@ -85,4 +161,3 @@ namespace MAT_NS_BEGIN {
     }
 
 } MAT_NS_END
-

lib/callbacks/DebugSourceInternal.hpp

@@ -0,0 +1,18 @@
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+#pragma once
+
+#include "DebugEvents.hpp"
+
+namespace MAT_NS_BEGIN
+{
+    using DebugEventListenerPendingReleaseCallback =
+        void (*)(DebugEventListener*);
+
+    bool IsDebugEventListenerPending(const DebugEventListener* listener) noexcept;
+    void SetDebugEventListenerPendingReleaseCallback(
+        DebugEventListenerPendingReleaseCallback callback) noexcept;
+}
+MAT_NS_END

lib/jni/JniConvertors.cpp

@@ -196,12 +196,26 @@ EventProperties GetEventProperties(JNIEnv* env, const jstring& jstrEventName, co
 std::vector<std::string> ConvertJObjectArrayToStdStringVector(JNIEnv* env, const jobjectArray& jArrayToConvert)
 {
     std::vector<std::string> stringVector;
-    stringVector.reserve(env->GetArrayLength(jArrayToConvert));
+    auto length = env->GetArrayLength(jArrayToConvert);
+    if (env->ExceptionCheck())
+    {
+        return stringVector;
+    }
+    stringVector.reserve(length);
 
-    for(int i = 0; i < env->GetArrayLength(jArrayToConvert); i++)
+    for(int i = 0; i < length; i++)
     {
         auto jStringValue = static_cast<jstring>(env->GetObjectArrayElement(jArrayToConvert, i));
+        if (env->ExceptionCheck())
+        {
+            return stringVector;
+        }
         auto stringValue = JStringToStdString(env, jStringValue);
+        if (env->ExceptionCheck())
+        {
+            env->DeleteLocalRef(jStringValue);
+            return stringVector;
+        }
         if(!stringValue.empty())
         {
             stringVector.emplace_back(std::move(stringValue));