00. Liste des appareils

Découvrez tous les appareils Haply connectés via l'API REST HTTP — sans avoir besoin de WebSocket. Un test de base pour vérifier que l'environnement d'exécution fonctionne correctement et détecte le matériel.

Ce que vous allez apprendre :

• Interroger GET /devices pour consulter la liste des 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. Envoyer 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'a été détecté.
4. Si un sélecteur de session est ajouté sous la forme ?session=<selector>, la réponse est filtrée en fonction des 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 présente cela sous forme d'argument de ligne de commande --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 n° 8 (HTTP : configuration à distance), de sorte qu'un sélecteur trouvé ici peut être copié-collé directement là-bas. Les exemples en C++ effectuent la requête sans sélecteur.

Paramètres

Paramètre	Par défaut	Rôle
URL du service	http://localhost:10001	URL de base HTTP
Point d'arrivée	/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. Présenté sous la forme --session SELECTOR dans l'exemple Python (même indicateur que le tutoriel 08).

Code clé

Python

L'exemple Python présente le sélecteur de session sous la forme d'un 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 en fonction de la session sélectionnée et convertis dans l'espace d'application. Le texte d'aide correspond à celui du Tutoriel n° 8 (HTTP : configuration à distance), de sorte qu'un sélecteur trouvé ici peut être copié-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 en C++ ne mentionnent 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 le format JSON — Glaze les remplit par réflexion lors de la compilation. Aucune vérification contains() n'est pas nécessaire : les tableaux manquants sont renvoyés vides sous la 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 également 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