00. Liste des appareils

Découvre tous les appareils Haply connectés via l'API REST HTTP — sans WebSocket requis. Un test de base pour vérifier que l'environnement d'exécution est opérationnel et détecte le matériel.

Ce que vous allez apprendre :

• Interroger GET /devices pour lister les appareils Inverse3, VerseGrip et VerseGrip sans fil
• Lire les identifiants des appareils dans la réponse JSON, regroupés par type d'appareil
• Utiliser un sélecteur de session pour basculer entre les coordonnées brutes des appareils et la vue de l'espace d'application d'une session

Déroulement

1. Envoyez GET http://localhost:10001/devices.
2. Analysez la réponse JSON — trois tableaux de premier niveau : inverse3, verse_grip, wireless_verse_grip.
3. Affichez les identifiants des appareils regroupés par type. Un tableau vide signifie qu'aucun appareil de ce type n'est détecté.
4. Si un sélecteur de session est ajouté sous la forme ?session=<selector>, la réponse est filtrée selon les appareils de cette session et les coordonnées sont converties dans son espace d'application (base, montage et espace de travail appliqués). L'exemple Python expose ceci sous forme d'argument CLI --session SELECTOR (accepte :profile:instance, #id, :-1, :0, …) — le même indicateur, avec le même texte d'aide que celui utilisé dans le tutoriel 08 (HTTP : configuration à distance), de sorte qu'un sélecteur trouvé ici peut être collé directement là-bas. Les exemples C++ interrogent sans sélecteur.

Paramètres

Paramètre	Par défaut	Rôle
URL du service	http://localhost:10001	URL de base de HTTP
Point de terminaison	/devices	Point de terminaison de découverte des appareils
Sélecteur de session	(aucun)	?session=:0, ?session=:-1, ?session=:my_profile:0, ?session=co.haply.hub::*:0 (caractères génériques pris en charge) — voir Sélecteurs. Exposé sous la forme --session SELECTOR dans l'exemple Python (même indicateur que le tutoriel 08).

Code clé

Python

L'exemple Python expose le sélecteur de session sous forme d'argument argparse --session SELECTOR. Sans lui, les appareils sont renvoyés dans les coordonnées brutes de l'espace de l'appareil ; avec lui, ils sont filtrés selon la session sélectionnée et convertis dans l'espace d'application. Le texte d'aide correspond à celui du tutoriel 08 (HTTP : configuration à distance), de sorte qu'un sélecteur trouvé ici peut être collé directement là-bas.

def parse_args():
    parser = argparse.ArgumentParser(
        description="List connected Haply Inverse devices via the HTTP API.")
    parser.add_argument(
        "--session", type=str, default="",
        help=(
            "Session selector. Formats:\n"
            "  :profile:instance   by profile name (e.g. ':my_profile:0')\n"
            "  pattern:instance    glob wildcard in profile (e.g. 'co.haply.hub::*:0')\n"
            "                      '*' matches any sequence, '?' one character\n"
            "  #session_id         by numeric id (e.g. '#42' — quote in shells to escape '#')\n"
            "  :-1                 the last active session\n"
            "  :0                  the first session"
        ))
    return parser.parse_args()

def main():
    args    = parse_args()
    session = args.session or None

    url = f"{BASE_URL}/devices"
    if session:
        url += f"?session={session}"
        print(f"Querying devices for session '{session}' (application space)\n")
    else:
        print("Querying all detected devices (device space)\n")

    r = requests.get(url, timeout=3)
    r.raise_for_status()
    data = r.json()

    print_devices("Inverse3", data.get("inverse3"))
    print_devices("Wired Verse Grip", data.get("verse_grip"))
    print_devices("Wireless Verse Grip", data.get("wireless_verse_grip"))

C++ (nlohmann)

La variante C++ utilise libhv pour HTTP et nlohmann/json pour l'analyse. Elle vérifie manuellement chaque clé de premier niveau avec contains() et parcourt le tableau s'il n'est pas vide. Les exemples C++ n'exposent pas l'argument CLI du sélecteur de session — ajoutez ?session=<selector> à l'URL si vous avez besoin des coordonnées de l'espace d'application.

HttpResponsePtr resp = requests::get("localhost:10001/devices");
if (resp == nullptr) { /* ... error ... */ return 1; }

json data = json::parse(resp->body);

if (data.contains("inverse3") && !data["inverse3"].empty()) {
    printf("Inverse3 found:\n");
    for (auto &element : data["inverse3"]) {
        printf("   (id: %s)\n", element["device_id"].get<std::string>().c_str());
    }
}
// ... same pattern for verse_grip and wireless_verse_grip

C++ (Glaze)

La variante Glaze déclare des structures simples qui reproduisent la forme JSON — Glaze les remplit par réflexion à la compilation. Aucune vérification contains() n'est nécessaire : les tableaux absents sont renvoyés vides sous forme de std::vector<>.

static constexpr glz::opts glz_settings{.error_on_unknown_keys = false};

struct device_entry { std::string device_id; };
struct devices_response {
    std::vector<device_entry> inverse3;
    std::vector<device_entry> verse_grip;
    std::vector<device_entry> wireless_verse_grip;
};

// In main():
HttpResponsePtr resp = requests::get("localhost:10001/devices");
devices_response data;
if (auto err = glz::read<glz_settings>(data, resp->body)) {
    printf("JSON parse error: %s\n", glz::format_error(err, resp->body).c_str());
    return 1;
}

for (const auto &dev : data.inverse3) {
    printf("   (id: %s)\n", dev.device_id.c_str());
}

Inclus dans le programme d'installation du SDK

Le tutoriel 00 est aussi installé localement avec le SDK — consultez tutorials/00-haply-inverse-device-list/ dans le répertoire d'installation du service.

Source : Python · C++ · C++ Glaze

Voir aussi : Conventions JSON · Sélecteurs · Sessions