git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2022 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.nest.internal.sdm.api;
  14
  15 import static org.eclipse.jetty.http.HttpHeader.*;
  16 import static org.eclipse.jetty.http.HttpMethod.*;
  17 import static org.openhab.binding.nest.internal.sdm.dto.SDMGson.GSON;
  18
  19 import java.io.IOException;
  20 import java.math.BigDecimal;
  21 import java.time.Duration;
  22 import java.util.List;
  23 import java.util.Set;
  24 import java.util.concurrent.ConcurrentHashMap;
  25 import java.util.concurrent.ExecutionException;
  26 import java.util.concurrent.TimeUnit;
  27 import java.util.concurrent.TimeoutException;
  28
  29 import org.eclipse.jdt.annotation.NonNullByDefault;
  30 import org.eclipse.jdt.annotation.Nullable;
  31 import org.eclipse.jetty.client.HttpClient;
  32 import org.eclipse.jetty.client.api.ContentResponse;
  33 import org.eclipse.jetty.client.api.Request;
  34 import org.eclipse.jetty.client.util.StringContentProvider;
  35 import org.openhab.binding.nest.internal.sdm.dto.SDMCommands.SDMCommandRequest;
  36 import org.openhab.binding.nest.internal.sdm.dto.SDMCommands.SDMCommandResponse;
  37 import org.openhab.binding.nest.internal.sdm.dto.SDMDevice;
  38 import org.openhab.binding.nest.internal.sdm.dto.SDMError;
  39 import org.openhab.binding.nest.internal.sdm.dto.SDMError.SDMErrorDetails;
  40 import org.openhab.binding.nest.internal.sdm.dto.SDMListDevicesResponse;
  41 import org.openhab.binding.nest.internal.sdm.dto.SDMListRoomsResponse;
  42 import org.openhab.binding.nest.internal.sdm.dto.SDMListStructuresResponse;
  43 import org.openhab.binding.nest.internal.sdm.dto.SDMRoom;
  44 import org.openhab.binding.nest.internal.sdm.dto.SDMStructure;
  45 import org.openhab.binding.nest.internal.sdm.exception.FailedSendingSDMDataException;
  46 import org.openhab.binding.nest.internal.sdm.exception.InvalidSDMAccessTokenException;
  47 import org.openhab.binding.nest.internal.sdm.exception.InvalidSDMAuthorizationCodeException;
  48 import org.openhab.binding.nest.internal.sdm.listener.SDMAPIRequestListener;
  49 import org.openhab.core.auth.client.oauth2.AccessTokenResponse;
  50 import org.openhab.core.auth.client.oauth2.OAuthClientService;
  51 import org.openhab.core.auth.client.oauth2.OAuthException;
  52 import org.openhab.core.auth.client.oauth2.OAuthFactory;
  53 import org.openhab.core.auth.client.oauth2.OAuthResponseException;
  54 import org.openhab.core.io.net.http.HttpClientFactory;
  55 import org.slf4j.Logger;
  56 import org.slf4j.LoggerFactory;
  57
  58 /**
  59  * The {@link SDMAPI} implements the SDM REST API which allows for querying Nest device, structure and room information
  60  * as well as executing device commands.
  61  *
  62  * @author Wouter Born - Initial contribution
  63  *
  64  * @see https://developers.google.com/nest/device-access/reference/rest
  65  */
  66 @NonNullByDefault
  67 public class SDMAPI {
  68
  69     private static final String AUTH_URL = "https://accounts.google.com/o/oauth2/auth";
  70     private static final String TOKEN_URL = "https://accounts.google.com/o/oauth2/token";
  71     private static final String REDIRECT_URI = "https://www.google.com";
  72
  73     private static final String SDM_HANDLE_FORMAT = "%s.sdm";
  74     private static final String SDM_SCOPE = "https://www.googleapis.com/auth/sdm.service";
  75
  76     private static final String SDM_URL_PREFIX = "https://smartdevicemanagement.googleapis.com/v1/enterprises/";
  77
  78     private static final String APPLICATION_JSON = "application/json";
  79     private static final String BEARER = "Bearer ";
  80     private static final String IMAGE_JPEG = "image/jpeg";
  81
  82     private static final Duration REQUEST_TIMEOUT = Duration.ofMinutes(1);
  83
  84     private final Logger logger = LoggerFactory.getLogger(SDMAPI.class);
  85
  86     private final HttpClient httpClient;
  87     private final OAuthClientService oAuthService;
  88     private final String projectId;
  89
  90     private final Set<SDMAPIRequestListener> requestListeners = ConcurrentHashMap.newKeySet();
  91
  92     public SDMAPI(HttpClientFactory httpClientFactory, OAuthFactory oAuthFactory, String ownerId, String projectId,
  93             String clientId, String clientSecret) {
  94         this.httpClient = httpClientFactory.getCommonHttpClient();
  95         this.oAuthService = oAuthFactory.createOAuthClientService(String.format(SDM_HANDLE_FORMAT, ownerId), TOKEN_URL,
  96                 AUTH_URL, clientId, clientSecret, SDM_SCOPE, false);
  97         this.projectId = projectId;
  98     }
  99
 100     public void dispose() {
 101         requestListeners.clear();
 102     }
 103
 104     public void authorizeClient(String authorizationCode) throws InvalidSDMAuthorizationCodeException, IOException {
 105         try {
 106             oAuthService.getAccessTokenResponseByAuthorizationCode(authorizationCode, REDIRECT_URI);
 107         } catch (OAuthException | OAuthResponseException e) {
 108             throw new InvalidSDMAuthorizationCodeException(
 109                     "Failed to authorize SDM client. Check the authorization code or generate a new one.", e);
 110         }
 111     }
 112
 113     public void checkAccessTokenValidity() throws InvalidSDMAccessTokenException, IOException {
 114         getAuthorizationHeader();
 115     }
 116
 117     public void addRequestListener(SDMAPIRequestListener listener) {
 118         requestListeners.add(listener);
 119     }
 120
 121     public void removeRequestListener(SDMAPIRequestListener listener) {
 122         requestListeners.remove(listener);
 123     }
 124
 125     public <T extends SDMCommandResponse> @Nullable T executeDeviceCommand(String deviceId,
 126             SDMCommandRequest<T> request) throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 127         logger.debug("Executing device command for: {}", deviceId);
 128         String requestContent = GSON.toJson(request);
 129         String responseContent = postJson(getDeviceUrl(deviceId) + ":executeCommand", requestContent);
 130         return GSON.fromJson(responseContent, request.getResponseClass());
 131     }
 132
 133     private String getAuthorizationHeader() throws InvalidSDMAccessTokenException, IOException {
 134         try {
 135             AccessTokenResponse response = oAuthService.getAccessTokenResponse();
 136             if (response == null || response.getAccessToken() == null || response.getAccessToken().isEmpty()) {
 137                 throw new InvalidSDMAccessTokenException("No SDM access token. Client may not have been authorized.");
 138             }
 139             return BEARER + response.getAccessToken();
 140         } catch (OAuthException | OAuthResponseException e) {
 141             throw new InvalidSDMAccessTokenException(
 142                     "Error fetching SDM access token. Check the authorization code or generate a new one.", e);
 143         }
 144     }
 145
 146     public byte[] getCameraImage(String url, String token, @Nullable BigDecimal imageWidth,
 147             @Nullable BigDecimal imageHeight) throws FailedSendingSDMDataException {
 148         try {
 149             logger.debug("Getting camera image from: {}", url);
 150
 151             Request request = httpClient.newRequest(url) //
 152                     .method(GET) //
 153                     .header(ACCEPT, IMAGE_JPEG) //
 154                     .header(AUTHORIZATION, token) //
 155                     .timeout(REQUEST_TIMEOUT.toNanos(), TimeUnit.NANOSECONDS);
 156
 157             if (imageWidth != null) {
 158                 request = request.param("width", Long.toString(imageWidth.longValue()));
 159             } else if (imageHeight != null) {
 160                 request = request.param("height", Long.toString(imageHeight.longValue()));
 161             }
 162
 163             ContentResponse contentResponse = request.send();
 164             logResponseErrors(contentResponse);
 165             logger.debug("Retrieved camera image from: {}", url);
 166             requestListeners.forEach(SDMAPIRequestListener::onSuccess);
 167             return contentResponse.getContent();
 168         } catch (ExecutionException | InterruptedException | TimeoutException e) {
 169             logger.debug("Failed to get camera image", e);
 170             FailedSendingSDMDataException exception = new FailedSendingSDMDataException("Failed to get camera image",
 171                     e);
 172             requestListeners.forEach(listener -> listener.onError(exception));
 173             throw exception;
 174         }
 175     }
 176
 177     public @Nullable SDMDevice getDevice(String deviceId)
 178             throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 179         logger.debug("Getting device: {}", deviceId);
 180         return GSON.fromJson(getJson(getDeviceUrl(deviceId)), SDMDevice.class);
 181     }
 182
 183     public @Nullable SDMStructure getStructure(String structureId)
 184             throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 185         logger.debug("Getting structure: {}", structureId);
 186         return GSON.fromJson(getJson(getStructureUrl(structureId)), SDMStructure.class);
 187     }
 188
 189     public @Nullable SDMRoom getRoom(String structureId, String roomId)
 190             throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 191         logger.debug("Getting structure {} room: {}", structureId, roomId);
 192         return GSON.fromJson(getJson(getRoomUrl(structureId, roomId)), SDMRoom.class);
 193     }
 194
 195     private String getProjectUrl() {
 196         return SDM_URL_PREFIX + projectId;
 197     }
 198
 199     private String getDevicesUrl() {
 200         return getProjectUrl() + "/devices";
 201     }
 202
 203     private String getDevicesUrl(String pageToken) {
 204         return getDevicesUrl() + "?pageToken=" + pageToken;
 205     }
 206
 207     private String getDeviceUrl(String deviceId) {
 208         return getDevicesUrl() + "/" + deviceId;
 209     }
 210
 211     private String getStructuresUrl() {
 212         return getProjectUrl() + "/structures";
 213     }
 214
 215     private String getStructuresUrl(String pageToken) {
 216         return getStructuresUrl() + "?pageToken=" + pageToken;
 217     }
 218
 219     private String getStructureUrl(String structureId) {
 220         return getStructuresUrl() + "/" + structureId;
 221     }
 222
 223     private String getRoomsUrl(String structureId) {
 224         return getStructureUrl(structureId) + "/rooms";
 225     }
 226
 227     private String getRoomsUrl(String structureId, String pageToken) {
 228         return getRoomsUrl(structureId) + "?pageToken=" + pageToken;
 229     }
 230
 231     private String getRoomUrl(String structureId, String roomId) {
 232         return getRoomsUrl(structureId) + "/" + roomId;
 233     }
 234
 235     public List<SDMDevice> listDevices() throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 236         logger.debug("Listing devices");
 237         SDMListDevicesResponse response = GSON.fromJson(getJson(getDevicesUrl()), SDMListDevicesResponse.class);
 238         List<SDMDevice> result = response == null ? List.of() : response.devices;
 239         while (response != null && !response.nextPageToken.isEmpty()) {
 240             response = GSON.fromJson(getJson(getDevicesUrl(response.nextPageToken)), SDMListDevicesResponse.class);
 241             if (response != null) {
 242                 result.addAll(response.devices);
 243             }
 244         }
 245         return result;
 246     }
 247
 248     public List<SDMStructure> listStructures() throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 249         logger.debug("Listing structures");
 250         SDMListStructuresResponse response = GSON.fromJson(getJson(getStructuresUrl()),
 251                 SDMListStructuresResponse.class);
 252         List<SDMStructure> result = response == null ? List.of() : response.structures;
 253         while (response != null && !response.nextPageToken.isEmpty()) {
 254             response = GSON.fromJson(getJson(getStructuresUrl(response.nextPageToken)),
 255                     SDMListStructuresResponse.class);
 256             if (response != null) {
 257                 result.addAll(response.structures);
 258             }
 259         }
 260         return result;
 261     }
 262
 263     public List<SDMRoom> listRooms(String structureId)
 264             throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 265         logger.debug("Listing rooms for structure: {}", structureId);
 266         SDMListRoomsResponse response = GSON.fromJson(getJson(getRoomsUrl(structureId)), SDMListRoomsResponse.class);
 267         List<SDMRoom> result = response == null ? List.of() : response.rooms;
 268         while (response != null && !response.nextPageToken.isEmpty()) {
 269             response = GSON.fromJson(getJson(getRoomsUrl(structureId, response.nextPageToken)),
 270                     SDMListRoomsResponse.class);
 271             if (response != null) {
 272                 result.addAll(response.rooms);
 273             }
 274         }
 275         return result;
 276     }
 277
 278     private void logResponseErrors(ContentResponse contentResponse) {
 279         if (contentResponse.getStatus() >= 400) {
 280             logger.debug("SDM API error: {}", contentResponse.getContentAsString());
 281
 282             SDMError error = GSON.fromJson(contentResponse.getContentAsString(), SDMError.class);
 283             SDMErrorDetails details = error == null ? null : error.error;
 284
 285             if (details != null && !details.message.isBlank()) {
 286                 logger.warn("SDM API error: {}", details.message);
 287             } else {
 288                 logger.warn("SDM API error: {} (HTTP {})", contentResponse.getReason(), contentResponse.getStatus());
 289             }
 290         }
 291     }
 292
 293     private String getJson(String url) throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 294         try {
 295             logger.debug("Getting JSON from: {}", url);
 296             ContentResponse contentResponse = httpClient.newRequest(url) //
 297                     .method(GET) //
 298                     .header(ACCEPT, APPLICATION_JSON) //
 299                     .header(AUTHORIZATION, getAuthorizationHeader()) //
 300                     .timeout(REQUEST_TIMEOUT.toNanos(), TimeUnit.NANOSECONDS) //
 301                     .send();
 302             logResponseErrors(contentResponse);
 303             String response = contentResponse.getContentAsString();
 304             logger.debug("Response: {}", response);
 305             requestListeners.forEach(SDMAPIRequestListener::onSuccess);
 306             return response;
 307         } catch (ExecutionException | InterruptedException | IOException | TimeoutException e) {
 308             logger.debug("Failed to send JSON GET request", e);
 309             FailedSendingSDMDataException exception = new FailedSendingSDMDataException(
 310                     "Failed to send JSON GET request", e);
 311             requestListeners.forEach(listener -> listener.onError(exception));
 312             throw exception;
 313         }
 314     }
 315
 316     private String postJson(String url, String requestContent)
 317             throws FailedSendingSDMDataException, InvalidSDMAccessTokenException {
 318         try {
 319             logger.debug("Posting JSON to: {}", url);
 320             ContentResponse contentResponse = httpClient.newRequest(url) //
 321                     .method(POST) //
 322                     .header(ACCEPT, APPLICATION_JSON) //
 323                     .header(AUTHORIZATION, getAuthorizationHeader()) //
 324                     .content(new StringContentProvider(requestContent), APPLICATION_JSON) //
 325                     .timeout(REQUEST_TIMEOUT.toNanos(), TimeUnit.NANOSECONDS) //
 326                     .send();
 327             logResponseErrors(contentResponse);
 328             String response = contentResponse.getContentAsString();
 329             logger.debug("Response: {}", response);
 330             requestListeners.forEach(SDMAPIRequestListener::onSuccess);
 331             return response;
 332         } catch (ExecutionException | InterruptedException | IOException | TimeoutException e) {
 333             logger.debug("Failed to send JSON POST request", e);
 334             FailedSendingSDMDataException exception = new FailedSendingSDMDataException(
 335                     "Failed to send JSON POST request", e);
 336             requestListeners.forEach(listener -> listener.onError(exception));
 337             throw exception;
 338         }
 339     }
 340 }