Disponibilité du partage d'écran

Cette page explique comment obtenir une mise à jour des informations d'un appareil à chaque modification.

SSE GET /devices/{id}/stream-status

Cet endpoint utilise le mécanisme SSE (Server-Sent Events), une technologie de communication unidirectionnelle en temps réel. Il permet de recevoir instantanément toutes les mises à jour concernant les informations de status du partage d'écran d'un appareil dans l'API.

Headers

Name

Value

Content-Type

application/json

Authorization

Bearer <token>

Exemples d'implementation

JavaScript possède une implémentation native d'EventSource. Cependant, il est recommandé d'utiliser un polyfill d'EventSource (tel que "event-source-polyfill" dans cet exemple) pour accéder à des fonctionnalités avancées comme la personnalisation des en-têtes, ce qui est essentiel pour l'inclusion du token Bearer.

// Importer le polyfill
const { EventSourcePolyfill } = require('event-source-polyfill');
// Ton Bearer Token
const token = 'votre token';

// Utiliser EventSourcePolyfill pour envoyer le token dans l'en-tête Authorization
const eventSource = new EventSourcePolyfill('https://mdm.pulse-xr.com/devices/:id/stream-status', {
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

eventSource.onopen = function (data) {
  console.log('connection opened ');
};

eventSource.onmessage = function (event) {
  const updatedDevice = JSON.parse(event.data);
  console.log('Mise à jour du device:', updatedDevice);
  if (newMessage.streaming === true) {
    console.log('✅ Stream prêt');
    eventSource.close();
  }
};

eventSource.onerror = function (err) {
  console.error('Erreur dans la connexion SSE:' + err);
};

import requests
import sseclient

# URL du serveur SSE
url = "https://mdm.pulse-xr.com/devices/:id/updates"

# Bearer Token
headers = {
    "Authorization": "Bearer votre_token"
}

# Ouvrir la connexion SSE
response = requests.get(url, headers=headers, stream=True)
client = sseclient.SSEClient(response)

for event in client.events():
    print("Mise à jour du device:", event.data)

import okhttp3.*
import java.io.IOException

fun main() {
    val client = OkHttpClient()

    val request = Request.Builder()
        .url("https://mdm.pulse-xr.com/devices/:id/updates")
        .addHeader("Authorization", "Bearer votre_token")
        .build()

    client.newCall(request).enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) {
            println("Erreur SSE: ${e.message}")
        }

        override fun onResponse(call: Call, response: Response) {
            response.body?.string()?.let {
                println("Mise à jour du device: $it")
            }
        }
    })
}

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using (HttpClient client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer votre_token");
            var response = await client.GetStreamAsync("https://mdm.pulse-xr.com/devices/:id/updates");

            using (StreamReader reader = new StreamReader(response))
            {
                string line;
                while ((line = await reader.ReadLineAsync()) != null)
                {
                    Console.WriteLine($"Mise à jour du device: {line}");
                }
            }
        }
    }
}

package main

import (
	"bufio"
	"fmt"
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://mdm.pulse-xr.com/devices/:id/updates", nil)
	req.Header.Set("Authorization", "Bearer votre_token")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Erreur SSE:", err)
		return
	}
	defer resp.Body.Close()

	scanner := bufio.NewScanner(resp.Body)
	for scanner.Scan() {
		fmt.Println("Mise à jour du device:", scanner.Text())
	}
}

Il faut fermer l’EventSource dès que streaming: true est reçu, car le serveur met fin à la connexion juste après. Cela évite une erreur côté client liée à la fermeture volontaire du flux SSE.

Response

{
	"streaming": boolean
}

PrécédentAjouter le contenu en cours SuivantHistorique d'un appareil

Mis à jour il y a 1 mois

hashtagExemples d'implementation

Exemples d'implementation