Refactor JNI_PeetConnectionFactory for readability and use unique ptrs for threads

Signed-off-by: Joshua Castle <26531652+Kas-tle@users.noreply.github.com>

Author: Kas-tle

gradle.properties

@@ -1 +1 @@
-version=1.0.2
+version=1.0.3

webrtc-jni/src/main/cpp/src/JNI_PeerConnectionFactory.cpp

@@ -26,44 +26,42 @@
 JNIEXPORT void JNICALL Java_dev_kastle_webrtc_PeerConnectionFactory_initialize
 (JNIEnv * env, jobject caller)
 {
-	try {
-        auto networkThread = webrtc::Thread::CreateWithSocketServer();
-        networkThread->SetName("webrtc_jni_network_thread", nullptr);
-
-        auto signalingThread = webrtc::Thread::Create();
-        signalingThread->SetName("webrtc_jni_signaling_thread", nullptr);
-
-        auto workerThread = webrtc::Thread::Create();
-        workerThread->SetName("webrtc_jni_worker_thread", nullptr);
-
-        if (!networkThread->Start()) {
-            throw jni::Exception("Start network thread failed");
-        }
-        if (!signalingThread->Start()) {
-            throw jni::Exception("Start signaling thread failed");
-        }
-        if (!workerThread->Start()) {
-            throw jni::Exception("Start worker thread failed");
-        }
-
-        webrtc::PeerConnectionFactoryDependencies dependencies;
-        
-        dependencies.network_thread = networkThread.release();
-        dependencies.worker_thread = workerThread.release();
-        dependencies.signaling_thread = signalingThread.release();
-
-        auto factory = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
-
-        if (factory != nullptr) {
-            SetHandle(env, caller, factory.release());
-        }
-        else {
-            throw jni::Exception("Create PeerConnectionFactory failed");
-        }
-	}
-	catch (...) {
-		ThrowCxxJavaException(env);
-	}
+    std::unique_ptr<webrtc::Thread> networkThread = webrtc::Thread::CreateWithSocketServer();
+    networkThread->SetName("webrtc_jni_network_thread", nullptr);
+    if (!networkThread->Start()) {
+        env->Throw(jni::JavaRuntimeException(env, "Start network thread failed"));
+        return;
+    }
+
+    std::unique_ptr<webrtc::Thread> signalingThread = webrtc::Thread::Create();
+    signalingThread->SetName("webrtc_jni_signaling_thread", nullptr);
+    if (!signalingThread->Start()) {
+        env->Throw(jni::JavaRuntimeException(env, "Start signaling thread failed"));
+        return;
+    }
+
+    std::unique_ptr<webrtc::Thread> workerThread = webrtc::Thread::Create();
+    workerThread->SetName("webrtc_jni_worker_thread", nullptr);
+    if (!workerThread->Start()) {
+        env->Throw(jni::JavaRuntimeException(env, "Start worker thread failed"));
+        return;
+    }
+
+    webrtc::PeerConnectionFactoryDependencies dependencies;
+    
+    dependencies.network_thread = networkThread.release();
+    dependencies.worker_thread = workerThread.release();
+    dependencies.signaling_thread = signalingThread.release();
+
+    webrtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory = 
+        webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
+
+    if (factory == nullptr) {
+        env->Throw(jni::JavaRuntimeException(env, "Create PeerConnectionFactory failed"));
+        return;
+    }
+
+    SetHandle(env, caller, factory.release());
 }
 
 JNIEXPORT void JNICALL Java_dev_kastle_webrtc_PeerConnectionFactory_dispose
@@ -72,37 +70,31 @@ JNIEXPORT void JNICALL Java_dev_kastle_webrtc_PeerConnectionFactory_dispose
 	webrtc::PeerConnectionFactoryInterface * factory = GetHandle<webrtc::PeerConnectionFactoryInterface>(env, caller);
 	CHECK_HANDLE(factory);
 
-	webrtc::Thread * networkThread = GetHandle<webrtc::Thread>(env, caller, "networkThreadHandle");
-	webrtc::Thread * signalingThread = GetHandle<webrtc::Thread>(env, caller, "signalingThreadHandle");
-	webrtc::Thread * workerThread = GetHandle<webrtc::Thread>(env, caller, "workerThreadHandle");
+	std::unique_ptr<webrtc::Thread> networkThread(GetHandle<webrtc::Thread>(env, caller, "networkThreadHandle"));
+	std::unique_ptr<webrtc::Thread> signalingThread(GetHandle<webrtc::Thread>(env, caller, "signalingThreadHandle"));
+	std::unique_ptr<webrtc::Thread> workerThread(GetHandle<webrtc::Thread>(env, caller, "workerThreadHandle"));
 
 	webrtc::RefCountReleaseStatus status = factory->Release();
 
 	if (status != webrtc::RefCountReleaseStatus::kDroppedLastRef) {
-		env->Throw(jni::JavaError(env, "Native object was not deleted. A reference is still around somewhere."));
+		env->Throw(jni::JavaError(
+            env, 
+            "Native object was not deleted. A reference is still around somewhere."
+        ));
 	}
 
 	SetHandle<std::nullptr_t>(env, caller, nullptr);
-
 	factory = nullptr;
 
-	try {
-		if (networkThread) {
-			networkThread->Stop();
-			delete networkThread;
-		}
-		if (signalingThread) {
-			signalingThread->Stop();
-			delete signalingThread;
-		}
-		if (workerThread) {
-			workerThread->Stop();
-			delete workerThread;
-		}
-	}
-	catch (...) {
-		ThrowCxxJavaException(env);
-	}
+    if (networkThread) {
+        networkThread->Stop();
+    }
+    if (signalingThread) {
+        signalingThread->Stop();
+    }
+    if (workerThread) {
+        workerThread->Stop();
+    }
 }
 
 JNIEXPORT jobject JNICALL Java_dev_kastle_webrtc_PeerConnectionFactory_createPeerConnection
@@ -117,14 +109,20 @@ JNIEXPORT jobject JNICALL Java_dev_kastle_webrtc_PeerConnectionFactory_createPee
 		return nullptr;
 	}
 
-	webrtc::PeerConnectionFactoryInterface * factory = GetHandle<webrtc::PeerConnectionFactoryInterface>(env, caller);
+	webrtc::PeerConnectionFactoryInterface * factory = 
+        GetHandle<webrtc::PeerConnectionFactoryInterface>(env, caller);
 	CHECK_HANDLEV(factory, nullptr);
 
-	webrtc::PeerConnectionInterface::RTCConfiguration configuration = jni::RTCConfiguration::toNative(env, jni::JavaLocalRef<jobject>(env, jConfig));
-	webrtc::PeerConnectionObserver * observer = new jni::PeerConnectionObserver(env, jni::JavaGlobalRef<jobject>(env, jobserver));
+	webrtc::PeerConnectionInterface::RTCConfiguration configuration = 
+        jni::RTCConfiguration::toNative(env, jni::JavaLocalRef<jobject>(env, jConfig));
+
+	webrtc::PeerConnectionObserver * observer = 
+        new jni::PeerConnectionObserver(env, jni::JavaGlobalRef<jobject>(env, jobserver));
+
 	webrtc::PeerConnectionDependencies dependencies(observer);
 
-	auto result = factory->CreatePeerConnectionOrError(configuration, std::move(dependencies));
+    webrtc::RTCErrorOr<webrtc::scoped_refptr<webrtc::PeerConnectionInterface>> result = 
+        factory->CreatePeerConnectionOrError(configuration, std::move(dependencies));
 
 	if (!result.ok()) {
 		env->Throw(jni::JavaRuntimeException(env, "Create PeerConnection failed: %s %s",
@@ -133,13 +131,12 @@ JNIEXPORT jobject JNICALL Java_dev_kastle_webrtc_PeerConnectionFactory_createPee
 		return nullptr;
 	}
 
-	auto pc = result.MoveValue();
+	webrtc::scoped_refptr<webrtc::PeerConnectionInterface> pc = result.MoveValue();
 
 	if (pc != nullptr) {
-		auto javaPeerConnection = jni::JavaFactories::create(env, pc.release());
-
+		jni::JavaLocalRef<jobject> javaPeerConnection = 
+            jni::JavaFactories::create(env, pc.release());
 		SetHandle(env, javaPeerConnection.get(), "observerHandle", observer);
-
 		return javaPeerConnection.release();
 	}