aboutsummaryrefslogtreecommitdiff
path: root/bridge.go
blob: 9502af7f8b7f06bae5f6bf1f931416aa38cb328a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
/*
* bridge.go
* GoHue library for Philips Hue
* Copyright (C) 2016 Collin Guarino (Collinux) collin.guarino@gmail.com
* License: GPL version 2 or higher http://www.gnu.org/licenses/gpl.html
 */
// All things start with the bridge. You will find many Bridge.Func() items
// to use once a bridge has been created and identified.
// See the getting started guide on the Philips hue website:
// http://www.developers.meethue.com/documentation/getting-started

package hue

import (
	"bytes"
	"encoding/json"
	"encoding/xml"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"runtime"
	"strconv"
	"strings"
)

// Bridge struct defines hardware that is used to communicate with the lights.
type Bridge struct {
	IPAddress string `json:"internalipaddress"`
	Username  string
	Info      BridgeInfo
}

// BridgeInfo struct is the format for parsing xml from a bridge.
type BridgeInfo struct {
	XMLName xml.Name `xml:"root"`
	Device  struct {
		XMLName          xml.Name `xml:"device"`
		DeviceType       string   `xml:"deviceType"`
		FriendlyName     string   `xml:"friendlyName"`
		Manufacturer     string   `xml:"manufacturer"`
		ManufacturerURL  string   `xml:"manufacturerURL"`
		ModelDescription string   `xml:"modelDescription"`
		ModelName        string   `xml:"modelName"`
		ModelNumber      string   `xml:"modelNumber"`
		ModelURL         string   `xml:"modelURL"`
		SerialNumber     string   `xml:"serialNumber"`
		UDN              string   `xml:"UDN"`
	} `xml:"device"`
}

// bridge.Get sends an http GET to the bridge
func (bridge *Bridge) Get(path string) ([]byte, io.Reader, error) {
	uri := fmt.Sprintf("http://" + bridge.IPAddress + path)
	resp, err := http.Get(uri)
	if err != nil {
		err = errors.New("Error: Unable to access bridge. ")
		log.Println(err)
		return []byte{}, nil, err
	}
	return HandleResponse(resp)
}

// Bridge.Put sends an http PUT to the bridge with
// a body formatted with parameters (in a generic interface)
func (bridge *Bridge) Put(path string, params interface{}) ([]byte, io.Reader, error) {
	uri := fmt.Sprintf("http://" + bridge.IPAddress + path)
	client := &http.Client{}

	data, err := json.Marshal(params)
	if err != nil {
		err = errors.New("Error: Unable marshal PUT request interface.")
		log.Println(err)
		return []byte{}, nil, err
	}
	//fmt.Println("\n\nPARAMS: ", params)
	//log.Println("\nSending PUT body: ", string(data))

	request, err := http.NewRequest("PUT", uri, bytes.NewReader(data))
	resp, err := client.Do(request)
	if err != nil {
		err = errors.New("Error: Unable to access bridge.")
		log.Println(err)
		return []byte{}, nil, err
	}
	return HandleResponse(resp)
}

// bridge.Post sends an http POST to the bridge with
// a body formatted with parameters (in a generic interface).
// If `params` is nil then it will send an empty body with the post request.
func (bridge *Bridge) Post(path string, params interface{}) ([]byte, io.Reader, error) {
	// Add the params to the request or allow an empty body
	request := []byte{}
	if params != nil {
		reqBody, err := json.Marshal(params)
		if err != nil {
			err = errors.New("Error: Unable to add POST body parameters due to json marshal error.")
			log.Println(err)
			return []byte{}, nil, err
		}
		request = reqBody
	}
	// Send the request and handle the response
	uri := fmt.Sprintf("http://" + bridge.IPAddress + path)
	resp, err := http.Post(uri, "text/json", bytes.NewReader(request))
	if err != nil {
		err = errors.New("Error: Unable to access bridge.")
		log.Println(err)
		return []byte{}, nil, err
	}
	return HandleResponse(resp)
}

// Bridge.Delete sends an http DELETE to the bridge
func (bridge *Bridge) Delete(path string) error {
	uri := fmt.Sprintf("http://" + bridge.IPAddress + path)
	client := &http.Client{}
	req, err := http.NewRequest("DELETE", uri, nil)
	resp, err := client.Do(req)
	if err != nil {
		err = errors.New("Error: Unable to access bridge.")
		log.Println(err)
		return err
	}
	_, _, err = HandleResponse(resp)
	return err
}

// HandleResponse manages the http.Response content from a
// bridge Get/Put/Post/Delete by checking it for errors
// and invalid return types.
func HandleResponse(resp *http.Response) ([]byte, io.Reader, error) {
	body, err := ioutil.ReadAll(resp.Body)
	defer resp.Body.Close()
	if err != nil {
		trace("Error parsing bridge description xml.", nil)
		return []byte{}, nil, err
	}
	reader := bytes.NewReader(body)
	if strings.Contains(string(body), "\"error\"") {
		errString := string(body)
		errNum := errString[strings.Index(errString, "type\":")+6 : strings.Index(errString, ",\"address")]
		errDesc := errString[strings.Index(errString, "description\":\"")+14 : strings.Index(errString, "\"}}")]
		errOut := fmt.Sprintf("Error type %s: %s.", errNum, errDesc)
		err = errors.New(errOut)
		log.Println(err)
		return []byte{}, nil, err
	}
	return body, reader, nil
}

// FindBridges will visit www.meethue.com/api/nupnp to see a list of
// bridges on the local network.
func FindBridges() ([]Bridge, error) {
	bridge := Bridge{IPAddress: "www.meethue.com"}
	body, _, err := bridge.Get("/api/nupnp")
	if err != nil {
		err = errors.New("Error: Unable to locate bridge.")
		log.Fatal(err)
		return []Bridge{}, err
	}
	bridges := []Bridge{}
	err = json.Unmarshal(body, &bridges)
	if err != nil {
		return []Bridge{}, errors.New("Unable to parse FindBridges response. ")
	}
	return bridges, nil
}

// NewBridge defines hardware that is compatible with Hue.
// The function is the core of all functionality, it's necessary
// to call `NewBridge` and `Login` or `CreateUser` to access any
// lights, scenes, groups, etc.
func NewBridge(ip string) (*Bridge, error) {
	bridge := Bridge{
		IPAddress: ip,
	}
	// Test the connection by attempting to get the bridge info.
	err := bridge.GetInfo()
	if err != nil {
		log.Fatal("Error: Unable to access bridge. ", err)
		return &Bridge{}, err
	}
	return &bridge, nil
}

// GetBridgeInfo retreives the description.xml file from the bridge.
// This is used as a check to see if the bridge is accessible
// and any error will be fatal as the bridge is required for nearly
// all functions.
func (bridge *Bridge) GetInfo() error {
	_, reader, err := bridge.Get("/description.xml")
	if err != nil {
		return err
	}
	data := BridgeInfo{}
	err = xml.NewDecoder(reader).Decode(&data)
	if err != nil {
		err = errors.New("Error: Unable to decode XML response from bridge. ")
		log.Fatal(err)
		return err
	}
	bridge.Info = data
	return nil
}

// Bridge.Login verifies that the username token has bridge access
// and only assigns the bridge its Username value if verification is successful.
func (bridge *Bridge) Login(username string) error {
	uri := fmt.Sprintf("/api/%s", username)
	_, _, err := bridge.Get(uri)
	if err != nil {
		log.Fatal(err)
		return err
	}
	bridge.Username = username
	return nil
}

// Bridge.CreateUser adds a new user token on the whitelist.
// The token is the first return value in this function which must
// be used with `Bridge.Login`. You cannot use a plaintext username
// like the argument provided in this function.
// This was done by Philips Hue for security reasons.
func (bridge *Bridge) CreateUser(deviceType string) (string, error) {
	params := map[string]string{"devicetype": deviceType}
	body, _, err := bridge.Post("/api", params)
	if err != nil {
		log.Fatal("Error: Failed to create user. ", err)
		return "", err
	}
	content := string(body)
	username := content[strings.LastIndex(content, ":\"")+2 : strings.LastIndex(content, "\"")]
	userOut := fmt.Sprintf(
		"Created user token '%s'. Use Bridge.Login with this token from now on.",
		username)
	log.Println(userOut)
	bridge.Username = username
	return username, nil
}

// Bridge.DeleteUser deletes a user given its USER KEY, not the string name.
// See http://www.developers.meethue.com/documentation/configuration-api
// for description on `username` deprecation in place of the devicetype key.
func (bridge *Bridge) DeleteUser(username string) error {
	uri := fmt.Sprintf("/api/%s/config/whitelist/%s", bridge.Username, username)
	err := bridge.Delete(uri)
	if err != nil {
		return err
	}
	return nil
}

// GetAllLights retreives the state of all lights that the bridge is aware of.
func (bridge *Bridge) GetAllLights() ([]Light, error) {
	uri := fmt.Sprintf("/api/%s/lights", bridge.Username)
	body, _, err := bridge.Get(uri)
	if err != nil {
		return []Light{}, err
	}

	// An index is at the top of every Light in the array
	lightMap := map[string]Light{}
	err = json.Unmarshal(body, &lightMap)
	if err != nil {
		return []Light{}, errors.New("Unable to marshal GetAllLights response. ")
	}

	// Parse the index, add the light to the list, and return the array
	lights := []Light{}
	for index, light := range lightMap {
		light.Index, err = strconv.Atoi(index)
		if err != nil {
			return []Light{}, errors.New("Unable to convert light index to integer. ")
		}
		light.Bridge = bridge
		lights = append(lights, light)
	}
	return lights, nil
}

// GetLightByIndex returns a light struct containing data on
// a light given its index stored on the bridge. This is used for
// quickly updating an individual light.
func (bridge *Bridge) GetLightByIndex(index int) (Light, error) {
	// Send an http GET and inspect the response
	uri := fmt.Sprintf("/api/%s/lights/%d", bridge.Username, index)
	body, _, err := bridge.Get(uri)
	if err != nil {
		return Light{}, err
	}
	if strings.Contains(string(body), "not available") {
		return Light{}, errors.New("Error: Light selection index out of bounds. ")
	}

	// Parse and load the response into the light array
	light := Light{}
	err = json.Unmarshal(body, &light)
	if err != nil {
		return Light{}, errors.New("Error: Unable to unmarshal light data. ")
	}
	light.Index = index
	light.Bridge = bridge
	return light, nil
}

// Bridge.FindNewLights makes the bridge search the zigbee spectrum for
// lights in the area and will add them to the list of lights available.
// If successful these new lights can be used by `Bridge.GetAllLights`
//
// Notes from Philips Hue API documentation:
// The bridge will search for 1 minute and will add a maximum of 15 new
// lights. To add further lights, the command needs to be sent again after
// the search has completed. If a search is already active, it will be
// aborted and a new search will start.
// http://www.developers.meethue.com/documentation/lights-api#13_search_for_new_lights
func (bridge *Bridge) FindNewLights() error {
	uri := fmt.Sprintf("/api/%s/lights", bridge.Username)
	_, _, err := bridge.Post(uri, nil)
	if err != nil {
		log.Println(err)
		return err
	}
	return nil
}

// GetLight returns a light struct containing data on a given name.
func (bridge *Bridge) GetLightByName(name string) (Light, error) {
	lights, _ := bridge.GetAllLights()
	for _, light := range lights {
		if light.Name == name {
			return light, nil
		}
	}
	errOut := fmt.Sprintf("Error: Light name '%s' not found. ", name)
	return Light{}, errors.New(errOut)
}

// Log the date, time, file location, line number, and function.
// Message can be "" or Err can be nil (not both)
func trace(message string, err error) {
	pc := make([]uintptr, 10)
	runtime.Callers(2, pc)
	f := runtime.FuncForPC(pc[0])
	file, line := f.FileLine(pc[0])
	if err != nil {
		log.Printf("%s:%d %s: %s\n", file, line, f.Name(), err)
	} else {
		log.Printf("%s:%d %s: %s\n", file, line, f.Name(), message)
	}
}