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_zcl_global_control.h>
23 static void on_zclglobal_control_read_attributes_req_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_zclglobal_control_read_attributes_req(ZigbeeZcl_global_control *zclglobal_control_object,
37 GDBusMethodInvocation *invocation,
38 GVariant *attribute_id,
39 gint attribute_ids_length,
46 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
47 ZigbeeZclGlobalControlReadAttributesRequest_t req;
48 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
50 GVariantIter *iter = NULL;
55 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
57 /* Update request structure */
58 g_variant_get(attribute_id, "ay", &iter);
59 while (g_variant_iter_loop(iter, "y", req.attribute_id[i])) {
61 if (i >= attribute_ids_length)
64 req.attribute_id_len = attribute_ids_length;
65 req.node_id = node_id;
66 req.cluster_id = cluster_id;
67 req.zcl_frame_ctrl = zcl_frame_ctrl;
68 req.dest_ep = dest_ep;
70 /* Allocate response callback data */
72 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
74 if (NULL == resp_cb_data) {
75 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
77 /* Send failure response */
78 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
83 /* Dispatch request */
84 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
85 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
86 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ,
88 on_zclglobal_control_read_attributes_req_resp, resp_cb_data);
90 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
92 /* Free response callback data */
93 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
95 /* Send failure response */
96 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
104 static void on_zclglobal_control_write_attributes_req_resp(ZigBeeServiceInterface *service_interface,
105 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
107 ZigbeeServiceInterfaceRespCbData_t *cb_data =
108 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
111 NOT_USED(service_interface);
112 NOT_USED(request_id);
114 NOT_USED(resp_data_len);
117 static gboolean on_zclglobal_control_write_attributes_req(ZigbeeZcl_global_control *zclglobal_control_object,
118 GDBusMethodInvocation *invocation,
119 GVariant *write_attribute,
123 gchar zcl_frame_ctrl,
127 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
128 ZigbeeZclGlobalControlWriteAttributesRequest_t req;
129 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
131 GVariantIter *iter = NULL;
136 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
138 /* Update request structure */
139 g_variant_get(write_attribute, "ay", &iter);
140 while (g_variant_iter_loop(iter, "y", req.write_records[i])) {
142 if (i >= records_length)
145 req.records_len = records_length;
146 req.node_id = node_id;
147 req.cluster_id = cluster_id;
148 req.zcl_frame_ctrl = zcl_frame_ctrl;
149 req.dest_ep = dest_ep;
151 /* Allocate response callback data */
153 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
154 invocation, NULL, 0);
155 if (NULL == resp_cb_data) {
156 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
158 /* Send failure response */
159 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
164 /* Dispatch request */
165 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
166 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
167 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ,
169 on_zclglobal_control_write_attributes_req_resp, resp_cb_data);
171 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
173 /* Free response callback data */
174 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
176 /* Send failure response */
177 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
185 static void on_zclglobal_control_write_attributes_undivided_req_resp(ZigBeeServiceInterface *service_interface,
186 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
188 ZigbeeServiceInterfaceRespCbData_t *cb_data =
189 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
192 NOT_USED(service_interface);
193 NOT_USED(request_id);
195 NOT_USED(resp_data_len);
198 static gboolean on_zclglobal_control_write_attributes_undivided_req(ZigbeeZcl_global_control *zclglobal_control_object,
199 GDBusMethodInvocation *invocation,
200 GVariant *write_attribute,
204 gchar zcl_frame_ctrl,
209 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
210 ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t req;
211 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
213 GVariantIter *iter = NULL;
218 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
220 /* Update request structure */
221 g_variant_get(write_attribute, "ay", &iter);
222 while (g_variant_iter_loop(iter, "y", req.write_records[i])) {
224 if (i >= records_length)
227 req.records_len = records_length;
228 req.node_id = node_id;
229 req.cluster_id = cluster_id;
230 req.zcl_frame_ctrl = zcl_frame_ctrl;
232 req.dest_ep = dest_ep;
234 /* Allocate response callback data */
236 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
237 invocation, NULL, 0);
238 if (NULL == resp_cb_data) {
239 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
241 /* Send failure response */
242 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
247 /* Dispatch request */
248 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
249 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
250 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ,
252 on_zclglobal_control_write_attributes_undivided_req_resp, resp_cb_data);
254 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
256 /* Free response callback data */
257 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
259 /* Send failure response */
260 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
268 static void on_zclglobal_control_write_attributes_no_resp_resp(ZigBeeServiceInterface *service_interface,
269 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
271 ZigbeeServiceInterfaceRespCbData_t *cb_data =
272 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
275 NOT_USED(service_interface);
276 NOT_USED(request_id);
278 NOT_USED(resp_data_len);
281 static gboolean on_zclglobal_control_write_attributes_no_resp(ZigbeeZcl_global_control *zclglobal_control_object,
282 GDBusMethodInvocation *invocation,
283 GVariant *write_attribute,
287 gchar zcl_frame_ctrl,
292 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
293 ZigbeeZclGlobalControlWriteAttributesNoResponse_t req;
294 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
296 GVariantIter *iter = NULL;
301 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
303 /* Update request structure */
304 g_variant_get(write_attribute, "ay", &iter);
305 while (g_variant_iter_loop(iter, "y", req.write_records[i])) {
307 if (i >= records_length)
310 req.records_len = records_length;
311 req.node_id = node_id;
312 req.cluster_id = cluster_id;
313 req.zcl_frame_ctrl = zcl_frame_ctrl;
315 req.dest_ep = dest_ep;
317 /* Allocate response callback data */
319 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
320 invocation, NULL, 0);
321 if (NULL == resp_cb_data) {
322 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
324 /* Send failure response */
325 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
330 /* Dispatch request */
331 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
332 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
333 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP,
335 on_zclglobal_control_write_attributes_no_resp_resp, resp_cb_data);
337 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
339 /* Free response callback data */
340 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
342 /* Send failure response */
343 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
351 static void on_zclglobal_control_write_attributes_structured_resp(ZigBeeServiceInterface *service_interface,
352 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
354 ZigbeeServiceInterfaceRespCbData_t *cb_data =
355 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
358 NOT_USED(service_interface);
359 NOT_USED(request_id);
361 NOT_USED(resp_data_len);
364 static gboolean on_zclglobal_control_write_attributes_structured(ZigbeeZcl_global_control *zclglobal_control_object,
365 GDBusMethodInvocation *invocation,
366 GVariant *write_attribute,
370 gchar zcl_frame_ctrl,
375 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
376 ZigbeeZclGlobalControlWriteAttributesStructed_t req;
377 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
379 GVariantIter *iter = NULL;
384 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
386 /* Update request structure */
387 g_variant_get(write_attribute, "ay", &iter);
388 while (g_variant_iter_loop(iter, "y", req.write_records[i])) {
390 if (i >= records_length)
393 req.records_len = records_length;
394 req.node_id = node_id;
395 req.cluster_id = cluster_id;
396 req.zcl_frame_ctrl = zcl_frame_ctrl;
398 req.dest_ep = dest_ep;
400 /* Allocate response callback data */
402 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
403 invocation, NULL, 0);
404 if (NULL == resp_cb_data) {
405 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
407 /* Send failure response */
408 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
413 /* Dispatch request */
414 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
415 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
416 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED,
418 on_zclglobal_control_write_attributes_structured_resp, resp_cb_data);
420 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
422 /* Free response callback data */
423 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
425 /* Send failure response */
426 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
434 static void on_zclglobal_control_read_attributes_structured_resp(ZigBeeServiceInterface *service_interface,
435 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
437 ZigbeeServiceInterfaceRespCbData_t *cb_data =
438 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
441 NOT_USED(service_interface);
442 NOT_USED(request_id);
444 NOT_USED(resp_data_len);
447 static gboolean on_zclglobal_control_read_attributes_structured(ZigbeeZcl_global_control *zclglobal_control_object,
448 GDBusMethodInvocation *invocation,
449 GVariant *read_attribute,
453 gchar zcl_frame_ctrl,
458 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
459 ZigbeeZclGlobalControlReadAttributesStructed_t req;
460 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
462 GVariantIter *iter = NULL;
467 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
469 /* Update request structure */
470 g_variant_get(read_attribute, "ay", &iter);
471 while (g_variant_iter_loop(iter, "y", req.read_records[i])) {
473 if (i >= records_length)
476 req.records_len = records_length;
477 req.node_id = node_id;
478 req.cluster_id = cluster_id;
479 req.zcl_frame_ctrl = zcl_frame_ctrl;
481 req.dest_ep = dest_ep;
483 /* Allocate response callback data */
485 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
486 invocation, NULL, 0);
487 if (NULL == resp_cb_data) {
488 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
490 /* Send failure response */
491 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
496 /* Dispatch request */
497 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
498 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
499 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED,
501 on_zclglobal_control_read_attributes_structured_resp, resp_cb_data);
503 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
505 /* Free response callback data */
506 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
508 /* Send failure response */
509 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
517 static void on_zclglobal_control_configure_reporting_req_resp(ZigBeeServiceInterface *service_interface,
518 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
520 ZigbeeServiceInterfaceRespCbData_t *cb_data =
521 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
524 NOT_USED(service_interface);
525 NOT_USED(request_id);
527 NOT_USED(resp_data_len);
530 static gboolean on_zclglobal_control_configure_reporting_req(ZigbeeZcl_global_control *zclglobal_control_object,
531 GDBusMethodInvocation *invocation,
532 GVariant *read_attribute,
536 gchar zcl_frame_ctrl,
541 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
542 ZigbeeZclGlobalControlConfigureReportingReq_t req;
543 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
545 GVariantIter *iter = NULL;
550 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
552 /* Update request structure */
553 g_variant_get(read_attribute, "ay", &iter);
554 while (g_variant_iter_loop(iter, "y", req.read_records[i])) {
556 if (i >= records_length)
559 req.records_len = records_length;
560 req.node_id = node_id;
561 req.cluster_id = cluster_id;
562 req.zcl_frame_ctrl = zcl_frame_ctrl;
564 req.dest_ep = dest_ep;
566 /* Allocate response callback data */
568 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
569 invocation, NULL, 0);
570 if (NULL == resp_cb_data) {
571 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
573 /* Send failure response */
574 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
579 /* Dispatch request */
580 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
581 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
582 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ,
584 on_zclglobal_control_configure_reporting_req_resp, resp_cb_data);
586 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
588 /* Free response callback data */
589 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
591 /* Send failure response */
592 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
600 static void on_zclglobal_control_read_configure_reporting_resp(ZigBeeServiceInterface *service_interface,
601 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
603 ZigbeeServiceInterfaceRespCbData_t *cb_data =
604 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
607 NOT_USED(service_interface);
608 NOT_USED(request_id);
610 NOT_USED(resp_data_len);
613 static gboolean on_zclglobal_control_read_configure_reporting(ZigbeeZcl_global_control *zclglobal_control_object,
614 GDBusMethodInvocation *invocation,
615 GVariant *read_attribute,
619 gchar zcl_frame_ctrl,
624 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
625 ZigbeeZclGlobalControlReadConfigureReporting_t req;
626 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
628 GVariantIter *iter = NULL;
633 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
635 /* Update request structure */
636 g_variant_get(read_attribute, "ay", &iter);
637 while (g_variant_iter_loop(iter, "y", req.read_records[i])) {
639 if (i >= records_length)
642 req.records_len = records_length;
643 req.node_id = node_id;
644 req.cluster_id = cluster_id;
645 req.zcl_frame_ctrl = zcl_frame_ctrl;
647 req.dest_ep = dest_ep;
649 /* Allocate response callback data */
651 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
652 invocation, NULL, 0);
653 if (NULL == resp_cb_data) {
654 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
656 /* Send failure response */
657 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
662 /* Dispatch request */
663 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
664 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
665 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING,
667 on_zclglobal_control_read_configure_reporting_resp, resp_cb_data);
669 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
671 /* Free response callback data */
672 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
674 /* Send failure response */
675 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
683 static void on_zclglobal_control_discover_attributes_resp(ZigBeeServiceInterface *service_interface,
684 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
686 ZigbeeServiceInterfaceRespCbData_t *cb_data =
687 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
690 NOT_USED(service_interface);
691 NOT_USED(request_id);
693 NOT_USED(resp_data_len);
696 static gboolean on_zclglobal_control_discover_attributes(ZigbeeZcl_global_control *zclglobal_control_object,
697 GDBusMethodInvocation *invocation,
700 gchar zcl_frame_ctrl,
706 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
707 ZigbeeZclGlobalControlDiscoverAttributes_t req;
708 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
712 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
714 /* Update request structure */
715 req.node_id = node_id;
716 req.dest_ep = dest_ep;
717 req.zcl_frame_ctrl = zcl_frame_ctrl;
718 req.cluster_id = cluster_id;
719 req.start_attribute = start_attr;
722 /* Allocate response callback data */
724 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
725 invocation, NULL, 0);
726 if (NULL == resp_cb_data) {
727 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
729 /* Send failure response */
730 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
735 /* Dispatch request */
736 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
737 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
738 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES,
740 on_zclglobal_control_discover_attributes_resp, resp_cb_data);
742 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
744 /* Free response callback data */
745 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
747 /* Send failure response */
748 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
756 static void on_zclglobal_control_discover_attributes_extended_resp(ZigBeeServiceInterface *service_interface,
757 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
759 ZigbeeServiceInterfaceRespCbData_t *cb_data =
760 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
763 NOT_USED(service_interface);
764 NOT_USED(request_id);
766 NOT_USED(resp_data_len);
769 static gboolean on_zclglobal_control_discover_attributes_extended(ZigbeeZcl_global_control *zclglobal_control_object,
770 GDBusMethodInvocation *invocation,
773 gchar zcl_frame_ctrl,
779 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
780 ZigbeeZclGlobalControlDiscoverAttributesExtended_t req;
781 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
785 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
787 /* Update request structure */
788 req.node_id = node_id;
789 req.dest_ep = dest_ep;
790 req.zcl_frame_ctrl = zcl_frame_ctrl;
791 req.cluster_id = cluster_id;
792 req.start_attribute = start_attr;
795 /* Allocate response callback data */
797 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
798 invocation, NULL, 0);
799 if (NULL == resp_cb_data) {
800 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
802 /* Send failure response */
803 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
808 /* Dispatch request */
809 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
810 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
811 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED,
813 on_zclglobal_control_discover_attributes_extended_resp, resp_cb_data);
815 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
817 /* Free response callback data */
818 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
820 /* Send failure response */
821 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
829 static void on_zclglobal_control_discover_commands_received_resp(ZigBeeServiceInterface *service_interface,
830 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
832 ZigbeeServiceInterfaceRespCbData_t *cb_data =
833 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
836 NOT_USED(service_interface);
837 NOT_USED(request_id);
839 NOT_USED(resp_data_len);
842 static gboolean on_zclglobal_control_discover_commands_received(ZigbeeZcl_global_control *zclglobal_control_object,
843 GDBusMethodInvocation *invocation,
846 gchar zcl_frame_ctrl,
852 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
853 ZigbeeZclGlobalControlDiscoverCommandsReceived_t req;
854 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
858 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
860 /* Update request structure */
861 req.node_id = node_id;
862 req.dest_ep = dest_ep;
863 req.zcl_frame_ctrl = zcl_frame_ctrl;
864 req.cluster_id = cluster_id;
865 req.start_attribute = start_attr;
868 /* Allocate response callback data */
870 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
871 invocation, NULL, 0);
872 if (NULL == resp_cb_data) {
873 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
875 /* Send failure response */
876 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
881 /* Dispatch request */
882 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
883 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
884 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED,
886 on_zclglobal_control_discover_commands_received_resp, resp_cb_data);
888 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
890 /* Free response callback data */
891 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
893 /* Send failure response */
894 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
902 static void on_zclglobal_control_discover_commands_generated_resp(ZigBeeServiceInterface *service_interface,
903 guint request_id, gpointer resp_data, guint resp_data_len, gpointer resp_cb_data)
905 ZigbeeServiceInterfaceRespCbData_t *cb_data =
906 (ZigbeeServiceInterfaceRespCbData_t *)resp_cb_data;
909 NOT_USED(service_interface);
910 NOT_USED(request_id);
912 NOT_USED(resp_data_len);
915 static gboolean on_zclglobal_control_discover_commands_generated(ZigbeeZcl_global_control *zclglobal_control_object,
916 GDBusMethodInvocation *invocation,
919 gchar zcl_frame_ctrl,
925 ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
926 ZigbeeZclGlobalControlDiscoverCommandsGenerated_t req;
927 ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
931 memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
933 /* Update request structure */
934 req.node_id = node_id;
935 req.dest_ep = dest_ep;
936 req.zcl_frame_ctrl = zcl_frame_ctrl;
937 req.cluster_id = cluster_id;
938 req.start_attribute = start_attr;
941 /* Allocate response callback data */
943 zigbee_service_dbus_interface_create_resp_cb_data(zclglobal_control_object,
944 invocation, NULL, 0);
945 if (NULL == resp_cb_data) {
946 Z_LOGE("zigbee_service_dbus_interface_create_resp_cb_data failed!");
948 /* Send failure response */
949 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
954 /* Dispatch request */
955 ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
956 ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
957 ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED,
959 on_zclglobal_control_discover_commands_generated_resp, resp_cb_data);
961 Z_LOGE("zigbee_service_dbus_interface_dispatch_request failed!");
963 /* Free response callback data */
964 zigbee_service_dbus_interface_destroy_resp_cb_data(resp_cb_data);
966 /* Send failure response */
967 ZIGBEE_DBUS_FAIL_RESPONSE(invocation, ZIGBEE_DBUS_DEFAULT_REQ_FAILED_MSG);
975 gboolean zigbee_service_dbus_interface_zcl_global_control_init(ZigBeeServiceInterface *service_interface,
976 ZigbeeObjectSkeleton *zigbee_object)
978 ZigbeeZcl_global_control *zclglobal_control_object;
980 if (NULL == service_interface) {
981 Z_LOGE("service_interface is NULL");
985 zclglobal_control_object = zigbee_zcl_global_control_skeleton_new();
986 zigbee_object_skeleton_set_zcl_global_control(zigbee_object, zclglobal_control_object);
987 g_object_unref(zclglobal_control_object);
989 Z_LOGI("zclglobal_control_object: [%p]", zclglobal_control_object);
992 * Register signal handlers for 'zclglobal_control' interface
994 g_signal_connect(zclglobal_control_object,
995 "handle-read-attributes-req",
996 G_CALLBACK(on_zclglobal_control_read_attributes_req), service_interface);
998 g_signal_connect(zclglobal_control_object,
999 "handle-write-attributes-req",
1000 G_CALLBACK(on_zclglobal_control_write_attributes_req), service_interface);
1002 g_signal_connect(zclglobal_control_object,
1003 "handle-write-attributes-undivided-req",
1004 G_CALLBACK(on_zclglobal_control_write_attributes_undivided_req), service_interface);
1006 g_signal_connect(zclglobal_control_object,
1007 "handle-write-attributes-no-resp",
1008 G_CALLBACK(on_zclglobal_control_write_attributes_no_resp), service_interface);
1010 g_signal_connect(zclglobal_control_object,
1011 "handle-write-attributes-structured",
1012 G_CALLBACK(on_zclglobal_control_write_attributes_structured), service_interface);
1014 g_signal_connect(zclglobal_control_object,
1015 "handle-read-attributes-structured",
1016 G_CALLBACK(on_zclglobal_control_read_attributes_structured), service_interface);
1018 g_signal_connect(zclglobal_control_object,
1019 "handle-configure-reporting-req",
1020 G_CALLBACK(on_zclglobal_control_configure_reporting_req), service_interface);
1022 g_signal_connect(zclglobal_control_object,
1023 "handle-read-configure-reporting",
1024 G_CALLBACK(on_zclglobal_control_read_configure_reporting), service_interface);
1026 g_signal_connect(zclglobal_control_object,
1027 "handle-discover-attributes",
1028 G_CALLBACK(on_zclglobal_control_discover_attributes), service_interface);
1030 g_signal_connect(zclglobal_control_object,
1031 "handle-discover-attributes-extended",
1032 G_CALLBACK(on_zclglobal_control_discover_attributes_extended), service_interface);
1034 g_signal_connect(zclglobal_control_object,
1035 "handle-discover-commands-received",
1036 G_CALLBACK(on_zclglobal_control_discover_commands_received), service_interface);
1038 g_signal_connect(zclglobal_control_object,
1039 "handle-discover-commands-generated",
1040 G_CALLBACK(on_zclglobal_control_discover_commands_generated), service_interface);