En Google, luchamos por la equidad racial de la comunidad negra. Más información

Ejemplos de lectura de API

Fuera

Utilice la API de Nest para escuchar cambios en estructuras y dispositivos, de modo que pueda tomar medidas para ahorrar energía cuando los propietarios no estén, notificarles que algo anda mal (por ejemplo, la puerta del garaje está abierta) o activar funciones para hacer que el hogar más cómodo y acogedor.

Esta guía muestra cómo leer datos de estructuras y dispositivos Nest. Para aprender cómo hacer llamadas de escritura, ver ejemplos de la API de escritura .

Prerrequisitos

Antes de hacer llamadas a la API, obtener un token de acceso, como se describe en autenticación con OAuth 2.0 .

Acerca de las llamadas de lectura REST

Para llamadas REST, use GET para leer datos.

Las llamadas de lectura REST son útiles en escenarios limitados, como los siguientes casos de uso:

  • Llamadas puntuales ad-hoc
  • Laboratorios de prueba de concepto
  • Solución de problemas
  • Aplicaciones que sondean aproximadamente cada minuto
  • Implementaciones de botones de actualización

Las llamadas de lectura REST no son útiles para escenarios continuos en tiempo real o de transmisión.

Autenticación de portador

Recomendamos el cumplimiento de la norma OAuth , que ofrece una mayor seguridad mediante el uso de "Bearer" de autenticación para transmitir el token de acceso. No se recomiendan las llamadas con credenciales de cliente en la URL.

El "Content-Type" cabecera dirige el servidor para utilizar JSON.

La "Authorization" encabezado proporciona acceso a la API.

Ejemplos de

En los siguientes ejemplos, reemplace YOUR_TOKEN_HERE con su token de acceso específico, como "c.twC2q ...".

Leer estructuras y dispositivos

Para leer toda la estructura y los datos del dispositivo (nivel base), use la URL de nivel raíz. Para obtener respuestas más detalladas, modifique la URL según sea necesario.

Rizo
curl -v --location-trusted \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN_HERE" \
  -X GET "https://developer-api.nest.com/"
Multiplex de curl
curl -v --location-trusted \
  -H "Accept: text/event-stream" \
  -H "Authorization: Bearer LIST_OF_ACCESS_TOKENS" \
  -X GET "https://developer-api.nest.com/multiplex"
Ir
package main

import (
    "errors"
    "fmt"
    "io/ioutil"
    "net/http"
)

const token = "YOUR_TOKEN_HERE" // Update with your token

func main() {
    url := "https://developer-api.nest.com/"
    req, _ := http.NewRequest(http.MethodGet, url, nil)

    req.Header.Add(
        "Authorization",
        fmt.Sprintf("Bearer %s", token),
    )

    customClient := http.Client {
        CheckRedirect: func(redirRequest *http.Request, via []*http.Request) error {
            // Go's http.DefaultClient does not forward headers when a redirect 3xx
            // response is received. Thus, the header (which in this case contains the
            // Authorization token) needs to be passed forward to the redirect
            // destinations.
            redirRequest.Header = req.Header

            // Go's http.DefaultClient allows 10 redirects before returning an
            // an error. We have mimicked this default behavior.
            if len(via) >= 10 {
                return errors.New("stopped after 10 redirects")
            }
            return nil
        },
    }

    response, _ := customClient.Do(req)

    if response.StatusCode != 200 {
        panic(fmt.Sprintf(
            "Expected a 200 status code; got a %d",
            response.StatusCode,
        ))
    }

    defer response.Body.Close()
    body, _ := ioutil.ReadAll(response.Body)
    fmt.Println(string(body))

}
Node.js
"use strict"

var request = require('request');

var token = "YOUR_TOKEN_HERE"; // Update with your token

var url = "https://developer-api.nest.com";

var options = {
    "method": "GET",
    "path": "/",
    "headers": {
       "Authorization": "Bearer " + token
    },
    "followRedirect": true
};

var req = request(url, options, function(err, resp, data) {
    console.log('response code: ' + resp.statusCode);
    if (err) {
        console.log('Error: ' + err.message);
    }
    console.log("data: " + data);
});

req.end();

Para utilizar el ejemplo de código Node.js, instalar el módulo de petición ( https://www.npmjs.com/package/request ).

npm install request
Python 2
import hashlib
import json
import os
import requests

url = "https://developer-api.nest.com/"

token = "YOUR_TOKEN_HERE" # Update with your token

headers = {'Authorization': 'Bearer {0}'.format(token), 'Content-Type': 'application/json'}

response = requests.get(url, headers=headers, allow_redirects=False)
if response.status_code == 307:
    response = requests.get(response.headers['Location'], headers=headers, allow_redirects=False)

print(response.text)
Python 3
import http.client
from urllib.parse import urlparse

token = "YOUR_TOKEN_HERE" # Update with your token

conn = http.client.HTTPSConnection("developer-api.nest.com")
headers = {'authorization': "Bearer {0}".format(token)}
conn.request("GET", "/", headers=headers)
response = conn.getresponse()

if response.status == 307:
    redirectLocation = urlparse(response.getheader("location"))
    conn = http.client.HTTPSConnection(redirectLocation.netloc)
    conn.request("GET", "/", headers=headers)
    response = conn.getresponse()
    if response.status != 200:
        raise Exception("Redirect with non 200 response")

data = response.read()
print(data.decode("utf-8"))
Java
import java.io.IOException;
import okhttp3.Headers;
import okhttp3.OkHttpClient;
import okhttp3.OkHttpClient.Builder;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.Authenticator;
import okhttp3.Route;

public class ReadNest {

    public static void main(String[] args) throws IOException {
        String auth = "Bearer YOUR_TOKEN_HERE"; // Update with your token

        OkHttpClient client = new OkHttpClient.Builder()
        .authenticator(new Authenticator() {
          @Override public Request authenticate(Route route, Response response) throws IOException {
            return response.request().newBuilder()
                .header("Authorization", auth)
                .build();
          }
        })
        .followRedirects(true)
        .followSslRedirects(true)
        .build();

        Request request = new Request.Builder()
        .url("https://developer-api.nest.com")
        .get()
        .addHeader("content-type", "application/json; charset=UTF-8")
        .addHeader("authorization", auth)
        .build();

        try {
            System.out.println("Begin request:  ");
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
            System.out.println("End request");
            System.out.println();
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {
                e.printStackTrace();
        }
   }
}

Para usar el ejemplo de código Java:

1. Descarga la última archivos Jar Okio okhttp y al http://square.github.io/okhttp/ . Además, la descarga de archivos Kotlin stdlib en https://mvnrepository.com/artifact/org.jetbrains.kotlin/kotlin-stdlib si su versión de okhttp depende de ello.

2. Construya su código.

3. Compile y ejecute el programa con la siguiente configuración de ruta de clases.

Sustituir los números de versión de la biblioteca en el javac y java comandos siguientes:
javac -cp .:okhttp-<ver>.jar:okio-<ver>.jar ReadNest.java
java -cp .:okhttp-<ver>.jar:okio-<ver>.jar:kotlin-stdlib-<ver>.jar ReadNest

Por ejemplo, si usted tiene las siguientes versiones 3.11.0, 2.1.0, y 1.3.0, los comandos se vería así:
javac -cp .:okhttp-3.11.0.jar:okio-2.1.0.jar ReadNest.java
java -cp .:okhttp-3.11.0.jar:okio-2.1.0.jar:kotlin-stdlib-1.3.0.jar ReadNest

Usando Postman para probar la API

La llamada de Curl anterior se puede replicar fácilmente en Postman.

PONER encabezado para escribir

Utilice el enlace Código de cartero para traducir una llamada en diferentes idiomas como punto de partida para un mayor desarrollo.