haply 1.3.1

Haply Robotics Client Library for the Inverse Service
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! Session profile naming — set and verify via HTTP or WS.
//!
//! Usage:
//!   cargo run --example profile_demo

use haply::{
    device_model::{ ProfileConfig, SessionConfigure },
    http::InverseHttpClient,
    HaplyDevice,
};
use std::time::Duration;
use tokio::time::sleep;

const USE_HTTP: bool = false;
const HTTP_BASE: &str = "http://localhost:10001";
const WS_URL: &str = "ws://localhost:10001/";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // WS connection always needed (creates the session)
    let mut device = HaplyDevice::new(HTTP_BASE, WS_URL).await?;
    let http = InverseHttpClient::new(HTTP_BASE);
    println!("Connected");

    sleep(Duration::from_millis(300)).await;
    let state = device.read_state().await?;
    let session_id = state.session_id;
    println!("Session ID: {}", session_id);

    // Show current profile
    if let Some(s) = &state.session {
        if let Some(c) = &s.config {
            if let Some(p) = &c.profile {
                println!("Current profile: {}", p.name);
            }
        }
    }

    let new_name = "test_profile";
    println!("Setting profile to '{}'...", new_name);

    if USE_HTTP {
        http.set_session_profile(
            session_id,
            &(ProfileConfig {
                name: new_name.to_string(),
                required_version: Some(">=3.5".to_string()),
            })
        ).await?;

        let confirmed = http.get_session_profile(session_id).await?;
        println!("HTTP confirmed profile: {}", confirmed.name);
    } else {
        device.configure_session(
            SessionConfigure {
                profile: Some(ProfileConfig {
                    name: new_name.to_string(),
                    required_version: Some(">=3.5".to_string()),
                }),
                basis: None,
                serialization: None,
                sdf: None,
            },
            Some(true)
        ).await?;

        // Request full state to get config (streaming frames don't include config)
        sleep(Duration::from_millis(100)).await;
        device.send_force_full_render().await?;
        sleep(Duration::from_millis(200)).await;
        let state = device.read_state().await?;
        if let Some(s) = &state.session {
            if let Some(c) = &s.config {
                if let Some(p) = &c.profile {
                    println!("WS confirmed profile: {}", p.name);
                }
            }
        } else {
            println!(
                "WS: session info not available (profile was sent but config not echoed in streaming frames)"
            );
        }
    }

    device.shutdown().await?;
    println!("Done");
    Ok(())
}