Rewrite async runtime handling and port to tracing

Author: jkcoxson

Cargo.lock

@@ -9,6 +9,7 @@ idevice = { path = "../idevice", default-features = false }
 futures = { version = "0.3", optional = true }
 tracing = { version = "0.1.41" }
 tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }
+tracing-appender = { version = "0.2" }
 once_cell = "1.21.1"
 tokio = { version = "1.44.1", features = ["full"] }
 libc = "0.2.171"

ffi/Cargo.toml

@@ -7,7 +7,7 @@ use idevice::tcp::handle::StreamHandle;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 use crate::core_device_proxy::AdapterHandle;
-use crate::{IdeviceFfiError, RUNTIME, ReadWriteOpaque, ffi_err};
+use crate::{IdeviceFfiError, ReadWriteOpaque, ffi_err, run_sync};
 
 pub struct AdapterStreamHandle(pub StreamHandle);
 
@@ -36,7 +36,7 @@ pub unsafe extern "C" fn adapter_connect(
     }
 
     let adapter = unsafe { &mut (*adapter_handle).0 };
-    let res = RUNTIME.block_on(async move { adapter.connect(port).await });
+    let res = run_sync(async move { adapter.connect(port).await });
 
     match res {
         Ok(r) => {
@@ -81,7 +81,7 @@ pub unsafe extern "C" fn adapter_pcap(
         Err(_) => return ffi_err!(IdeviceError::FfiInvalidString),
     };
 
-    let res = RUNTIME.block_on(async move { adapter.pcap(path_str).await });
+    let res = run_sync(async move { adapter.pcap(path_str).await });
 
     match res {
         Ok(_) => null_mut(),
@@ -111,7 +111,7 @@ pub unsafe extern "C" fn adapter_stream_close(
     }
 
     let adapter = unsafe { &mut (*handle).0 };
-    RUNTIME.block_on(async move { adapter.close() });
+    run_sync(async move { adapter.close() });
 
     null_mut()
 }
@@ -133,7 +133,7 @@ pub unsafe extern "C" fn adapter_close(handle: *mut AdapterHandle) -> *mut Idevi
     }
 
     let adapter = unsafe { &mut (*handle).0 };
-    RUNTIME.block_on(async move { adapter.close().await.ok() });
+    run_sync(async move { adapter.close().await.ok() });
 
     null_mut()
 }
@@ -164,7 +164,7 @@ pub unsafe extern "C" fn adapter_send(
     let adapter = unsafe { &mut (*handle).0 };
     let data_slice = unsafe { std::slice::from_raw_parts(data, length) };
 
-    let res = RUNTIME.block_on(async move { adapter.write_all(data_slice).await });
+    let res = run_sync(async move { adapter.write_all(data_slice).await });
 
     match res {
         Ok(_) => null_mut(),
@@ -202,7 +202,7 @@ pub unsafe extern "C" fn adapter_recv(
     }
 
     let adapter = unsafe { &mut (*handle).0 };
-    let res: Result<Vec<u8>, std::io::Error> = RUNTIME.block_on(async move {
+    let res: Result<Vec<u8>, std::io::Error> = run_sync(async move {
         let mut buf = [0; 2048];
         let res = adapter.read(&mut buf).await?;
         Ok(buf[..res].to_vec())

ffi/src/adapter.rs

@@ -8,7 +8,10 @@ use idevice::{
     provider::IdeviceProvider,
 };
 
-use crate::{IdeviceFfiError, IdeviceHandle, RUNTIME, ffi_err, provider::IdeviceProviderHandle};
+use crate::{
+    IdeviceFfiError, IdeviceHandle, LOCAL_RUNTIME, ffi_err, provider::IdeviceProviderHandle,
+    run_sync, run_sync_local,
+};
 
 pub struct AfcClientHandle(pub AfcClient);
 
@@ -34,7 +37,7 @@ pub unsafe extern "C" fn afc_client_connect(
         return ffi_err!(IdeviceError::FfiInvalidArg);
     }
 
-    let res = RUNTIME.block_on(async {
+    let res = run_sync_local(async {
         let provider_ref: &dyn IdeviceProvider = unsafe { &*(*provider).0 };
 
         AfcClient::connect(provider_ref).await
@@ -122,7 +125,7 @@ pub unsafe extern "C" fn afc_list_directory(
     // Use to_string_lossy to handle non-UTF8 paths
     let path = path_cstr.to_string_lossy();
 
-    let res: Result<Vec<String>, IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<Vec<String>, IdeviceError> = run_sync_local(async move {
         // SAFETY: We're assuming client is a valid pointer here
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.list_dir(&path.to_string()).await
@@ -194,7 +197,7 @@ pub unsafe extern "C" fn afc_make_directory(
         Err(_) => return ffi_err!(IdeviceError::FfiInvalidArg),
     };
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<(), IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.mk_dir(path).await
     });
@@ -246,7 +249,7 @@ pub unsafe extern "C" fn afc_get_file_info(
         Err(_) => return ffi_err!(IdeviceError::FfiInvalidArg),
     };
 
-    let res: Result<FileInfo, IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<FileInfo, IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.get_file_info(path).await
     });
@@ -331,7 +334,7 @@ pub unsafe extern "C" fn afc_get_device_info(
         return ffi_err!(IdeviceError::FfiInvalidArg);
     }
 
-    let res: Result<DeviceInfo, IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<DeviceInfo, IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.get_device_info().await
     });
@@ -395,7 +398,7 @@ pub unsafe extern "C" fn afc_remove_path(
         Err(_) => return ffi_err!(IdeviceError::FfiInvalidArg),
     };
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<(), IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.remove(path).await
     });
@@ -433,7 +436,7 @@ pub unsafe extern "C" fn afc_remove_path_and_contents(
         Err(_) => return ffi_err!(IdeviceError::FfiInvalidArg),
     };
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<(), IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.remove_all(path).await
     });
@@ -506,7 +509,7 @@ pub unsafe extern "C" fn afc_file_open(
 
     let mode = mode.into();
 
-    let res: Result<*mut AfcFileHandle, IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<*mut AfcFileHandle, IdeviceError> = LOCAL_RUNTIME.block_on(async move {
         let client_ref = unsafe { &mut (*client).0 };
         let result = client_ref.open(path, mode).await;
         match result {
@@ -544,7 +547,7 @@ pub unsafe extern "C" fn afc_file_close(handle: *mut AfcFileHandle) -> *mut Idev
     }
 
     let fd = unsafe { Box::from_raw(handle as *mut idevice::afc::file::FileDescriptor) };
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move { fd.close().await });
+    let res: Result<(), IdeviceError> = run_sync(async move { fd.close().await });
 
     match res {
         Ok(_) => null_mut(),
@@ -575,7 +578,7 @@ pub unsafe extern "C" fn afc_file_read(
     }
 
     let fd = unsafe { &mut *(handle as *mut idevice::afc::file::FileDescriptor) };
-    let res: Result<Vec<u8>, IdeviceError> = RUNTIME.block_on(async move { fd.read().await });
+    let res: Result<Vec<u8>, IdeviceError> = run_sync(async move { fd.read().await });
 
     match res {
         Ok(bytes) => {
@@ -617,7 +620,7 @@ pub unsafe extern "C" fn afc_file_write(
     let fd = unsafe { &mut *(handle as *mut idevice::afc::file::FileDescriptor) };
     let data_slice = unsafe { std::slice::from_raw_parts(data, length) };
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move { fd.write(data_slice).await });
+    let res: Result<(), IdeviceError> = run_sync(async move { fd.write(data_slice).await });
 
     match res {
         Ok(_) => null_mut(),
@@ -674,7 +677,7 @@ pub unsafe extern "C" fn afc_make_link(
         AfcLinkType::Symbolic => idevice::afc::opcode::LinkType::Symlink,
     };
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<(), IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.link(target, source, link_type).await
     });
@@ -720,7 +723,7 @@ pub unsafe extern "C" fn afc_rename_path(
         Err(_) => return ffi_err!(IdeviceError::FfiInvalidArg),
     };
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<(), IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.rename(source, target).await
     });

ffi/src/afc.rs

@@ -4,7 +4,9 @@ use std::ptr::null_mut;
 
 use idevice::{IdeviceError, IdeviceService, amfi::AmfiClient, provider::IdeviceProvider};
 
-use crate::{IdeviceFfiError, IdeviceHandle, RUNTIME, ffi_err, provider::IdeviceProviderHandle};
+use crate::{
+    IdeviceFfiError, IdeviceHandle, ffi_err, provider::IdeviceProviderHandle, run_sync_local,
+};
 
 pub struct AmfiClientHandle(pub AmfiClient);
 
@@ -30,7 +32,7 @@ pub unsafe extern "C" fn amfi_connect(
         return ffi_err!(IdeviceError::FfiInvalidArg);
     }
 
-    let res: Result<AmfiClient, IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<AmfiClient, IdeviceError> = run_sync_local(async move {
         let provider_ref: &dyn IdeviceProvider = unsafe { &*(*provider).0 };
 
         // Connect using the reference
@@ -94,7 +96,7 @@ pub unsafe extern "C" fn amfi_reveal_developer_mode_option_in_ui(
         return ffi_err!(IdeviceError::FfiInvalidArg);
     }
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<(), IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.reveal_developer_mode_option_in_ui().await
     });
@@ -122,7 +124,7 @@ pub unsafe extern "C" fn amfi_enable_developer_mode(
         return ffi_err!(IdeviceError::FfiInvalidArg);
     }
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<(), IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.enable_developer_mode().await
     });
@@ -150,7 +152,7 @@ pub unsafe extern "C" fn amfi_accept_developer_mode(
         return ffi_err!(IdeviceError::FfiInvalidArg);
     }
 
-    let res: Result<(), IdeviceError> = RUNTIME.block_on(async move {
+    let res: Result<(), IdeviceError> = run_sync_local(async move {
         let client_ref = unsafe { &mut (*client).0 };
         client_ref.accept_developer_mode().await
     });

ffi/src/amfi.rs

@@ -9,7 +9,7 @@ use idevice::{IdeviceError, ReadWrite, RsdService};
 
 use crate::core_device_proxy::AdapterHandle;
 use crate::rsd::RsdHandshakeHandle;
-use crate::{IdeviceFfiError, RUNTIME, ReadWriteOpaque, ffi_err};
+use crate::{IdeviceFfiError, ReadWriteOpaque, ffi_err, run_sync, run_sync_local};
 
 /// Opaque handle to an AppServiceClient
 pub struct AppServiceHandle(pub AppServiceClient<Box<dyn ReadWrite>>);
@@ -91,7 +91,7 @@ pub unsafe extern "C" fn app_service_connect_rsd(
     }
 
     let res: Result<AppServiceClient<Box<dyn ReadWrite>>, IdeviceError> =
-        RUNTIME.block_on(async move {
+        run_sync_local(async move {
             let provider_ref = unsafe { &mut (*provider).0 };
             let handshake_ref = unsafe { &mut (*handshake).0 };
 
@@ -130,7 +130,7 @@ pub unsafe extern "C" fn app_service_new(
     }
 
     let socket = unsafe { Box::from_raw(socket) };
-    let res = RUNTIME.block_on(async move { AppServiceClient::new(socket.inner.unwrap()).await });
+    let res = run_sync(async move { AppServiceClient::new(socket.inner.unwrap()).await });
 
     match res {
         Ok(client) => {
@@ -186,7 +186,7 @@ pub unsafe extern "C" fn app_service_list_apps(
     }
 
     let client = unsafe { &mut (*handle).0 };
-    let res = RUNTIME.block_on(async move {
+    let res = run_sync(async move {
         client
             .list_apps(
                 app_clips != 0,
@@ -347,7 +347,7 @@ pub unsafe extern "C" fn app_service_launch_app(
     };
 
     let client = unsafe { &mut (*handle).0 };
-    let res = RUNTIME.block_on(async move {
+    let res = run_sync(async move {
         client
             .launch_application(
                 bundle_id_str,
@@ -430,7 +430,7 @@ pub unsafe extern "C" fn app_service_list_processes(
     }
 
     let client = unsafe { &mut (*handle).0 };
-    let res = RUNTIME.block_on(async move { client.list_processes().await });
+    let res = run_sync(async move { client.list_processes().await });
 
     match res {
         Ok(process_list) => {
@@ -513,7 +513,7 @@ pub unsafe extern "C" fn app_service_uninstall_app(
     };
 
     let client = unsafe { &mut (*handle).0 };
-    let res = RUNTIME.block_on(async move { client.uninstall_app(bundle_id_str).await });
+    let res = run_sync(async move { client.uninstall_app(bundle_id_str).await });
 
     match res {
         Ok(_) => null_mut(),
@@ -546,7 +546,7 @@ pub unsafe extern "C" fn app_service_send_signal(
     }
 
     let client = unsafe { &mut (*handle).0 };
-    let res = RUNTIME.block_on(async move { client.send_signal(pid, signal).await });
+    let res = run_sync(async move { client.send_signal(pid, signal).await });
 
     match res {
         Ok(signal_response) => {
@@ -628,7 +628,7 @@ pub unsafe extern "C" fn app_service_fetch_app_icon(
     };
 
     let client = unsafe { &mut (*handle).0 };
-    let res = RUNTIME.block_on(async move {
+    let res = run_sync(async move {
         client
             .fetch_app_icon(bundle_id_str, width, height, scale, allow_placeholder != 0)
             .await