2 * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
4 * Contact: Suresh Kumar N (suresh.n@samsung.com)
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
19 #include "zigbee_service_interface_common.h"
21 #include <zblib_driver_mfglib_control.h>
23 static void on_mfglib_control_start_resp(ZigBeeServiceInterface *service_interface,
24 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
26 ZigbeeServiceInterfaceRespCbData_t *cb_data =
27 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
30 NOT_USED(service_interface);
33 NOT_USED(resp_data_len);
36 static gboolean on_mfglib_control_start(ZigbeeMfglib_control *mfglib_control_object,
37 GDBusMethodInvocation *invocation,
39 gboolean mfglib_start,
42 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
43 ZigbeeMfglibControlStart_t req;
44 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
46 GVariantIter *iter = NULL;
51 memset(&req, 0x0, sizeof(ZigbeeMfglibControlStart_t));
53 /* Update request structure */
54 g_variant_get(eui64, "ay", &iter);
55 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
57 if (i >= ZIGBEE_EUI64_SIZE)
60 req.mfglib_start = ((mfglib_start == TRUE) ? 1 : 0);
62 /* Allocate response callback data */
64 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
66 if (NULL == resp_cb_data) {
67 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
69 /* Send failure response */
70 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
75 /* Dispatch request */
76 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
77 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
78 ZBLIB_MFGLIB_CONTROL_OPS_START,
80 on_mfglib_control_start_resp, resp_cb_data);
82 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
84 /* Free response callback data */
85 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
87 /* Send failure response */
88 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
96 static void on_mfglib_control_end_resp(ZigBeeServiceInterface *service_interface,
97 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
99 ZigbeeServiceInterfaceRespCbData_t *cb_data =
100 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
103 NOT_USED(service_interface);
104 NOT_USED(request_id);
106 NOT_USED(resp_data_len);
109 static gboolean on_mfglib_control_end(ZigbeeMfglib_control *mfglib_control_object,
110 GDBusMethodInvocation *invocation,
114 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
115 ZigbeeMfglibControlEnd_t req;
116 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
118 GVariantIter *iter = NULL;
123 memset(&req, 0x0, sizeof(ZigbeeMfglibControlEnd_t));
125 /* Update request structure */
126 g_variant_get(eui64, "ay", &iter);
127 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
129 if (i >= ZIGBEE_EUI64_SIZE)
133 /* Allocate response callback data */
135 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
136 invocation, NULL, 0);
137 if (NULL == resp_cb_data) {
138 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
140 /* Send failure response */
141 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
146 /* Dispatch request */
147 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
148 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
149 ZBLIB_MFGLIB_CONTROL_OPS_END,
151 on_mfglib_control_end_resp, resp_cb_data);
153 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
155 /* Free response callback data */
156 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
158 /* Send failure response */
159 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
167 static void on_mfglib_control_start_tone_resp(ZigBeeServiceInterface *service_interface,
168 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
170 ZigbeeServiceInterfaceRespCbData_t *cb_data =
171 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
174 NOT_USED(service_interface);
175 NOT_USED(request_id);
177 NOT_USED(resp_data_len);
180 static gboolean on_mfglib_control_start_tone(ZigbeeMfglib_control *mfglib_control_object,
181 GDBusMethodInvocation *invocation,
185 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
186 ZigbeeMfglibControlStartTone_t req;
187 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
189 GVariantIter *iter = NULL;
194 memset(&req, 0x0, sizeof(ZigbeeMfglibControlStartTone_t));
196 /* Update request structure */
197 g_variant_get(eui64, "ay", &iter);
198 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
200 if (i >= ZIGBEE_EUI64_SIZE)
204 /* Allocate response callback data */
206 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
207 invocation, NULL, 0);
208 if (NULL == resp_cb_data) {
209 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
211 /* Send failure response */
212 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
217 /* Dispatch request */
218 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
219 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
220 ZBLIB_MFGLIB_CONTROL_OPS_START_TONE,
222 on_mfglib_control_start_tone_resp, resp_cb_data);
224 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
226 /* Free response callback data */
227 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
229 /* Send failure response */
230 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
238 static void on_mfglib_control_stop_tone_resp(ZigBeeServiceInterface *service_interface,
239 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
241 ZigbeeServiceInterfaceRespCbData_t *cb_data =
242 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
245 NOT_USED(service_interface);
246 NOT_USED(request_id);
248 NOT_USED(resp_data_len);
251 static gboolean on_mfglib_control_stop_tone(ZigbeeMfglib_control *mfglib_control_object,
252 GDBusMethodInvocation *invocation,
256 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
257 ZigbeeMfglibControlStopTone_t req;
258 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
260 GVariantIter *iter = NULL;
265 memset(&req, 0x0, sizeof(ZigbeeMfglibControlStopTone_t));
267 /* Update request structure */
268 g_variant_get(eui64, "ay", &iter);
269 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
271 if (i >= ZIGBEE_EUI64_SIZE)
275 /* Allocate response callback data */
277 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
278 invocation, NULL, 0);
279 if (NULL == resp_cb_data) {
280 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
282 /* Send failure response */
283 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
288 /* Dispatch request */
289 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
290 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
291 ZBLIB_MFGLIB_CONTROL_OPS_STOP_TONE,
293 on_mfglib_control_stop_tone_resp, resp_cb_data);
295 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
297 /* Free response callback data */
298 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
300 /* Send failure response */
301 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
309 static void on_mfglib_control_start_stream_resp(ZigBeeServiceInterface *service_interface,
310 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
312 ZigbeeServiceInterfaceRespCbData_t *cb_data =
313 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
316 NOT_USED(service_interface);
317 NOT_USED(request_id);
319 NOT_USED(resp_data_len);
322 static gboolean on_mfglib_control_start_stream(ZigbeeMfglib_control *mfglib_control_object,
323 GDBusMethodInvocation *invocation,
327 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
328 ZigbeeMfglibControlStartStream_t req;
329 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
331 GVariantIter *iter = NULL;
336 memset(&req, 0x0, sizeof(ZigbeeMfglibControlStartStream_t));
338 /* Update request structure */
339 g_variant_get(eui64, "ay", &iter);
340 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
342 if (i >= ZIGBEE_EUI64_SIZE)
346 /* Allocate response callback data */
348 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
349 invocation, NULL, 0);
350 if (NULL == resp_cb_data) {
351 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
353 /* Send failure response */
354 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
359 /* Dispatch request */
360 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
361 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
362 ZBLIB_MFGLIB_CONTROL_OPS_START_STREAM,
364 on_mfglib_control_start_stream_resp, resp_cb_data);
366 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
368 /* Free response callback data */
369 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
371 /* Send failure response */
372 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
380 static void on_mfglib_control_stop_stream_resp(ZigBeeServiceInterface *service_interface,
381 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
383 ZigbeeServiceInterfaceRespCbData_t *cb_data =
384 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
387 NOT_USED(service_interface);
388 NOT_USED(request_id);
390 NOT_USED(resp_data_len);
393 static gboolean on_mfglib_control_stop_stream(ZigbeeMfglib_control *mfglib_control_object,
394 GDBusMethodInvocation *invocation,
398 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
399 ZigbeeMfglibControlStopStream_t req;
400 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
402 GVariantIter *iter = NULL;
407 memset(&req, 0x0, sizeof(ZigbeeMfglibControlStopStream_t));
409 /* Update request structure */
410 g_variant_get(eui64, "ay", &iter);
411 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
413 if (i >= ZIGBEE_EUI64_SIZE)
417 /* Allocate response callback data */
419 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
420 invocation, NULL, 0);
421 if (NULL == resp_cb_data) {
422 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
424 /* Send failure response */
425 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
430 /* Dispatch request */
431 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
432 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
433 ZBLIB_MFGLIB_CONTROL_OPS_STOP_STREAM,
435 on_mfglib_control_stop_stream_resp, resp_cb_data);
437 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
439 /* Free response callback data */
440 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
442 /* Send failure response */
443 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
451 static void on_mfglib_control_send_packet_resp(ZigBeeServiceInterface *service_interface,
452 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
454 ZigbeeServiceInterfaceRespCbData_t *cb_data =
455 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
458 NOT_USED(service_interface);
459 NOT_USED(request_id);
461 NOT_USED(resp_data_len);
464 static gboolean on_mfglib_control_send_packet(ZigbeeMfglib_control *mfglib_control_object,
465 GDBusMethodInvocation *invocation,
466 GVariant *packet_content,
470 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
471 ZigbeeMfglibControlSendPacket_t req;
472 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
474 GVariantIter *iter = NULL;
479 memset(&req, 0x0, sizeof(ZigbeeMfglibControlSendPacket_t));
481 /* Update request structure */
482 g_variant_get(packet_content, "ay", &iter);
483 while (g_variant_iter_loop(iter, "y", req.packet_content[i])) {
485 if (i >= (guint)packet_length)
488 req.packet_length = packet_length;
490 /* Allocate response callback data */
492 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
493 invocation, NULL, 0);
494 if (NULL == resp_cb_data) {
495 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
497 /* Send failure response */
498 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
503 /* Dispatch request */
504 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
505 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
506 ZBLIB_MFGLIB_CONTROL_OPS_SEND_PACKET,
508 on_mfglib_control_send_packet_resp, resp_cb_data);
510 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
512 /* Free response callback data */
513 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
515 /* Send failure response */
516 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
524 static void on_mfglib_control_set_channel_resp(ZigBeeServiceInterface *service_interface,
525 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
527 ZigbeeServiceInterfaceRespCbData_t *cb_data =
528 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
531 NOT_USED(service_interface);
532 NOT_USED(request_id);
534 NOT_USED(resp_data_len);
537 static gboolean on_mfglib_control_set_channel(ZigbeeMfglib_control *mfglib_control_object,
538 GDBusMethodInvocation *invocation,
543 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
544 ZigbeeMfglibControlSetChannel_t req;
545 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
547 GVariantIter *iter = NULL;
552 memset(&req, 0x0, sizeof(ZigbeeMfglibControlSetChannel_t));
554 /* Update request structure */
555 g_variant_get(eui64, "ay", &iter);
556 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
558 if (i >= ZIGBEE_EUI64_SIZE)
561 req.channel = channel;
563 /* Allocate response callback data */
565 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
566 invocation, NULL, 0);
567 if (NULL == resp_cb_data) {
568 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
570 /* Send failure response */
571 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
576 /* Dispatch request */
577 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
578 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
579 ZBLIB_MFGLIB_CONTROL_OPS_SET_CHANNEL,
581 on_mfglib_control_set_channel_resp, resp_cb_data);
583 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
585 /* Free response callback data */
586 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
588 /* Send failure response */
589 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
597 static void on_mfglib_control_get_channel_resp(ZigBeeServiceInterface *service_interface,
598 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
600 ZigbeeServiceInterfaceRespCbData_t *cb_data =
601 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
604 NOT_USED(service_interface);
605 NOT_USED(request_id);
607 NOT_USED(resp_data_len);
610 static gboolean on_mfglib_control_get_channel(ZigbeeMfglib_control *mfglib_control_object,
611 GDBusMethodInvocation *invocation,
615 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
616 ZigbeeMfglibControlGetChannel_t req;
617 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
619 GVariantIter *iter = NULL;
624 memset(&req, 0x0, sizeof(ZigbeeMfglibControlGetChannel_t));
626 /* Update request structure */
627 g_variant_get(eui64, "ay", &iter);
628 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
630 if (i >= ZIGBEE_EUI64_SIZE)
634 /* Allocate response callback data */
636 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
637 invocation, NULL, 0);
638 if (NULL == resp_cb_data) {
639 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
641 /* Send failure response */
642 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
647 /* Dispatch request */
648 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
649 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
650 ZBLIB_MFGLIB_CONTROL_OPS_GET_CHANNEL,
652 on_mfglib_control_get_channel_resp, resp_cb_data);
654 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
656 /* Free response callback data */
657 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
659 /* Send failure response */
660 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
668 static void on_mfglib_control_set_power_resp(ZigBeeServiceInterface *service_interface,
669 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
671 ZigbeeServiceInterfaceRespCbData_t *cb_data =
672 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
675 NOT_USED(service_interface);
676 NOT_USED(request_id);
678 NOT_USED(resp_data_len);
681 static gboolean on_mfglib_control_set_power(ZigbeeMfglib_control *mfglib_control_object,
682 GDBusMethodInvocation *invocation,
684 gshort tx_power_mode,
688 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
689 ZigbeeMfglibControlSetPower_t req;
690 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
692 GVariantIter *iter = NULL;
697 memset(&req, 0x0, sizeof(ZigbeeMfglibControlSetPower_t));
699 /* Update request structure */
700 g_variant_get(eui64, "ay", &iter);
701 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
703 if (i >= ZIGBEE_EUI64_SIZE)
706 req.tx_power_mode = tx_power_mode;
709 /* Allocate response callback data */
711 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
712 invocation, NULL, 0);
713 if (NULL == resp_cb_data) {
714 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
716 /* Send failure response */
717 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
722 /* Dispatch request */
723 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
724 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
725 ZBLIB_MFGLIB_CONTROL_OPS_SET_POWER,
727 on_mfglib_control_set_power_resp, resp_cb_data);
729 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
731 /* Free response callback data */
732 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
734 /* Send failure response */
735 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
743 static void on_mfglib_control_get_power_resp(ZigBeeServiceInterface *service_interface,
744 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
746 ZigbeeServiceInterfaceRespCbData_t *cb_data =
747 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
750 NOT_USED(service_interface);
751 NOT_USED(request_id);
753 NOT_USED(resp_data_len);
756 static gboolean on_mfglib_control_get_power(ZigbeeMfglib_control *mfglib_control_object,
757 GDBusMethodInvocation *invocation,
761 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
762 ZigbeeMfglibControlGetPower_t req;
763 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
765 GVariantIter *iter = NULL;
770 memset(&req, 0x0, sizeof(ZigbeeMfglibControlGetPower_t));
772 /* Update request structure */
773 g_variant_get(eui64, "ay", &iter);
774 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
776 if (i >= ZIGBEE_EUI64_SIZE)
780 /* Allocate response callback data */
782 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
783 invocation, NULL, 0);
784 if (NULL == resp_cb_data) {
785 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
787 /* Send failure response */
788 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
793 /* Dispatch request */
794 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
795 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
796 ZBLIB_MFGLIB_CONTROL_OPS_GET_POWER,
798 on_mfglib_control_get_power_resp, resp_cb_data);
800 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
802 /* Free response callback data */
803 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
805 /* Send failure response */
806 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
814 static void on_mfglib_control_set_synoffset_resp(ZigBeeServiceInterface *service_interface,
815 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
817 ZigbeeServiceInterfaceRespCbData_t *cb_data =
818 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
821 NOT_USED(service_interface);
822 NOT_USED(request_id);
824 NOT_USED(resp_data_len);
827 static gboolean on_mfglib_control_set_synoffset(ZigbeeMfglib_control *mfglib_control_object,
828 GDBusMethodInvocation *invocation,
833 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
834 ZigbeeMfglibControlSetSynOffset_t req;
835 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
837 GVariantIter *iter = NULL;
842 memset(&req, 0x0, sizeof(ZigbeeMfglibControlSetSynOffset_t));
844 /* Update request structure */
845 g_variant_get(eui64, "ay", &iter);
846 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
848 if (i >= ZIGBEE_EUI64_SIZE)
851 req.channel = test_channel;
853 /* Allocate response callback data */
855 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
856 invocation, NULL, 0);
857 if (NULL == resp_cb_data) {
858 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
860 /* Send failure response */
861 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
866 /* Dispatch request */
867 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
868 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
869 ZBLIB_MFGLIB_CONTROL_OPS_SET_SYNOFFSET,
871 on_mfglib_control_set_synoffset_resp, resp_cb_data);
873 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
875 /* Free response callback data */
876 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
878 /* Send failure response */
879 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
887 static void on_mfglib_control_get_synoffset_resp(ZigBeeServiceInterface *service_interface,
888 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
890 ZigbeeServiceInterfaceRespCbData_t *cb_data =
891 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
894 NOT_USED(service_interface);
895 NOT_USED(request_id);
897 NOT_USED(resp_data_len);
900 static gboolean on_mfglib_control_get_synoffset(ZigbeeMfglib_control *mfglib_control_object,
901 GDBusMethodInvocation *invocation,
908 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
909 ZigbeeMfglibControlGetSynOffset_t req;
910 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
912 GVariantIter *iter = NULL;
917 memset(&req, 0x0, sizeof(ZigbeeMfglibControlGetSynOffset_t));
919 /* Update request structure */
920 g_variant_get(packet, "ay", &iter);
921 while (g_variant_iter_loop(iter, "y", req.packet[i])) {
923 if (i >= (guint)packet_length)
926 req.packet_length = packet_length;
927 req.link_quality = link_quality;
930 /* Allocate response callback data */
932 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
933 invocation, NULL, 0);
934 if (NULL == resp_cb_data) {
935 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
937 /* Send failure response */
938 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
943 /* Dispatch request */
944 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
945 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
946 ZBLIB_MFGLIB_CONTROL_OPS_GET_SYNOFFSET,
948 on_mfglib_control_get_synoffset_resp, resp_cb_data);
950 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
952 /* Free response callback data */
953 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
955 /* Send failure response */
956 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
964 static void on_mfglib_control_rx_start_resp(ZigBeeServiceInterface *service_interface,
965 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
967 ZigbeeServiceInterfaceRespCbData_t *cb_data =
968 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
971 NOT_USED(service_interface);
972 NOT_USED(request_id);
974 NOT_USED(resp_data_len);
977 static gboolean on_mfglib_control_rx_start(ZigbeeMfglib_control *mfglib_control_object,
978 GDBusMethodInvocation *invocation,
982 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
983 ZigbeeMfglibControlRxStart_t req;
984 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
986 GVariantIter *iter = NULL;
991 memset(&req, 0x0, sizeof(ZigbeeMfglibControlRxStart_t));
993 /* Update request structure */
994 g_variant_get(eui64, "ay", &iter);
995 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
997 if (i >= ZIGBEE_EUI64_SIZE)
1001 /* Allocate response callback data */
1003 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
1004 invocation, NULL, 0);
1005 if (NULL == resp_cb_data) {
1006 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1008 /* Send failure response */
1009 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1014 /* Dispatch request */
1015 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1016 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
1017 ZBLIB_MFGLIB_CONTROL_OPS_RX_START,
1019 on_mfglib_control_rx_start_resp, resp_cb_data);
1021 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1023 /* Free response callback data */
1024 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1026 /* Send failure response */
1027 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1035 static void on_mfglib_control_rx_stop_resp(ZigBeeServiceInterface *service_interface,
1036 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1038 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1039 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1042 NOT_USED(service_interface);
1043 NOT_USED(request_id);
1044 NOT_USED(resp_data);
1045 NOT_USED(resp_data_len);
1048 static gboolean on_mfglib_control_rx_stop(ZigbeeMfglib_control *mfglib_control_object,
1049 GDBusMethodInvocation *invocation,
1053 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1054 ZigbeeMfglibControlRxStop_t req;
1055 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1057 GVariantIter *iter = NULL;
1062 memset(&req, 0x0, sizeof(ZigbeeMfglibControlRxStop_t));
1064 /* Update request structure */
1065 g_variant_get(eui64, "ay", &iter);
1066 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
1068 if (i >= ZIGBEE_EUI64_SIZE)
1072 /* Allocate response callback data */
1074 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
1075 invocation, NULL, 0);
1076 if (NULL == resp_cb_data) {
1077 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1079 /* Send failure response */
1080 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1085 /* Dispatch request */
1086 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1087 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
1088 ZBLIB_MFGLIB_CONTROL_OPS_RX_STOP,
1090 on_mfglib_control_rx_stop_resp, resp_cb_data);
1092 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1094 /* Free response callback data */
1095 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1097 /* Send failure response */
1098 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1106 static void on_mfglib_control_rx_verify_resp(ZigBeeServiceInterface *service_interface,
1107 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1109 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1110 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1113 NOT_USED(service_interface);
1114 NOT_USED(request_id);
1115 NOT_USED(resp_data);
1116 NOT_USED(resp_data_len);
1119 static gboolean on_mfglib_control_rx_verify(ZigbeeMfglib_control *mfglib_control_object,
1120 GDBusMethodInvocation *invocation,
1124 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1125 ZigbeeMfglibControlRxVerify_t req;
1126 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1128 GVariantIter *iter = NULL;
1133 memset(&req, 0x0, sizeof(ZigbeeMfglibControlRxVerify_t));
1135 /* Update request structure */
1136 g_variant_get(eui64, "ay", &iter);
1137 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
1139 if (i >= ZIGBEE_EUI64_SIZE)
1143 /* Allocate response callback data */
1145 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
1146 invocation, NULL, 0);
1147 if (NULL == resp_cb_data) {
1148 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1150 /* Send failure response */
1151 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1156 /* Dispatch request */
1157 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1158 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
1159 ZBLIB_MFGLIB_CONTROL_OPS_RX_VERIFY,
1161 on_mfglib_control_rx_verify_resp, resp_cb_data);
1163 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1165 /* Free response callback data */
1166 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1168 /* Send failure response */
1169 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1177 static void on_mfglib_control_get_rssi_resp(ZigBeeServiceInterface *service_interface,
1178 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
1180 ZigbeeServiceInterfaceRespCbData_t *cb_data =
1181 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
1184 NOT_USED(service_interface);
1185 NOT_USED(request_id);
1186 NOT_USED(resp_data);
1187 NOT_USED(resp_data_len);
1190 static gboolean on_mfglib_control_get_rssi(ZigbeeMfglib_control *mfglib_control_object,
1191 GDBusMethodInvocation *invocation,
1195 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
1196 ZigbeeMfglibControlGetRssi_t req;
1197 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
1199 GVariantIter *iter = NULL;
1204 memset(&req, 0x0, sizeof(ZigbeeMfglibControlGetRssi_t));
1206 /* Update request structure */
1207 g_variant_get(eui64, "ay", &iter);
1208 while (g_variant_iter_loop(iter, "y", req.eui64[i])) {
1210 if (i >= ZIGBEE_EUI64_SIZE)
1214 /* Allocate response callback data */
1216 zigbee_service_dbus_interface_create_resp_cb_data(mfglib_control_object,
1217 invocation, NULL, 0);
1218 if (NULL == resp_cb_data) {
1219 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
1221 /* Send failure response */
1222 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1227 /* Dispatch request */
1228 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
1229 ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL,
1230 ZBLIB_MFGLIB_CONTROL_OPS_GET_RSSI,
1232 on_mfglib_control_get_rssi_resp, resp_cb_data);
1234 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
1236 /* Free response callback data */
1237 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
1239 /* Send failure response */
1240 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
1248 gboolean zigbee_service_dbus_interface_mfglib_control_init(ZigBeeServiceInterface *service_interface,
1249 ZigbeeObjectSkeleton *zigbee_object)
1251 ZigbeeMfglib_control *mfglib_control_object;
1253 if (NULL == service_interface) {
1254 Z_LOGE("service_interface is NULL");
1258 mfglib_control_object = zigbee_mfglib_control_skeleton_new();
1259 zigbee_object_skeleton_set_mfglib_control(zigbee_object, mfglib_control_object);
1260 g_object_unref(mfglib_control_object);
1262 Z_LOGI("mfglib_control_object: [%p]", mfglib_control_object);
1265 * Register signal handlers for 'mfglib_control' interface
1267 g_signal_connect(mfglib_control_object,
1269 G_CALLBACK(on_mfglib_control_start), service_interface);
1271 g_signal_connect(mfglib_control_object,
1273 G_CALLBACK(on_mfglib_control_end), service_interface);
1275 g_signal_connect(mfglib_control_object,
1276 "handle-start-tone",
1277 G_CALLBACK(on_mfglib_control_start_tone), service_interface);
1279 g_signal_connect(mfglib_control_object,
1281 G_CALLBACK(on_mfglib_control_stop_tone), service_interface);
1283 g_signal_connect(mfglib_control_object,
1284 "handle-start-stream",
1285 G_CALLBACK(on_mfglib_control_start_stream), service_interface);
1287 g_signal_connect(mfglib_control_object,
1288 "handle-stop-stream",
1289 G_CALLBACK(on_mfglib_control_stop_stream), service_interface);
1291 g_signal_connect(mfglib_control_object,
1292 "handle-send-packet",
1293 G_CALLBACK(on_mfglib_control_send_packet), service_interface);
1295 g_signal_connect(mfglib_control_object,
1296 "handle-set-channel",
1297 G_CALLBACK(on_mfglib_control_set_channel), service_interface);
1299 g_signal_connect(mfglib_control_object,
1300 "handle-get-channel",
1301 G_CALLBACK(on_mfglib_control_get_channel), service_interface);
1303 g_signal_connect(mfglib_control_object,
1305 G_CALLBACK(on_mfglib_control_set_power), service_interface);
1307 g_signal_connect(mfglib_control_object,
1309 G_CALLBACK(on_mfglib_control_get_power), service_interface);
1311 g_signal_connect(mfglib_control_object,
1312 "handle-set-synoffset",
1313 G_CALLBACK(on_mfglib_control_set_synoffset), service_interface);
1315 g_signal_connect(mfglib_control_object,
1316 "handle-get-synoffset",
1317 G_CALLBACK(on_mfglib_control_get_synoffset), service_interface);
1319 g_signal_connect(mfglib_control_object,
1321 G_CALLBACK(on_mfglib_control_rx_start), service_interface);
1323 g_signal_connect(mfglib_control_object,
1325 G_CALLBACK(on_mfglib_control_rx_stop), service_interface);
1327 g_signal_connect(mfglib_control_object,
1329 G_CALLBACK(on_mfglib_control_rx_verify), service_interface);
1331 g_signal_connect(mfglib_control_object,
1333 G_CALLBACK(on_mfglib_control_get_rssi), service_interface);