bridging/plugins/hue_plugin/hue_objects/hue_light.h

   1 //******************************************************************
   2 //
   3 // Copyright 2017 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20 //
  21
  22
  23 /* This file contains the C++ representation definition of a Hue light */
  24 #ifndef __HUE_LIGHT_H__
  25 #define __HUE_LIGHT_H__
  26
  27 #include <vector>
  28 #include <string>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <map>
  32 #include <memory>
  33 #include <typeinfo>
  34 #include "mpmErrorCode.h"
  35 #include "rapidjson.h"
  36 #include "document.h"
  37 #include "hue_defs.h"
  38 #include "messageHandler.h"
  39
  40
  41 /**
  42  * The HueLight class represents one Hue Light instance. The class
  43  * provides methods to get/set of the desired configuration of the light.
  44  *
  45  * NOTE: A configuration can be build up by calling the desired set* methods
  46  *       followed by a call to put().
  47  *
  48  * For example;
  49  *    setOn(true);
  50  *    setHue(128);
  51  *    setBrightness(131);
  52  *    put();
  53  *
  54  * The representational state of the light is cached in the instance
  55  * but can be refreshed by a call to get();
  56  */
  57 class HueLight
  58 {
  59     public:
  60         typedef std::vector<std::shared_ptr<HueLight> > lights;
  61
  62         typedef struct light_state_tag
  63         {
  64             uint64_t hue;
  65             uint64_t bri;
  66             uint64_t sat;
  67             /* CSC array. Will contain the x, y coordinates. Both will be in [0.0, 1.0]. */
  68             double csc[2];
  69             bool power;
  70             std::string effect;
  71             bool reachable;
  72             std::string alert;
  73             std::string colorMode;
  74             uint16_t ct;
  75
  76             light_state_tag()
  77             {
  78                 hue = bri = sat = ct = 0;
  79                 power = reachable = 0;
  80                 effect.empty();
  81                 alert.empty();
  82                 colorMode.empty();
  83             }
  84
  85             bool operator!=(light_state_tag &state)
  86             {
  87                 return !(*this == state);
  88             }
  89
  90             bool operator==(light_state_tag &state)
  91             {
  92                 /*we only care about following state changes*/
  93                 return state.hue == hue && state.bri == bri && state.sat == sat && state.power == power;
  94             }
  95         } light_state_t;
  96
  97         typedef struct light_config_tag
  98         {
  99             std::string type;
 100             /** Light type       (Readonly) */
 101             std::string name;
 102             /** Friendly name               */
 103             std::string modelId;
 104             /** Model ID         (Readonly) */
 105             std::string uniqueId;
 106             /** Unique Lamp ID   (Readonly) */
 107             std::string swversion;
 108             /** Software version (Readonly) */
 109             std::string uri; /*URI for this resource created using uniqueId*/
 110         } light_config_t;
 111
 112
 113         /**
 114          * Constructor initializes a light instance
 115          *
 116          * @param[in] uri        is the URI for the light instance (e.g. <ip>/api/<user>/light/1)
 117          * @param[in] json       is the initial JSON state for the  light. If empty,
 118          *                       the constructor will attempt to get the state directly
 119          *                       from the light.
 120          * @param[in] bridge_ip  is the ip address of the hue bridge
 121          * @param[in] bridge_mac is the mac address of the hue bridge
 122          * @param[in] short_id   is the light id
 123          */
 124         HueLight();
 125
 126         HueLight(std::string uri, std::string bridge_ip, std::string bridge_mac, std::string short_id,
 127                  std::string json);
 128
 129         virtual ~HueLight();
 130
 131         /**
 132          * Retrieves the current light state of the Hue light.
 133          *
 134          * @param[in] state will hold the light state on success.
 135          * @param[in] refresh indicates whether to return cached data or not.
 136          *
 137          * @return MPM_RESULT_OK on success, or another MPM_RESULT_XXX on error.
 138          */
 139         MPMResult getState(light_state_t &state, bool refresh = false);
 140
 141         /**
 142          * Sets the current light state of the Hue light.
 143          *
 144          * @param[in] state is the desired state of the light.
 145          *
 146          * @return  MPM_RESULT_OK on success, or another MPM_RESULT_XXX on error.
 147          */
 148         MPMResult setState(light_state_t &state);
 149
 150         /**
 151          * Retrieves the configuration information of the Hue light.
 152          *
 153          * @param[in,out] config will hold the configuraion data on success.
 154          *
 155          * @return MPM_RESULT_OK on success, or another MPM_RESULT_XXX on error.
 156          */
 157         MPMResult getConfig(light_config_t &config);
 158
 159
 160         void setConfig(light_config_t &config);
 161
 162
 163         std::string getBridgeMac()
 164         {
 165             return m_bridge_mac;
 166         }
 167
 168         std::string getShortId()
 169         {
 170             return m_short_id;
 171         }
 172
 173         std::string getUri()
 174         {
 175             return m_uri;
 176         }
 177
 178     private:
 179         /**
 180          * Retrieves the current state of the light. Values read from
 181          * are cached until a new get() is issued.
 182          *
 183          * @return MPM_RESULT_OK on success, or another MPM_RESULT_XXX code on error.
 184          */
 185         MPMResult get();
 186
 187         /**
 188          * Sets the configured state of the light. Can be called for each setXXX() call
 189          * or sent in bulk.
 190          *
 191          * @param[in] doc is a reference to the JSON object that holds the configuration to
 192          *                send.
 193          *
 194          * @return MPM_RESULT_OK on success, or another MPM_RESULT_XXX code on error.
 195          */
 196         MPMResult put(rapidjson::Document &doc);
 197
 198         /**
 199          * Retrieves the light state from the JSON representation
 200          *
 201          * @param[in,out] doc is a reference to the DOM that contains the JSON rep.
 202          *
 203          * @return MPM_RESULT_OK on success, or another MPM_RESULT_XXX on error.
 204          */
 205         MPMResult getInternalState(rapidjson::Document &doc);
 206
 207         /**
 208          * Retrieves the configuration from the JSON representation
 209          *
 210          * @param[in,out] doc is a reference to the DOM that contains the JSON rep.
 211          *
 212          * @return MPM_RESULT_OK on success, or another MPM_RESULT_XXX on error.
 213          */
 214         MPMResult getInternalConfig(rapidjson::Document &doc);
 215
 216
 217         MPMResult parseJsonResponse(std::string json);
 218
 219
 220         /**
 221          * Generates unique URI for this resource
 222          */
 223         std::string generateURI();
 224
 225         std::string m_uri;
 226         std::string m_lastCurlResponse;
 227         std::string m_user;
 228         std::string m_bridge_ip;
 229         std::string m_short_id;
 230         std::string m_bridge_mac;
 231
 232         light_state_t m_state;
 233         light_config_t m_config;
 234         bool m_initialized;
 235 };
 236
 237 typedef std::shared_ptr<HueLight> HueLightSharedPtr;
 238
 239
 240 #endif /* __HUE_LIGHT_H__ */