Use `URI` all caps in documentation
[iotivity.git] / 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__ */