00. Liste des appareils

Détecte tous les appareils Haply connectés via l'API HTTP REST, sans avoir besoin de WebSocket. Un simple test de fonctionnement qui vérifie si l'environnement d'exécution est actif et s'il détecte le matériel.

Ce que vous apprendrez :

• Consultation de GET /devices, euh Inverse3, pour répertorier les appareils VerseGrip et VerseGrip sans fil
• Extraction des identifiants des appareils à partir de la réponse JSON, regroupés par type d'appareil
• Utilisation d'un sélecteur de session pour basculer entre les coordonnées brutes de l'appareil et la vue de l'espace applicatif d'une session

Déroulement

1. Envoyez GET http://localhost:10001/devices.
2. Analysez la réponse JSON — trois tableaux de niveau supérieur : inverse3, verse_grip, wireless_verse_grip.
3. Affichez les identifiants des appareils regroupés par type. Les tableaux vides indiquent qu'aucun appareil de ce type n'a été détecté.
4. Si un Sélecteur de session als ?session=<selector> Lorsqu'il est ajouté, la réponse est filtrée en fonction des périphériques de cette session et les coordonnées sont converties dans leur espace d'application (application de la base, du montage et de l'espace de travail). L'exemple Python présente cela sous forme d'argument CLI --session SELECTOR prêt (accepté) :profile:instance, #id, :-1, :0, …) — avec le même indicateur et le même texte d'aide que ceux utilisés par Tutoriel n° 08 (Configuration à distance via HTTP) est utilisé, ce qui permet d'y insérer directement un sélecteur trouvé ici. Les exemples en C++ effectuent la requête sans sélecteur.

Paramètres

Paramètres	Standard	Objet
URL du service	http://localhost:10001	URL de base du protocole HTTP
Point final	/devices	Point de terminaison pour la détection des périphériques
Sélecteur de session	(aucun)	?session=:0, ?session=:-1, ?session=:my_profile:0, ?session=co.haply.hub::*:0 (Les caractères génériques globaux sont pris en charge) — voir Sélecteurs. Dans l'exemple Python, sous la forme --session SELECTOR disponible (même indicateur que Tutoriel 08).

Code important

Python

L'exemple Python présente le sélecteur de session comme argument argparse --session SELECTOR prêt. Sans cet argument, les périphériques sont renvoyés dans leurs coordonnées brutes ; avec cet argument, ils sont filtrés en fonction de la session sélectionnée et convertis dans l'espace de l'application. Le texte d'aide correspond à celui de Tutoriel n° 08 (Configuration à distance via HTTP), de sorte qu'un sélecteur trouvé ici puisse être directement inséré à cet endroit.

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 niveau supérieur à l'aide de contains() et parcourt le tableau, à condition qu'il ne soit pas vide. Les exemples en C++ ne proposent pas l'argument CLI pour le sélecteur de session — ajoutez ?session=<selector> Accédez à cette URL si vous avez besoin de coordonnées dans l'espace de l'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éfinit des structures simples qui reflètent le format JSON — Glaze les remplit au moment de la compilation via la réflexion. Il n'y a pas de contains()- Vérifications nécessaires : les tableaux manquants sont considérés comme vides std::vector<> restitué.

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 — vous le trouverez dans le répertoire d'installation du service, sous tutorials/00-haply-inverse-device-list/ nach.

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

À lire également : Conventions JSON · Sélecteurs · Sessions