android: remove unwrap spam.

Author: Dirbaio

Cargo.toml

@@ -55,7 +55,7 @@ bluer = { version = "0.16.1", features = ["bluetoothd"] }
 tokio = { version = "1.20.1", features = ["rt-multi-thread"] }
 
 [target.'cfg(target_os = "android")'.dependencies]
-jni-glue = { git = "https://github.com/akiles/jni-bindgen", rev = "1ab6c3cb29ffcca01b269fc6c23900da6668288f" }
+jni-glue = { git = "https://github.com/akiles/jni-bindgen", rev = "45ddf3129bbe5987ab19f9c9be091de3bf3c5c25" }
 futures-channel = "0.3.24"
 
 [target.'cfg(any(target_os = "macos", target_os = "ios"))'.dependencies]

src/android/adapter.rs

@@ -8,15 +8,15 @@ use futures_channel::mpsc::{Receiver, Sender};
 use futures_core::Stream;
 use futures_lite::{stream, StreamExt};
 use jni_glue::{Argument, ByteArray, Env, Global, Local, PrimitiveArray, VM};
-use tracing::{info, warn};
+use tracing::{debug, warn};
 use uuid::Uuid;
 
 use super::bindings::android::bluetooth::le::{BluetoothLeScanner, ScanResult};
 use super::bindings::android::bluetooth::{BluetoothAdapter, BluetoothManager};
 use super::bindings::android::os::ParcelUuid;
 use super::bindings::com::github::alexmoon::bluest::android::BluestScanCallback;
 use super::device::DeviceImpl;
-use super::JavaIterator;
+use super::{JavaIterator, OptionExt};
 use crate::android::bindings::java::util::Map_Entry;
 use crate::util::defer;
 use crate::{
@@ -41,8 +41,8 @@ impl AdapterImpl {
 
         vm.with_env(|env| {
             let local_manager = manager.with(env);
-            let adapter = local_manager.getAdapter()?.unwrap();
-            let le_scanner = adapter.getBluetoothLeScanner()?.unwrap();
+            let adapter = local_manager.getAdapter()?.non_null()?;
+            let le_scanner = adapter.getBluetoothLeScanner()?.non_null()?;
 
             Ok(Self {
                 inner: Arc::new(AdapterInner {
@@ -89,8 +89,10 @@ impl AdapterImpl {
                 self.inner.manager.vm().with_env(|env| {
                     let callback = callback_global.with(env);
                     let scanner = self.inner.le_scanner.with(env);
-                    scanner.stopScan_ScanCallback(&**callback).unwrap();
-                    info!("stopped scan");
+                    match scanner.stopScan_ScanCallback(&**callback) {
+                        Ok(()) => debug!("stopped scan"),
+                        Err(e) => warn!("failed to stop scan: {:?}", e),
+                    };
                 });
             });
 
@@ -225,53 +227,60 @@ pub extern "system" fn Java_com_github_alexmoon_bluest_android_BluestScanCallbac
     callback_type: i32,
     scan_result: Argument<ScanResult>,
 ) {
-    let scan_result = unsafe { scan_result.with_unchecked(env) }.unwrap();
+    if let Err(e) = on_scan_result(env, id, callback_type, scan_result) {
+        warn!("on_scan_result failed: {:?}", e);
+    }
+}
 
-    tracing::info!("got callback! {} {}", id, callback_type);
+fn convert_uuid(uuid: Local<'_, ParcelUuid>) -> Result<Uuid> {
+    let uuid = uuid.getUuid()?.non_null()?;
+    let lsb = uuid.getLeastSignificantBits()? as u64;
+    let msb = uuid.getMostSignificantBits()? as u64;
+    Ok(Uuid::from_u64_pair(msb, lsb))
+}
 
-    let scan_record = scan_result.getScanRecord().unwrap().unwrap();
-    let device = scan_result.getDevice().unwrap().unwrap();
+#[no_mangle]
+fn on_scan_result(env: Env<'_>, id: i32, callback_type: i32, scan_result: Argument<ScanResult>) -> Result<()> {
+    let scan_result = unsafe { scan_result.with_unchecked(env) }.non_null()?;
 
-    fn convert_uuid(uuid: Local<'_, ParcelUuid>) -> Uuid {
-        let uuid = uuid.getUuid().unwrap().unwrap();
-        let lsb = uuid.getLeastSignificantBits().unwrap() as u64;
-        let msb = uuid.getMostSignificantBits().unwrap() as u64;
-        Uuid::from_u64_pair(msb, lsb)
-    }
+    tracing::info!("got callback! {} {}", id, callback_type);
 
-    let address = device.getAddress().unwrap().unwrap().to_string_lossy();
-    let rssi = scan_result.getRssi().unwrap();
-    let is_connectable = scan_result.isConnectable().unwrap();
-    let local_name = scan_record.getDeviceName().unwrap().map(|s| s.to_string_lossy());
-    let tx_power_level = scan_record.getTxPowerLevel().unwrap();
+    let scan_record = scan_result.getScanRecord()?.non_null()?;
+    let device = scan_result.getDevice()?.non_null()?;
+
+    let address = device.getAddress()?.non_null()?.to_string_lossy();
+    let rssi = scan_result.getRssi()?;
+    let is_connectable = scan_result.isConnectable()?;
+    let local_name = scan_record.getDeviceName()?.map(|s| s.to_string_lossy());
+    let tx_power_level = scan_record.getTxPowerLevel()?;
 
     // Services
     let mut services = Vec::new();
-    if let Some(uuids) = scan_record.getServiceUuids().unwrap() {
-        for uuid in JavaIterator(uuids.iterator().unwrap().unwrap()) {
-            services.push(convert_uuid(uuid.cast().unwrap()))
+    if let Some(uuids) = scan_record.getServiceUuids()? {
+        for uuid in JavaIterator(uuids.iterator()?.non_null()?) {
+            services.push(convert_uuid(uuid.cast()?)?)
         }
     }
 
     // Service data
     let mut service_data = HashMap::new();
-    let sd = scan_record.getServiceData().unwrap().unwrap();
-    let sd = sd.entrySet().unwrap().unwrap();
-    for entry in JavaIterator(sd.iterator().unwrap().unwrap()) {
-        let entry: Local<Map_Entry> = entry.cast().unwrap();
-        let key: Local<ParcelUuid> = entry.getKey().unwrap().unwrap().cast().unwrap();
-        let val: Local<ByteArray> = entry.getValue().unwrap().unwrap().cast().unwrap();
-        service_data.insert(convert_uuid(key), val.as_vec().into_iter().map(|i| i as u8).collect());
+    let sd = scan_record.getServiceData()?.non_null()?;
+    let sd = sd.entrySet()?.non_null()?;
+    for entry in JavaIterator(sd.iterator()?.non_null()?) {
+        let entry: Local<Map_Entry> = entry.cast()?;
+        let key: Local<ParcelUuid> = entry.getKey()?.non_null()?.cast()?;
+        let val: Local<ByteArray> = entry.getValue()?.non_null()?.cast()?;
+        service_data.insert(convert_uuid(key)?, val.as_vec().into_iter().map(|i| i as u8).collect());
     }
 
     // Manufacturer data
     let mut manufacturer_data = None;
-    let msd = scan_record.getManufacturerSpecificData().unwrap().unwrap();
+    let msd = scan_record.getManufacturerSpecificData()?.non_null()?;
     // TODO there can be multiple manufacturer data entries, but the bluest API only supports one. So grab just the first.
-    if msd.size().unwrap() != 0 {
-        let val: Local<'_, ByteArray> = msd.valueAt(0).unwrap().unwrap().cast().unwrap();
+    if msd.size()? != 0 {
+        let val: Local<'_, ByteArray> = msd.valueAt(0)?.non_null()?.cast()?;
         manufacturer_data = Some(ManufacturerData {
-            company_id: msd.keyAt(0).unwrap() as _,
+            company_id: msd.keyAt(0)? as _,
             data: val.as_vec().into_iter().map(|i| i as u8).collect(),
         });
     }
@@ -291,6 +300,8 @@ pub extern "system" fn Java_com_github_alexmoon_bluest_android_BluestScanCallbac
         rssi: Some(rssi as _),
     };
     SCAN_CALLBACKS.callback(id, d);
+
+    Ok(())
 }
 
 #[no_mangle]

src/android/mod.rs

@@ -1,4 +1,4 @@
-use jni_glue::Local;
+use jni_glue::{CastError, Local};
 
 use self::bindings::java::lang::Throwable;
 use crate::error::ErrorKind;
@@ -28,6 +28,12 @@ impl From<Local<'_, Throwable>> for crate::Error {
     }
 }
 
+impl From<CastError> for crate::Error {
+    fn from(e: CastError) -> Self {
+        Self::new(ErrorKind::Internal, None, format!("{:?}", e))
+    }
+}
+
 struct JavaIterator<'env>(Local<'env, bindings::java::util::Iterator>);
 
 impl<'env> Iterator for JavaIterator<'env> {
@@ -43,3 +49,20 @@ impl<'env> Iterator for JavaIterator<'env> {
         }
     }
 }
+
+trait OptionExt<T> {
+    fn non_null(self) -> Result<T, crate::Error>;
+}
+
+impl<T> OptionExt<T> for Option<T> {
+    #[track_caller]
+    fn non_null(self) -> Result<T, crate::Error> {
+        self.ok_or_else(|| {
+            crate::Error::new(
+                ErrorKind::Internal,
+                None,
+                "Java call unexpectedly returned null.".to_string(),
+            )
+        })
+    }
+}