|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 */ |
|
16 #include "HtiSysInfoH.h" |
|
17 #include "HtiPlugin.h" |
|
18 #include "HtiSoapHandlerInterface.h" |
|
19 |
|
20 const unsigned char CMD_HAL = 0x01; |
|
21 const unsigned char CMD_IMEI = 0x02; |
|
22 const unsigned char CMD_SW_VERSION = 0x03; |
|
23 const unsigned char CMD_LANG_VERSION = 0x04; |
|
24 const unsigned char CMD_SW_LANG_VERSION = 0x05; |
|
25 const unsigned char CMD_USERAGENT_STRING = 0x06; |
|
26 const unsigned char CMD_GET_FREE_RAM = 0x07; |
|
27 const unsigned char CMD_GET_USED_RAM = 0x08; |
|
28 const unsigned char CMD_GET_TOTAL_RAM = 0x09; |
|
29 const unsigned char CMD_EAT_RAM = 0x0A; |
|
30 const unsigned char CMD_RELEASE_RAM = 0x0B; |
|
31 const unsigned char CMD_GET_FREE_DISKSPACE = 0x0C; |
|
32 const unsigned char CMD_GET_USED_DISKSPACE = 0x0D; |
|
33 const unsigned char CMD_GET_TOTAL_DISKSPACE = 0x0E; |
|
34 const unsigned char CMD_EAT_DISKSPACE = 0x0F; |
|
35 const unsigned char CMD_RELEASE_DISKSPACE = 0x10; |
|
36 const unsigned char CMD_SET_HOMETIME = 0x20; |
|
37 const unsigned char CMD_GET_HOMETIME = 0x21; |
|
38 const unsigned char CMD_SET_DATE_TIME_FORMAT = 0x22; |
|
39 const unsigned char CMD_LIGHT_STATUS = 0x30; |
|
40 const unsigned char CMD_LIGHT_ON = 0x31; |
|
41 const unsigned char CMD_LIGHT_OFF = 0x32; |
|
42 const unsigned char CMD_LIGHT_BLINK = 0x33; |
|
43 const unsigned char CMD_LIGHT_RELEASE = 0x3A; |
|
44 const unsigned char CMD_SCREENSAVER_DISABLE = 0x40; |
|
45 const unsigned char CMD_SCREENSAVER_ENABLE = 0x41; |
|
46 const unsigned char CMD_SCREENSAVER_TIMEOUT = 0x42; |
|
47 const unsigned char CMD_GET_NETWORK_MODE = 0x50; |
|
48 const unsigned char CMD_SET_NETWORK_MODE = 0x51; |
|
49 const unsigned char CMD_SET_NETWORK_MODE_NO_REBOOT = 0x52; |
|
50 const unsigned char CMD_HSDPA_ENABLE_DISABLE = 0x53; |
|
51 const unsigned char CMD_IR_ACTIVATE = 0x5A; |
|
52 const unsigned char CMD_BT_POWER_STATE = 0x5B; |
|
53 const unsigned char CMD_BT_SETTINGS = 0x5C; |
|
54 const unsigned char CMD_BT_DELETE_PAIRINGS = 0x5D; |
|
55 const unsigned char CMD_KEY_LOCK_TOGGLE = 0x60; |
|
56 const unsigned char CMD_AUTO_KEY_LOCK_TIME = 0x61; |
|
57 const unsigned char CMD_EMPTY_DRM_RIGHTS_DB = 0x65; |
|
58 const unsigned char CMD_BATTERY_STATUS = 0x70; |
|
59 const unsigned char CMD_SIGNAL_STRENGTH = 0x71; |
|
60 const unsigned char CMD_UPDATE_MEDIA_GALLERY = 0x7A; |
|
61 const unsigned char CMD_ACTIVATE_SKIN = 0x80; |
|
62 |
|
63 //const unsigned char CMD_LIGHT_SUCCESS = 0x00; |
|
64 |
|
65 //********************************************************************************** |
|
66 // SOAP FUNCTIONS |
|
67 // |
|
68 //********************************************************************************** |
|
69 |
|
70 //********************************************************************************** |
|
71 // ns1__getHalAttribute() |
|
72 //********************************************************************************** |
|
73 int ns1__getHalAttribute(struct soap* soap, |
|
74 int attribute, |
|
75 int &halAttribute) |
|
76 { |
|
77 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_HAL ); |
|
78 msg.AddInt( attribute ); |
|
79 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
80 return SOAP_FAULT; |
|
81 |
|
82 if ( msg.CheckMsgExactLen( 4 ) ) |
|
83 return SOAP_FAULT; |
|
84 |
|
85 halAttribute = msg.GetInt( 0 ); |
|
86 |
|
87 return SOAP_OK; |
|
88 } |
|
89 |
|
90 //********************************************************************************** |
|
91 // ns1__getImei() |
|
92 //********************************************************************************** |
|
93 int ns1__getImei(struct soap* soap, |
|
94 void *_, |
|
95 char *&imei) |
|
96 { |
|
97 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_IMEI ); |
|
98 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
99 return SOAP_FAULT; |
|
100 |
|
101 imei = msg.GetSoapString( 0, msg.GetMsgLen() ); |
|
102 |
|
103 return SOAP_OK; |
|
104 } |
|
105 |
|
106 //********************************************************************************** |
|
107 // ns1__getSwVersion() |
|
108 //********************************************************************************** |
|
109 int ns1__getSwVersion(struct soap* soap, |
|
110 void *_, |
|
111 wchar_t *&SwVersion) |
|
112 { |
|
113 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SW_VERSION ); |
|
114 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
115 return SOAP_FAULT; |
|
116 |
|
117 // UCS-2 encoded string size must always be even |
|
118 if( msg.GetMsgLen() % 2 ) |
|
119 { |
|
120 soap->error = soap_receiver_fault(soap, "HtiError", |
|
121 "response message size not even"); |
|
122 return SOAP_FAULT; |
|
123 } |
|
124 |
|
125 // SwVersion returned as UCS-2 encoded text |
|
126 SwVersion = msg.GetSoapWCString( 0, msg.GetMsgLen()/2 ); |
|
127 |
|
128 return SOAP_OK; |
|
129 } |
|
130 |
|
131 //********************************************************************************** |
|
132 // ns1__getLangVersion() |
|
133 //********************************************************************************** |
|
134 int ns1__getLangVersion(struct soap* soap, |
|
135 void *_, |
|
136 wchar_t *&langVersion) |
|
137 { |
|
138 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_LANG_VERSION ); |
|
139 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
140 return SOAP_FAULT; |
|
141 |
|
142 // UCS-2 encoded string size must always be even |
|
143 if( msg.GetMsgLen() % 2 ) |
|
144 { |
|
145 soap->error = soap_receiver_fault(soap, "HtiError", |
|
146 "response message size not even"); |
|
147 return SOAP_FAULT; |
|
148 } |
|
149 |
|
150 // LangVersion returned as UCS-2 encoded text |
|
151 langVersion = msg.GetSoapWCString( 0, msg.GetMsgLen()/2 ); |
|
152 |
|
153 return SOAP_OK; |
|
154 } |
|
155 |
|
156 //********************************************************************************** |
|
157 // ns1__getSwLangVersion() |
|
158 //********************************************************************************** |
|
159 int ns1__getSwLangVersion(struct soap* soap, |
|
160 void *_, |
|
161 wchar_t *&swLangVersion) |
|
162 { |
|
163 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SW_LANG_VERSION ); |
|
164 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
165 return SOAP_FAULT; |
|
166 |
|
167 // UCS-2 encoded string size must always be even |
|
168 if( msg.GetMsgLen() % 2 ) |
|
169 { |
|
170 soap->error = soap_receiver_fault(soap, "HtiError", |
|
171 "response message size not even"); |
|
172 return SOAP_FAULT; |
|
173 } |
|
174 |
|
175 // swLangVersion returned as UCS-2 encoded text |
|
176 swLangVersion = msg.GetSoapWCString( 0, msg.GetMsgLen()/2 ); |
|
177 |
|
178 return SOAP_OK; |
|
179 } |
|
180 |
|
181 //********************************************************************************** |
|
182 // ns1__getUserAgentString() |
|
183 //********************************************************************************** |
|
184 int ns1__getUserAgentString(struct soap* soap, |
|
185 void *_, |
|
186 char *&userAgentString) |
|
187 { |
|
188 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_USERAGENT_STRING ); |
|
189 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
190 return SOAP_FAULT; |
|
191 |
|
192 userAgentString = msg.GetSoapString( 0, msg.GetMsgLen() ); |
|
193 |
|
194 return SOAP_OK; |
|
195 } |
|
196 |
|
197 //********************************************************************************** |
|
198 // ns1__setHomeTime() |
|
199 //********************************************************************************** |
|
200 int ns1__setHomeTime(struct soap* soap, |
|
201 struct ns1__HtiTime * time, |
|
202 struct ns1__setHomeTimeResponse *out) |
|
203 { |
|
204 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SET_HOMETIME ); |
|
205 msg.AddWord( time->year ); |
|
206 msg.AddByte( time->month ); |
|
207 msg.AddByte( time->day ); |
|
208 msg.AddByte( time->hour ); |
|
209 msg.AddByte( time->minute ); |
|
210 msg.AddByte( time->second ); |
|
211 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
212 } |
|
213 |
|
214 //********************************************************************************** |
|
215 // ns1__getHomeTime() |
|
216 //********************************************************************************** |
|
217 int ns1__getHomeTime(struct soap* soap, |
|
218 void *_, |
|
219 struct getHomeTimeResponse& r) |
|
220 { |
|
221 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_GET_HOMETIME ); |
|
222 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
223 return SOAP_FAULT; |
|
224 |
|
225 if ( msg.CheckMsgExactLen( 7 ) ) |
|
226 return SOAP_FAULT; |
|
227 |
|
228 r._returnHtiTime.year = msg.GetWord( 0 ); |
|
229 r._returnHtiTime.month = msg.GetByte( 2 ); |
|
230 r._returnHtiTime.day = msg.GetByte( 3 ); |
|
231 r._returnHtiTime.hour = msg.GetByte( 4 ); |
|
232 r._returnHtiTime.minute = msg.GetByte( 5 ); |
|
233 r._returnHtiTime.second = msg.GetByte( 6 ); |
|
234 |
|
235 return SOAP_OK; |
|
236 } |
|
237 |
|
238 //********************************************************************************** |
|
239 // ns1__setDateTimeFormat() |
|
240 //********************************************************************************** |
|
241 int ns1__setDateTimeFormat(struct soap* soap, |
|
242 enum DateFormat dateFormat, |
|
243 unsigned char dateSeparator, |
|
244 enum TimeFormat timeFormat, |
|
245 unsigned char timeSeparator, |
|
246 enum ClockFormat clockFormat, |
|
247 struct ns1__setDateTimeFormatResponse *out) |
|
248 { |
|
249 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SET_DATE_TIME_FORMAT ); |
|
250 msg.AddByte( dateFormat ); |
|
251 msg.AddByte( dateSeparator ); |
|
252 msg.AddByte( timeFormat ); |
|
253 msg.AddByte( timeSeparator ); |
|
254 msg.AddByte( clockFormat ); |
|
255 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
256 } |
|
257 |
|
258 //********************************************************************************** |
|
259 // ns1__getFreeRAM() |
|
260 //********************************************************************************** |
|
261 int ns1__getFreeRAM(struct soap* soap, |
|
262 void *_, |
|
263 unsigned int &freeRAM) |
|
264 { |
|
265 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_GET_FREE_RAM ); |
|
266 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
267 return SOAP_FAULT; |
|
268 |
|
269 freeRAM = (unsigned int) msg.GetInt( 0 ); |
|
270 |
|
271 return SOAP_OK; |
|
272 } |
|
273 |
|
274 //********************************************************************************** |
|
275 // ns1__getUsedRAM() |
|
276 //********************************************************************************** |
|
277 int ns1__getUsedRAM(struct soap* soap, |
|
278 void *_, |
|
279 unsigned int &usedRAM) |
|
280 { |
|
281 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_GET_USED_RAM ); |
|
282 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
283 return SOAP_FAULT; |
|
284 |
|
285 usedRAM = (unsigned int) msg.GetInt( 0 ); |
|
286 |
|
287 return SOAP_OK; |
|
288 } |
|
289 |
|
290 //********************************************************************************** |
|
291 // ns1__getTotalRAM() |
|
292 //********************************************************************************** |
|
293 int ns1__getTotalRAM(struct soap* soap, |
|
294 void *_, |
|
295 unsigned int &totalRAM) |
|
296 { |
|
297 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_GET_TOTAL_RAM ); |
|
298 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
299 return SOAP_FAULT; |
|
300 |
|
301 totalRAM = (unsigned int) msg.GetInt( 0 ); |
|
302 |
|
303 return SOAP_OK; |
|
304 } |
|
305 |
|
306 //********************************************************************************** |
|
307 // ns1__eatRAM() |
|
308 //********************************************************************************** |
|
309 int ns1__eatRAM(struct soap* soap, |
|
310 unsigned int RAMToBeLeftOver, |
|
311 unsigned int &freeRAM) |
|
312 { |
|
313 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_EAT_RAM ); |
|
314 msg.AddInt( RAMToBeLeftOver ); |
|
315 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
316 return SOAP_FAULT; |
|
317 |
|
318 freeRAM = (unsigned int) msg.GetInt( 0 ); |
|
319 |
|
320 return SOAP_OK; |
|
321 } |
|
322 |
|
323 //********************************************************************************** |
|
324 // ns1__releaseRAM() |
|
325 //********************************************************************************** |
|
326 int ns1__releaseRAM(struct soap* soap, |
|
327 void *_, |
|
328 unsigned int &freeRAM) |
|
329 { |
|
330 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_RELEASE_RAM ); |
|
331 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
332 return SOAP_FAULT; |
|
333 |
|
334 freeRAM = (unsigned int) msg.GetInt( 0 ); |
|
335 |
|
336 return SOAP_OK; |
|
337 } |
|
338 |
|
339 //********************************************************************************** |
|
340 // ns1__getFreeDiskSpace() |
|
341 //********************************************************************************** |
|
342 int ns1__getFreeDiskSpace(struct soap* soap, |
|
343 char *driveLetter, |
|
344 ULONG64 &freeDiskSpace) |
|
345 { |
|
346 if ( check_mandatory_string_parameter( soap, driveLetter, "driveLetter" ) ) |
|
347 return SOAP_FAULT; |
|
348 |
|
349 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_GET_FREE_DISKSPACE ); |
|
350 msg.AddByte( driveLetter[0] ); |
|
351 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
352 return SOAP_FAULT; |
|
353 |
|
354 freeDiskSpace = *(ULONG64*) msg.GetMsgBody(); |
|
355 |
|
356 return SOAP_OK; |
|
357 } |
|
358 |
|
359 //********************************************************************************** |
|
360 // ns1__getUsedDiskSpace() |
|
361 //********************************************************************************** |
|
362 int ns1__getUsedDiskSpace(struct soap* soap, |
|
363 char *driveLetter, |
|
364 ULONG64 &usedDiskSpace) |
|
365 { |
|
366 if ( check_mandatory_string_parameter( soap, driveLetter, "driveLetter" ) ) |
|
367 return SOAP_FAULT; |
|
368 |
|
369 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_GET_USED_DISKSPACE ); |
|
370 msg.AddByte( driveLetter[0] ); |
|
371 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
372 return SOAP_FAULT; |
|
373 |
|
374 usedDiskSpace = *(ULONG64*) msg.GetMsgBody(); |
|
375 |
|
376 return SOAP_OK; |
|
377 } |
|
378 |
|
379 //********************************************************************************** |
|
380 // ns1__getTotalDiskSpace() |
|
381 //********************************************************************************** |
|
382 int ns1__getTotalDiskSpace(struct soap* soap, |
|
383 char *driveLetter, |
|
384 ULONG64 &totalDiskSpace) |
|
385 { |
|
386 if ( check_mandatory_string_parameter( soap, driveLetter, "driveLetter" ) ) |
|
387 return SOAP_FAULT; |
|
388 |
|
389 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_GET_TOTAL_DISKSPACE ); |
|
390 msg.AddByte( driveLetter[0] ); |
|
391 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
392 return SOAP_FAULT; |
|
393 |
|
394 totalDiskSpace = *(ULONG64*) msg.GetMsgBody(); |
|
395 |
|
396 return SOAP_OK; |
|
397 } |
|
398 |
|
399 //********************************************************************************** |
|
400 // ns1__eatDiskSpace() |
|
401 //********************************************************************************** |
|
402 int ns1__eatDiskSpace(struct soap* soap, |
|
403 char *driveLetter, |
|
404 ULONG64 diskSpaceToBeLeftOver, |
|
405 ULONG64 &freeDiskSpace) |
|
406 { |
|
407 if ( check_mandatory_string_parameter( soap, driveLetter, "driveLetter" ) ) |
|
408 return SOAP_FAULT; |
|
409 |
|
410 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_EAT_DISKSPACE ); |
|
411 msg.AddByte( driveLetter[0] ); |
|
412 msg.AddUInt64( diskSpaceToBeLeftOver ); |
|
413 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
414 return SOAP_FAULT; |
|
415 |
|
416 freeDiskSpace = *(ULONG64*) msg.GetMsgBody(); |
|
417 |
|
418 return SOAP_OK; |
|
419 } |
|
420 |
|
421 //********************************************************************************** |
|
422 // ns1__releaseDiskSpace() |
|
423 //********************************************************************************** |
|
424 int ns1__releaseDiskSpace(struct soap* soap, |
|
425 char *driveLetter, |
|
426 ULONG64 &freeDiskSpace) |
|
427 { |
|
428 if ( check_mandatory_string_parameter( soap, driveLetter, "driveLetter" ) ) |
|
429 return SOAP_FAULT; |
|
430 |
|
431 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_RELEASE_DISKSPACE ); |
|
432 msg.AddByte( driveLetter[0] ); |
|
433 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
434 return SOAP_FAULT; |
|
435 |
|
436 freeDiskSpace = *(ULONG64*) msg.GetMsgBody(); |
|
437 |
|
438 return SOAP_OK; |
|
439 } |
|
440 |
|
441 //********************************************************************************** |
|
442 // ns1__lightStatus() |
|
443 //********************************************************************************** |
|
444 int ns1__lightStatus(struct soap* soap, |
|
445 unsigned char lightTarget, |
|
446 unsigned char &lightStatus) |
|
447 { |
|
448 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_LIGHT_STATUS ); |
|
449 msg.AddByte( lightTarget ); |
|
450 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
451 return SOAP_FAULT; |
|
452 |
|
453 lightStatus = msg.GetByte( 0 ); |
|
454 |
|
455 return SOAP_OK; |
|
456 } |
|
457 |
|
458 //********************************************************************************** |
|
459 // ns1__lightOn() |
|
460 //********************************************************************************** |
|
461 int ns1__lightOn(struct soap* soap, |
|
462 unsigned char lightTarget, |
|
463 unsigned short duration, |
|
464 unsigned char intensity, |
|
465 unsigned char fadeIn, |
|
466 struct ns1__lightOnResponse *out) |
|
467 { |
|
468 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_LIGHT_ON ); |
|
469 msg.AddByte( lightTarget ); |
|
470 msg.AddWord( duration ); |
|
471 msg.AddByte( intensity ); |
|
472 msg.AddByte( fadeIn ); |
|
473 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
474 } |
|
475 |
|
476 //********************************************************************************** |
|
477 // ns1__lightOff() |
|
478 //********************************************************************************** |
|
479 int ns1__lightOff(struct soap* soap, |
|
480 unsigned char lightTarget, |
|
481 unsigned short duration, |
|
482 unsigned char fadeOut, |
|
483 struct ns1__lightOffResponse *out) |
|
484 { |
|
485 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_LIGHT_OFF ); |
|
486 msg.AddByte( lightTarget ); |
|
487 msg.AddWord( duration ); |
|
488 msg.AddByte( fadeOut ); |
|
489 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
490 } |
|
491 |
|
492 //********************************************************************************** |
|
493 // ns1__lightBlink() |
|
494 //********************************************************************************** |
|
495 int ns1__lightBlink(struct soap* soap, |
|
496 unsigned char lightTarget, |
|
497 unsigned short duration, |
|
498 unsigned short onDuration, |
|
499 unsigned short offDuration, |
|
500 unsigned char intensity, |
|
501 struct ns1__lightBlinkResponse *out) |
|
502 { |
|
503 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_LIGHT_BLINK ); |
|
504 msg.AddByte( lightTarget ); |
|
505 msg.AddWord( duration ); |
|
506 msg.AddWord( onDuration ); |
|
507 msg.AddWord( offDuration ); |
|
508 msg.AddByte( intensity ); |
|
509 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
510 } |
|
511 |
|
512 //********************************************************************************** |
|
513 // ns1__lightRelease() |
|
514 //********************************************************************************** |
|
515 int ns1__lightRelease(struct soap* soap, |
|
516 void *_, |
|
517 struct ns1__lightReleaseResponse *out) |
|
518 { |
|
519 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_LIGHT_RELEASE ); |
|
520 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
521 } |
|
522 |
|
523 //********************************************************************************** |
|
524 // ns1__screenSaverDisable() |
|
525 //********************************************************************************** |
|
526 int ns1__screenSaverDisable(struct soap* soap, |
|
527 void *_, |
|
528 struct ns1__screenSaverDisableResponse *out) |
|
529 { |
|
530 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SCREENSAVER_DISABLE ); |
|
531 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
532 } |
|
533 |
|
534 //********************************************************************************** |
|
535 // ns1__screenSaverEnable() |
|
536 //********************************************************************************** |
|
537 int ns1__screenSaverEnable(struct soap* soap, |
|
538 void *_, |
|
539 struct ns1__screenSaverEnableResponse *out) |
|
540 { |
|
541 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SCREENSAVER_ENABLE ); |
|
542 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
543 } |
|
544 |
|
545 //********************************************************************************** |
|
546 // ns1__screenSaverTimeout() |
|
547 //********************************************************************************** |
|
548 int ns1__screenSaverTimeout(struct soap* soap, |
|
549 unsigned char timeout, |
|
550 struct ns1__screenSaverTimeoutResponse *out) |
|
551 { |
|
552 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SCREENSAVER_TIMEOUT ); |
|
553 msg.AddByte( timeout ); |
|
554 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
555 } |
|
556 |
|
557 //********************************************************************************** |
|
558 // ns1__getNetworkMode() |
|
559 //********************************************************************************** |
|
560 int ns1__getNetworkMode(struct soap* soap, |
|
561 void *_, |
|
562 enum NetworkMode &mode) |
|
563 { |
|
564 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_GET_NETWORK_MODE ); |
|
565 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
566 return SOAP_FAULT; |
|
567 |
|
568 if ( msg.CheckCommandCode( CMD_GET_NETWORK_MODE ) ) |
|
569 return SOAP_FAULT; |
|
570 |
|
571 mode = (NetworkMode) msg.GetInt( 1 ); |
|
572 |
|
573 return SOAP_OK; |
|
574 } |
|
575 |
|
576 //********************************************************************************** |
|
577 // ns1__setNetworkMode() |
|
578 //********************************************************************************** |
|
579 int ns1__setNetworkMode(struct soap* soap, |
|
580 enum NetworkMode mode, |
|
581 struct ns1__setNetworkModeResponse *out) |
|
582 { |
|
583 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SET_NETWORK_MODE ); |
|
584 msg.AddInt( mode ); |
|
585 msg.SendMsg(); |
|
586 |
|
587 HtiSoapHandlerInterface* handler = |
|
588 static_cast<HtiSoapHandlerInterface*>( soap->user ); |
|
589 |
|
590 // Wait a while if there is an error message. If there is no |
|
591 // response it is assumed that the command has succeeded. |
|
592 handler->WaitForHtiMessage( HTIMSG_TIMEOUT_10_SECONDS ); |
|
593 if ( handler->IsReceivedHtiError() ) |
|
594 { |
|
595 handler->SendSoapFaultFromReceivedHtiError(); |
|
596 return SOAP_FAULT; |
|
597 } |
|
598 return SOAP_OK; |
|
599 } |
|
600 |
|
601 //********************************************************************************** |
|
602 // ns1__setNetworkModeNoReboot() |
|
603 //********************************************************************************** |
|
604 int ns1__setNetworkModeNoReboot(struct soap* soap, |
|
605 enum NetworkMode mode, |
|
606 struct ns1__setNetworkModeNoRebootResponse *out) |
|
607 { |
|
608 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SET_NETWORK_MODE_NO_REBOOT ); |
|
609 msg.AddInt( mode ); |
|
610 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
611 } |
|
612 |
|
613 //********************************************************************************** |
|
614 // ns1__setHsdpaStatus() |
|
615 //********************************************************************************** |
|
616 int ns1__setHsdpaStatus(struct soap* soap, |
|
617 enum HsdpaStatus status, |
|
618 struct ns1__setHsdpaStatusResponse *out) |
|
619 { |
|
620 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_HSDPA_ENABLE_DISABLE ); |
|
621 msg.AddInt( status ); |
|
622 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
623 } |
|
624 |
|
625 //********************************************************************************** |
|
626 // ns1__irActivate() |
|
627 //********************************************************************************** |
|
628 int ns1__irActivate(struct soap* soap, |
|
629 void *_, |
|
630 struct ns1__irActivateResponse *out) |
|
631 { |
|
632 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_IR_ACTIVATE ); |
|
633 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
634 } |
|
635 |
|
636 //********************************************************************************** |
|
637 // ns1__btPowerState() |
|
638 //********************************************************************************** |
|
639 int ns1__btPowerState(struct soap* soap, |
|
640 bool btOn, |
|
641 bool force, |
|
642 struct ns1__btPowerStateResponse *out) |
|
643 { |
|
644 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_BT_POWER_STATE ); |
|
645 msg.AddByte( btOn ); |
|
646 msg.AddByte( force ); |
|
647 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
648 } |
|
649 |
|
650 //********************************************************************************** |
|
651 // ns1__btSettings() |
|
652 //********************************************************************************** |
|
653 int ns1__btSettings(struct soap* soap, |
|
654 bool discoverable, |
|
655 bool enableSAP, |
|
656 char *btName, |
|
657 struct ns1__btSettingsResponse *out) |
|
658 { |
|
659 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_BT_SETTINGS ); |
|
660 msg.AddByte( discoverable ); |
|
661 msg.AddByte( enableSAP ); |
|
662 msg.AddStringWithLengthByteZero( btName ); |
|
663 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
664 } |
|
665 |
|
666 //********************************************************************************** |
|
667 // ns1__btDeletePairings() |
|
668 //********************************************************************************** |
|
669 int ns1__btDeletePairings(struct soap* soap, |
|
670 bool closeConnections, |
|
671 char *btName, |
|
672 int &deleteCount) |
|
673 { |
|
674 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_BT_DELETE_PAIRINGS ); |
|
675 msg.AddByte( closeConnections ); |
|
676 msg.AddStringWithLengthByteZero( btName ); |
|
677 |
|
678 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
679 return SOAP_FAULT; |
|
680 |
|
681 if ( msg.CheckMsgExactLen( 1 ) ) |
|
682 return SOAP_FAULT; |
|
683 |
|
684 deleteCount = msg.GetByte( 0 ); |
|
685 |
|
686 return SOAP_OK; |
|
687 } |
|
688 |
|
689 //********************************************************************************** |
|
690 // ns1__keyLockToggle() |
|
691 //********************************************************************************** |
|
692 int ns1__keyLockToggle(struct soap* soap, |
|
693 bool keyLockOn, |
|
694 bool showNote, |
|
695 struct ns1__keyLockToggleResponse *out) |
|
696 { |
|
697 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_KEY_LOCK_TOGGLE ); |
|
698 msg.AddByte( keyLockOn ); |
|
699 msg.AddByte( showNote ); |
|
700 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
701 } |
|
702 |
|
703 //********************************************************************************** |
|
704 // ns1__autoKeyLockTime() |
|
705 //********************************************************************************** |
|
706 int ns1__autoKeyLockTime(struct soap* soap, |
|
707 int seconds, |
|
708 struct ns1__autoKeyLockTimeResponse *out) |
|
709 { |
|
710 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_AUTO_KEY_LOCK_TIME ); |
|
711 msg.AddWord( seconds ); |
|
712 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
713 } |
|
714 |
|
715 //********************************************************************************** |
|
716 // ns1__emptyDrmRightsDb() |
|
717 //********************************************************************************** |
|
718 int ns1__emptyDrmRightsDb(struct soap* soap, |
|
719 void *_, |
|
720 struct ns1__emptyDrmRightsDbResponse *out) |
|
721 { |
|
722 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_EMPTY_DRM_RIGHTS_DB ); |
|
723 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
724 } |
|
725 |
|
726 //********************************************************************************** |
|
727 // ns1__batteryStatus() |
|
728 //********************************************************************************** |
|
729 int ns1__batteryStatus(struct soap* soap, |
|
730 void *_, |
|
731 struct batteryStatusResponse& r) |
|
732 { |
|
733 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_BATTERY_STATUS ); |
|
734 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
735 return SOAP_FAULT; |
|
736 |
|
737 if ( msg.CheckMsgExactLen( 2 ) ) |
|
738 return SOAP_FAULT; |
|
739 |
|
740 r._returnHtiBatteryStatus.batteryBars = msg.GetByte( 0 ); |
|
741 r._returnHtiBatteryStatus.chargingStatus = msg.GetByte( 1 ); |
|
742 |
|
743 return SOAP_OK; |
|
744 } |
|
745 |
|
746 //********************************************************************************** |
|
747 // ns1__signalStrength() |
|
748 //********************************************************************************** |
|
749 int ns1__signalStrength(struct soap* soap, |
|
750 void *_, |
|
751 int &signalBars) |
|
752 { |
|
753 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_SIGNAL_STRENGTH ); |
|
754 if ( msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ) ) |
|
755 return SOAP_FAULT; |
|
756 |
|
757 if ( msg.CheckMsgExactLen( 1 ) ) |
|
758 return SOAP_FAULT; |
|
759 |
|
760 signalBars = msg.GetByte( 0 ); |
|
761 |
|
762 return SOAP_OK; |
|
763 } |
|
764 |
|
765 //********************************************************************************** |
|
766 // ns1__updateMediaGallery() |
|
767 //********************************************************************************** |
|
768 int ns1__updateMediaGallery(struct soap* soap, |
|
769 char* filePath, |
|
770 struct ns1__updateMediaGalleryResponse *out) |
|
771 { |
|
772 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_UPDATE_MEDIA_GALLERY ); |
|
773 msg.AddStringWithLengthByteZero( filePath ); |
|
774 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_30_SECONDS ); |
|
775 } |
|
776 |
|
777 //********************************************************************************** |
|
778 // ns1__activateSkin() |
|
779 //********************************************************************************** |
|
780 int ns1__activateSkin(struct soap* soap, |
|
781 char* skinName, |
|
782 struct ns1__activateSkinResponse *out) |
|
783 { |
|
784 HtiMsgHelper msg( soap, HTI_SYSINFO_UID, CMD_ACTIVATE_SKIN ); |
|
785 msg.AddStringWithLengthByteZero( skinName ); |
|
786 return msg.SendReceiveMsg( HTIMSG_TIMEOUT_10_SECONDS ); |
|
787 } |