get build-date, structure a bunch of stuff to get device info

Author: wdouglass

rust/libmultisense-ambarella/src/lib.rs

@@ -3,10 +3,15 @@ use str0m::{change::SdpOffer, Candidate, Rtc};
 use systemstat::{Platform, System};
 
 pub struct MswebrtcImpl {
+    host: String,
     pc: Rtc,
     sockets: Vec<UdpSocket>,
 }
 
+struct Info {
+    builddate: String,
+}
+
 #[allow(dead_code)]
 #[derive(Debug)]
 pub struct MswebrtcError {
@@ -15,14 +20,14 @@ pub struct MswebrtcError {
 }
 
 impl MswebrtcImpl {
-    fn connect_internal(&mut self, host: String) -> Result<(), MswebrtcError> {
+    fn connect(&mut self) -> Result<(), MswebrtcError> {
         let client = reqwest::blocking::Client::builder()
             .danger_accept_invalid_certs(true)
             .build()
             .unwrap();
         let offer = SdpOffer::from_sdp_string(
             client
-                .get(host.clone() + "/offer")
+                .get(self.host.clone() + "/offer")
                 .send()
                 .map_err(|e| MswebrtcError {
                     what: "Failed to request offer".to_owned(),
@@ -98,7 +103,7 @@ impl MswebrtcImpl {
             err: Some(Box::new(e)),
         })?;
         client
-            .post(host + "/answer")
+            .post(self.host.clone() + "/answer")
             .header("content-type", "application/json")
             .body(answer)
             .send()
@@ -108,45 +113,85 @@ impl MswebrtcImpl {
                 err: Some(Box::new(e)),
             })?
     }
-    fn connect(&mut self, host: String) -> bool {
-        match self.connect_internal(host) {
-            Ok(_) => true,
-            Err(e) => {
-                println!("ERROR CONNECTING: {:?}", e);
-                false
-            }
-        }
-    }
     fn disconnect(&self) {
         println!("DISCONNECT");
     }
+
+    fn get_info(&self) -> Result<Info, MswebrtcError> {
+        let client = reqwest::blocking::Client::builder()
+            .danger_accept_invalid_certs(true)
+            .build()
+            .unwrap();
+        let j = client
+            .get(self.host.clone() + "/info.json")
+            .send()
+            .map_err(|e| MswebrtcError {
+                what: "Failed to request offer".to_owned(),
+                err: Some(Box::new(e)),
+            })?;
+        let j = j.text().map_err(|e| MswebrtcError {
+            what: "Failed to extract offer from HTTP response".to_owned(),
+            err: Some(Box::new(e)),
+        })?;
+        let j: serde_json::Value = serde_json::from_str(j.as_str()).map_err(|e| MswebrtcError {
+            what: "Failed to parse info.json".to_owned(),
+            err: Some(Box::new(e)),
+        })?;
+        Ok(Info {
+            builddate: j["build-time"].to_string(),
+        })
+    }
 }
 
 #[no_mangle]
-pub extern "C" fn create_mswebrtc_impl() -> *mut MswebrtcImpl {
+pub extern "C" fn create_mswebrtc_impl(host: *const std::ffi::c_char) -> *mut MswebrtcImpl {
     let pc = Rtc::new();
     let out = Box::new(MswebrtcImpl {
+        host: unsafe { std::ffi::CStr::from_ptr(host) }
+            .to_str()
+            .unwrap()
+            .to_string(),
         pc: pc,
         sockets: Vec::new(),
     });
     Box::into_raw(out)
 }
 
 #[no_mangle]
-pub extern "C" fn connect_mswebrtc_impl(
+pub extern "C" fn connect_mswebrtc_impl(obj: *mut MswebrtcImpl) -> bool {
+    let r = unsafe { &mut *obj };
+    match r.connect() {
+        Ok(_) => true,
+        Err(e) => {
+            println!("ERROR CONNECTING: {:?}", e);
+            false
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn get_info_mswebrtc_impl(
     obj: *mut MswebrtcImpl,
-    addr: *const std::ffi::c_char,
+    mut buildtime: *mut std::ffi::c_char,
 ) -> bool {
-    let (r, addr) = unsafe {
-        (
-            &mut *obj,
-            std::ffi::CStr::from_ptr(addr as *const i8)
-                .to_str()
-                .unwrap()
-                .to_string(),
-        )
-    };
-    r.connect(addr)
+    let r = unsafe { &*obj };
+    let i = r.get_info();
+    match i {
+        Ok(i) => {
+            for (i, c) in i.builddate.chars().enumerate() {
+                unsafe { *buildtime = c as std::ffi::c_char };
+                buildtime = buildtime.wrapping_add(1);
+                if i >= 31 {
+                    break;
+                }
+            }
+            true
+        }
+        Err(e) => {
+            println!("ERROR Getting Info: {:?}", e);
+            false
+        }
+    }
 }
 
 #[no_mangle]

source/LibMultiSense/details/mswebrtc/channel.cc

@@ -40,7 +40,7 @@
 namespace multisense {
 namespace mswebrtc {
 
-    MswebrtcChannel::MswebrtcChannel(const Config &):impl(create_mswebrtc_impl())
+MswebrtcChannel::MswebrtcChannel(const Config &c):impl(create_mswebrtc_impl(c.ip_address.c_str()))
 {
 }
 
@@ -70,9 +70,9 @@ void MswebrtcChannel::add_imu_frame_callback(std::function<void(const ImuFrame&)
     CRL_EXCEPTION("NOT IMPLEMENTED");
 }
 
-Status MswebrtcChannel::connect(const Config &conf)
+Status MswebrtcChannel::connect(const Config &)
 {
-    if (connect_mswebrtc_impl(impl, conf.ip_address.c_str())) {
+    if (connect_mswebrtc_impl(impl)) {
         return Status::OK;
     }
     else {
@@ -117,7 +117,11 @@ Status MswebrtcChannel::set_calibration(const StereoCalibration &)
 
 MultiSenseInfo MswebrtcChannel::get_info()
 {
-    CRL_EXCEPTION("NOT IMPLEMENTED");
+    char builddate[32] = {};
+    MultiSenseInfo out = {};
+    get_info_mswebrtc_impl(impl, builddate);
+    out.version.firmware_build_date = std::string(builddate);
+    return out;
 }
 
 Status MswebrtcChannel::set_device_info(const MultiSenseInfo::DeviceInfo &, const std::string &)

source/LibMultiSense/include/MultiSense/MultiSenseTypes.hh

@@ -1622,7 +1622,7 @@ struct MultiSenseInfo
         ///
         MultiSenseInfo::Version firmware_version{};
 
-        ///
+        ///1
         /// @brief ID for the version of hardware
         ///
         uint64_t hardware_version = 0;