4 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
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.
20 #include "server_channel_handler.h"
22 #include <sensor_log.h>
23 #include <sensor_info.h>
24 #include <sensor_handler.h>
25 #include <command_types.h>
27 using namespace sensor;
30 server_channel_handler::server_channel_handler(sensor_manager *manager)
35 server_channel_handler::~server_channel_handler()
39 void server_channel_handler::connected(channel *ch)
43 void server_channel_handler::disconnected(channel *ch)
45 auto it = m_listeners.find(ch);
46 ret_if(it == m_listeners.end());
48 _I("Disconnected listener[%u]", it->second->get_id());
51 m_listeners.erase(ch);
54 void server_channel_handler::read(channel *ch, message &msg)
59 case CMD_MANAGER_SENSOR_LIST:
60 err = manager_get_sensor_list(ch, msg); break;
61 case CMD_LISTENER_CONNECT:
62 err = listener_connect(ch, msg); break;
63 case CMD_LISTENER_DISCONNECT:
64 err = listener_disconnect(ch, msg); break;
65 case CMD_LISTENER_START:
66 err = listener_start(ch, msg); break;
67 case CMD_LISTENER_STOP:
68 err = listener_stop(ch, msg); break;
69 case CMD_LISTENER_ATTR_INT:
70 err = listener_attr_int(ch, msg); break;
71 case CMD_LISTENER_ATTR_STR:
72 err = listener_attr_str(ch, msg); break;
73 case CMD_LISTENER_GET_DATA:
74 err = listener_get_data(ch, msg); break;
75 case CMD_PROVIDER_CONNECT:
76 err = provider_connect(ch, msg); break;
77 case CMD_PROVIDER_DISCONNECT:
78 err = provider_disconnect(ch, msg); break;
79 case CMD_PROVIDER_POST:
80 err = provider_post(ch, msg); break;
86 ch->send_sync(&reply);
90 int server_channel_handler::manager_get_sensor_list(channel *ch, message &msg)
96 size = m_manager->serialize(ch->get_fd(), &bytes);
97 retv_if(size < 0, size);
99 reply.enclose((const char *)bytes, size);
100 ch->send_sync(&reply);
107 int server_channel_handler::listener_connect(channel *ch, message &msg)
109 static uint32_t listener_id = 1;
110 sensor_handler *sensor;
111 cmd_listener_connect_t buf;
113 msg.disclose((char *)&buf);
115 sensor = m_manager->get_sensor(buf.sensor);
116 retv_if(!sensor, OP_ERROR);
118 sensor_listener_proxy *listener =
119 new(std::nothrow) sensor_listener_proxy(listener_id, sensor, ch);
120 retvm_if(!listener, OP_ERROR, "Failed to allocate memory");
122 buf.listener_id = listener_id;
125 reply.enclose((const char *)&buf, sizeof(buf));
126 reply.header()->err = OP_SUCCESS;
128 if (!ch->send_sync(&reply))
131 _I("Connected sensor_listener[fd(%d) -> id(%u)]", ch->get_fd(), listener_id);
133 m_listeners[ch] = listener;
138 int server_channel_handler::listener_disconnect(channel *ch, message &msg)
140 auto it = m_listeners.find(ch);
141 retv_if(it == m_listeners.end(), -EINVAL);
143 uint32_t id = m_listeners[ch]->get_id();
145 delete m_listeners[ch];
146 m_listeners.erase(ch);
148 _D("Disconnected sensor_listener[%u]", id);
150 return send_reply(ch, OP_SUCCESS);
153 int server_channel_handler::listener_start(channel *ch, message &msg)
155 auto it = m_listeners.find(ch);
156 retv_if(it == m_listeners.end(), -EINVAL);
158 int ret = m_listeners[ch]->start();
159 retv_if(ret < 0, ret);
161 return send_reply(ch, OP_SUCCESS);
164 int server_channel_handler::listener_stop(channel *ch, message &msg)
166 auto it = m_listeners.find(ch);
167 retv_if(it == m_listeners.end(), -EINVAL);
169 int ret = m_listeners[ch]->stop();
170 retv_if(ret < 0, ret);
172 return send_reply(ch, OP_SUCCESS);
175 int server_channel_handler::listener_attr_int(channel *ch, message &msg)
177 int ret = OP_SUCCESS;
179 auto it = m_listeners.find(ch);
180 retv_if(it == m_listeners.end(), -EINVAL);
182 cmd_listener_attr_int_t buf;
183 msg.disclose((char *)&buf);
185 switch (buf.attribute) {
186 case SENSORD_ATTRIBUTE_INTERVAL:
187 ret = m_listeners[ch]->set_interval(buf.value); break;
188 case SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY:
189 ret = m_listeners[ch]->set_max_batch_latency(buf.value); break;
190 case SENSORD_ATTRIBUTE_PASSIVE_MODE:
191 ret = m_listeners[ch]->set_passive_mode(buf.value); break;
192 case SENSORD_ATTRIBUTE_PAUSE_POLICY:
193 case SENSORD_ATTRIBUTE_AXIS_ORIENTATION:
195 ret = m_listeners[ch]->set_attribute(buf.attribute, buf.value);
197 retv_if(ret < 0, ret);
199 return send_reply(ch, OP_SUCCESS);
202 int server_channel_handler::listener_attr_str(channel *ch, message &msg)
204 auto it = m_listeners.find(ch);
205 retv_if(it == m_listeners.end(), -EINVAL);
207 cmd_listener_attr_str_t buf;
208 msg.disclose((char *)&buf);
210 int ret = m_listeners[ch]->set_attribute(buf.attribute, buf.value, buf.len);
211 retv_if(ret < 0, ret);
213 return send_reply(ch, OP_SUCCESS);
216 int server_channel_handler::listener_get_data(channel *ch, message &msg)
218 return send_reply(ch, OP_ERROR);
221 int server_channel_handler::provider_connect(channel *ch, message &msg)
223 return send_reply(ch, OP_ERROR);
226 int server_channel_handler::provider_disconnect(channel *ch, message &msg)
228 return send_reply(ch, OP_ERROR);
231 int server_channel_handler::provider_post(channel *ch, message &msg)
233 return send_reply(ch, OP_ERROR);
236 int server_channel_handler::send_reply(channel *ch, int error)
238 message reply(error);
239 retvm_if(!ch->send_sync(&reply), OP_ERROR, "Failed to send reply");