void AVReceiver::dataGet(std::string msg)
{
if (msg.find('\n') == std::string::npos &&
msg.find('\r') == std::string::npos)
{
//We have not a complete paquet yet, buffurize it.
recv_buffer += msg;
cDebugDom("output") << "Bufferize data.";
return;
}
if (!recv_buffer.empty())
{
//Put last data in buffer
recv_buffer += msg;
msg = recv_buffer;
recv_buffer.clear();
}
replace_str(msg, "\r\n", "\n");
replace_str(msg, "\r", "\n");
std::vector<std::string> tokens;
Utils::split(msg, tokens, "\n");
cDebugDom("output") << "Got " << tokens.size() << " messages.";
for(uint i = 0; i < tokens.size(); i++)
processMessage(tokens[i]);
}
void AVReceiver::timerConnReconnect()
{
cDebugDom("output") << "Connecting to " << host << ":" << port;
DELETE_NULL_FUNC(ecore_con_server_del, econ);
econ = ecore_con_server_connect(ECORE_CON_REMOTE_TCP, host.c_str(), port, this);
ecore_con_server_data_set(econ, this);
cDebugDom("output") << "econ == " << econ;
}
void HueOutputLightRGB::setColorReal(const ColorValue &c, bool s)
{
if (!s)
{
cDebugDom("hue") << "State OFF ";
setOff();
}
else
{
cDebugDom("hue") << "Hue color: " << c.toString();
setColor(c);
}
}
AVReceiver::AVReceiver(Params &p, int default_port, int _connection_type):
ref_count(0),
params(p),
econ(NULL),
timer_con(NULL),
isConnected(false),
volume_main(0),
volume_zone2(0),
volume_zone3(0),
power_main(false),
power_zone2(false),
power_zone3(false),
source_main(0),
source_zone2(0),
source_zone3(0),
connection_type(_connection_type)
{
cDebugDom("output") << params["id"];
if (!params.Exists("visible")) params.Add("visible", "false");
host = params["host"];
port = default_port;
if (params.Exists("port"))
from_string(params["port"], port);
ehandler_add = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_con_server_add, this);
ehandler_del = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL, (Ecore_Event_Handler_Cb)_con_server_del, this);
ehandler_data = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA, (Ecore_Event_Handler_Cb)_con_server_data, this);
timerConnReconnect();
timer_con = new EcoreTimer(AVR_RECONNECT, (sigc::slot<void>)sigc::mem_fun(*this, &AVReceiver::timerConnReconnect));
}
void CalaosCameraView::play()
{
if (ecurl)
ecore_con_url_free(ecurl);
ecurl = ecore_con_url_new(cameraUrl.c_str());
if (!ecurl)
{
cErrorDom("camera") << "Failed to create ecore_con_url!";
return;
}
ecore_con_url_data_set(ecurl, this);
ecore_con_url_ssl_verify_peer_set(ecurl, false);
single_frame = false;
buffer.clear();
formatDetected = false;
format_error = false;
nextContentLength = -1;
if (!ecore_con_url_get(ecurl))
{
cErrorDom("camera") << "Could not realize request!";
ecore_con_url_free(ecurl);
ecurl = nullptr;
}
cDebugDom("camera") << "Request started to " << cameraUrl;
}
ZibaseTemp::ZibaseTemp(Params &p):
InputTemp(p),
port(0)
{
// Define IO documentation
ioDoc->friendlyNameSet("ZibaseTemp");
ioDoc->descriptionSet(_("Zibase temperature sensor"));
ioDoc->paramAdd("host", _("Zibase IP address on the network"), IODoc::TYPE_STRING, true);
ioDoc->paramAddInt("port", _("Zibase ethernet port, default to 17100"), 0, 65535, false, 17100);
ioDoc->paramAdd("zibase_id", _("Zibase device ID (ABC)"), IODoc::TYPE_STRING, true);
Params devList = {{ "temp", _("Temperature sensor") }};
ioDoc->paramAddList("zibase_sensor", "Type of sensor", true, devList, "temp");
if (!param_exists("port")) set_param("port", "17100");
host = get_param("host");
Utils::from_string(get_param("port"), port);
id = get_param("zibase_id");
sensor_type = ZibaseInfoSensor::eTEMP;
Zibase::Instance(host, port).sig_newframe.connect(sigc::mem_fun(*this, &ZibaseTemp::valueUpdated));
cDebugDom("input") << get_param("id");
}
void FileDownloader::Cancel()
{
if (!url_con)
return;
ecore_con_url_free(url_con);
url_con = NULL;
fclose(dl_file);
if (dest.empty())
ecore_file_unlink(tmpFile.c_str());
cDebugDom("downloader") << "Download aborted! (" << url << ")";
IPC::Instance().SendEvent("downloader::" + Utils::to_string(this),
"aborted",
IPCData(new std::string(url), new Utils::DeletorT<std::string *>()),
true);
cb_signal.emit("aborted", &url);
cb_signal_user.emit("aborted", &url, user_data);
if (auto_destroy)
{
Destroy();
}
}
void JsonApiHandlerHttp::sendJson(json_t *json)
{
char *d = json_dumps(json, JSON_COMPACT | JSON_ENSURE_ASCII /*| JSON_ESCAPE_SLASH*/);
if (!d)
{
json_decref(json);
cDebugDom("network") << "json_dumps failed!";
Params headers;
headers.Add("Connection", "close");
headers.Add("Content-Type", "text/html");
string res = httpClient->buildHttpResponse(HTTP_500, headers, HTTP_500_BODY);
sendData.emit(res);
closeConnection.emit(0, string());
return;
}
json_decref(json);
string data(d);
free(d);
Params headers;
headers.Add("Connection", "Close");
headers.Add("Cache-Control", "no-cache, must-revalidate");
headers.Add("Expires", "Mon, 26 Jul 1997 05:00:00 GMT");
headers.Add("Content-Type", "application/json");
headers.Add("Content-Length", Utils::to_string(data.size()));
string res = httpClient->buildHttpResponse(HTTP_200, headers, data);
sendData.emit(res);
}
void AVReceiver::sendRequest(std::vector<char> request)
{
if (!econ || !isConnected) return;
cDebugDom("output") << request.size() << " bytes";
ecore_con_server_send(econ, &request[0], request.size());
}
void ActionStd::Remove(int pos)
{
auto iter = outputs.begin();
for (int i = 0;i < pos;iter++, i++) ;
outputs.erase(iter);
cDebugDom("rule.action.standard") << "Ok";
}
void HttpServer::addConnection(Ecore_Con_Client *client)
{
cDebugDom("network")
<< "Got a new connection from address "
<< ecore_con_client_ip_get(client);
WebSocket *conn = new WebSocket(client);
connections[client] = conn;
}
void JsonApiHandlerWS::handleEvents(const CalaosEvent &event)
{
if (!loggedin)
return;
cDebugDom("network") << "Handling event: " << event.toString();
sendJson("event", event.toJson());
}
void AVReceiver::sendRequest(std::string request)
{
if (!econ || !isConnected) return;
cDebugDom("output") << "Command: " << request;
request += command_suffix;
ecore_con_server_send(econ, request.c_str(), request.length());
}
AVReceiver::~AVReceiver()
{
DELETE_NULL(timer_con);
DELETE_NULL_FUNC(ecore_con_server_del, econ);
DELETE_NULL_FUNC(ecore_event_handler_del, ehandler_add);
DELETE_NULL_FUNC(ecore_event_handler_del, ehandler_del);
DELETE_NULL_FUNC(ecore_event_handler_del, ehandler_data);
cDebugDom("output");
}
void AVReceiver::addConnection(Ecore_Con_Server *srv)
{
if (srv != econ) return;
DELETE_NULL(timer_con);
isConnected = true;
connectionEstablished();
cDebugDom("output") << "main connection established";
}
void HueOutputLightRGB::setOff()
{
std::string url = "http://" + m_host + "/api/" + m_api + "/lights/" + m_idHue + "/state";
UrlDownloader *dl = new UrlDownloader(url, true);
dl->bodyDataSet("{\"on\":false}");
dl->m_signalCompleteData.connect([&](Eina_Binbuf *downloadedData, int status)
{
cDebugDom("hue") << "datareceived: " << eina_binbuf_string_get(downloadedData);
});
dl->httpPut();
}
HttpServer::~HttpServer()
{
ecore_con_server_del(tcp_server);
tcp_server = NULL;
ecore_event_handler_del(event_handler_client_add);
ecore_event_handler_del(event_handler_client_del);
ecore_event_handler_del(event_handler_data_get);
ecore_event_handler_del(event_handler_client_write);
cDebugDom("network");
}
void ActionStd::Add(IOBase *out)
{
if (!out->isOutput())
{
cWarningDom("rule.action.standard") << "Unable to add IO "
<< out->get_param("id")
<< " to action list. IO is not an output";
return;
}
outputs.push_back(out);
cDebugDom("rule.action.standard") << "Output(" << out->get_param("id") << ") added";
}
Eina_Bool _url_complete_cb(void *data, int type, void *event_info)
{
Ecore_Con_Event_Url_Complete *url_complete = reinterpret_cast<Ecore_Con_Event_Url_Complete *>(event_info);
CalaosCameraView *view = reinterpret_cast<CalaosCameraView *>(data);
if (view != ecore_con_url_data_get(url_complete->url_con))
return true;
cDebugDom("camera") << "completed: " << view->buffer.size();
view->requestCompleted();
return true;
}
HttpServer::HttpServer(int p):
port(p),
tcp_server(NULL)
{
/* Setup ecore con TCP server and callbacks */
tcp_server = ecore_con_server_add(ECORE_CON_REMOTE_TCP, "0.0.0.0", port, this);
ecore_con_server_data_set(tcp_server, this);
event_handler_client_add = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_ecore_con_handler_client_add, this);
event_handler_client_del = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb)_ecore_con_handler_data_get, this);
event_handler_client_write = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_WRITE, (Ecore_Event_Handler_Cb)_ecore_con_handler_data_write, this);
event_handler_data_get = ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_ecore_con_handler_client_del, this);
cDebugDom("network") << "Init TCP Server";
cInfoDom("network") << "Listening on port " << port;
}
void HttpServer::dataWritten(Ecore_Con_Client *client, int size)
{
cDebugDom("network")
<< Utils::to_string(size) << " bytes written"
<< " to client at address "
<< ecore_con_client_ip_get(client);
std::map<Ecore_Con_Client *, WebSocket *>::iterator it = connections.find(client);
if (it == connections.end())
{
cCriticalDom("network") << "Can't find corresponding HttpClient !";
return;
}
it->second->DataWritten(size);
}
void HttpServer::delConnection(Ecore_Con_Client *client)
{
cDebugDom("network")
<< "Connection from adress "
<< ecore_con_client_ip_get(client) << " closed.";
std::map<Ecore_Con_Client *, WebSocket *>::iterator it = connections.find(client);
if (it == connections.end())
{
cCriticalDom("network") << "Can't find corresponding HttpClient !";
return;
}
delete it->second;
connections.erase(it);
}
void HueOutputLightRGB::setColor(const ColorValue &c)
{
std::string url = "http://" + m_host + "/api/" + m_api + "/lights/" + m_idHue + "/state";
UrlDownloader *dl = new UrlDownloader(url, true);
std::string ccolor = "{\"on\":true,"
"\"sat\":" + Utils::to_string((int)(c.getHSVSaturation() * 255.0 / 100.0)) +
",\"bri\":" + Utils::to_string((int)(c.getHSLLightness() * 255.0 / 100.0)) +
",\"hue\":" + Utils::to_string((int)(c.getHSLHue() * 65535.0 / 360.0)) + "}";
dl->bodyDataSet(ccolor);
dl->m_signalCompleteData.connect([&](Eina_Binbuf *downloadedData, int status)
{
VAR_UNUSED(status);
cDebugDom("hue") << "datareceived: " << eina_binbuf_string_get(downloadedData);
});
dl->httpPut();
}
Eina_Bool _url_data_cb(void *data, int type, void *event_info)
{
Ecore_Con_Event_Url_Data *url_data = reinterpret_cast<Ecore_Con_Event_Url_Data *>(event_info);
CalaosCameraView *view = reinterpret_cast<CalaosCameraView *>(data);
if (view != ecore_con_url_data_get(url_data->url_con))
return true;
view->buffer.reserve(view->buffer.size() + url_data->size);
std::copy(url_data->data, url_data->data + url_data->size, std::back_inserter(view->buffer));
if (view->headers.size() <= 0)
{
const Eina_List *headers, *l;
void *str;
headers = ecore_con_url_response_headers_get(url_data->url_con);
EINA_LIST_FOREACH(headers, l, str)
{
if (!str) continue;
string s((char *)str);
vector<string> tokens;
Utils::replace_str(s, "\n", "");
Utils::replace_str(s, "\r", "");
Utils::split(s, tokens, ":", 2);
string key = tokens[0];
Utils::trim_left(key, " ");
Utils::trim_right(key, " ");
string val = tokens[1];
Utils::trim_left(val, " ");
Utils::trim_right(val, " ");
cDebugDom("camera") << "add key: \"" << key << "\" with value: \"" << val << "\"";
view->headers.Add(key, val);
}
}
view->processData();
return true;
}
void HttpServer::getDataConnection(Ecore_Con_Client *client, void *data, int size)
{
std::string d((char *)data, size);
cDebugDom("network")
<< "Got data from client at address "
<< ecore_con_client_ip_get(client);
std::map<Ecore_Con_Client *, WebSocket *>::iterator it = connections.find(client);
if (it == connections.end())
{
cCriticalDom("network") << "Can't find corresponding HttpClient !";
return;
}
it->second->ProcessData(d);
}
OwCtrl::OwCtrl(const string &args)
{
cDebugDom("1wire") << "new OWCtrl: " << args;
process = new ExternProcServer("1wire");
exe = Prefix::Instance().binDirectoryGet() + "/calaos_1wire";
process->messageReceived.connect(sigc::mem_fun(*this, &OwCtrl::processNewMessage));
process->processExited.connect([=]()
{
//restart process when stopped
cWarningDom("process") << "process exited, restarting...";
process->startProcess(exe, "1wire", args);
});
process->startProcess(exe, "1wire", args);
}
void CalaosConnection::onConnected()
{
if (con_state == CALAOS_CON_NONE)
{
con_state = CALAOS_CON_LOGIN;
//Get username/password
string username;
string password;
getCredentials(username, password);
json_t *jlogin = json_pack("{s:s, s:s}",
"cn_user", username.c_str(),
"cn_pass", password.c_str());
sendJson("login", jlogin);
cDebugDom("network.connection") << "trying to log in.";
}
}
void ActivityScheduleScenarioView::headerWeekButtonClick(string bt)
{
if (bt == "button.back")
{
editState = editStatesHist.top();
editStatesHist.pop();
elm_naviframe_item_pop(pager_popup);
}
else if (bt == "button.valid")
{
if (is_edit)
{
deleteTimeRange(old_range);
}
if (week_days[0]->isSelected() || week_days[1]->isSelected())
range_infos.range_monday.push_back(edit_range);
if (week_days[0]->isSelected() || week_days[2]->isSelected())
range_infos.range_tuesday.push_back(edit_range);
if (week_days[0]->isSelected() || week_days[3]->isSelected())
range_infos.range_wednesday.push_back(edit_range);
if (week_days[0]->isSelected() || week_days[4]->isSelected())
range_infos.range_thursday.push_back(edit_range);
if (week_days[0]->isSelected() || week_days[5]->isSelected())
range_infos.range_friday.push_back(edit_range);
if (week_days[0]->isSelected() || week_days[6]->isSelected())
range_infos.range_saturday.push_back(edit_range);
if (week_days[0]->isSelected() || week_days[7]->isSelected())
range_infos.range_sunday.push_back(edit_range);
cDebugDom("auto_scenario") << "New TimeRange: " << edit_range.toString();
elm_ctxpopup_dismiss(popup);
reloadTimeRanges();
}
}
bool ActionStd::Execute()
{
std::string tmp;
bool ret = true;
std::string sval;
bool bval = false;
double dval = 0;
for (uint i = 0;i < outputs.size();i++)
{
bool ovar = false;
switch (outputs[i]->get_type())
{
case TBOOL:
{
if (params_var[outputs[i]->get_param("id")] != "")
{
std::string var_id = params_var[outputs[i]->get_param("id")];
IOBase *out = ListeRoom::Instance().get_io(var_id);
if (out && out->get_type() == TBOOL)
{
bval = out->get_value_bool();
ovar = true;
}
}
if (ovar)
{
if (!outputs[i]->set_value(bval)) ret = false;
}
else if (params[outputs[i]->get_param("id")] == "true")
{
if (!outputs[i]->set_value(true)) ret = false;
}
else if (params[outputs[i]->get_param("id")] == "false")
{
if (!outputs[i]->set_value(false)) ret = false;
}
else
{
if (!outputs[i]->set_value(params[outputs[i]->get_param("id")])) ret = false;
}
break;
}
case TINT:
{
if (params_var[outputs[i]->get_param("id")] != "")
{
std::string var_id = params_var[outputs[i]->get_param("id")];
IOBase *out = ListeRoom::Instance().get_io(var_id);
if (out && out->get_type() == TINT)
{
dval = out->get_value_double();
ovar = true;
}
}
tmp = params[outputs[i]->get_param("id")];
if (ovar)
{
if (!outputs[i]->set_value(dval)) ret = false;
}
else if (is_of_type<double>(tmp))
{
if (!outputs[i]->set_value(atof(tmp.c_str()))) ret = false;
}
else
{
if (!outputs[i]->set_value(tmp)) ret = false;
}
break;
}
case TSTRING:
{
if (params_var[outputs[i]->get_param("id")] != "")
{
std::string var_id = params_var[outputs[i]->get_param("id")];
IOBase *out = ListeRoom::Instance().get_io(var_id);
if (out && out->get_type() == TSTRING)
{
sval = out->get_command_string();
ovar = true;
}
}
tmp = params[outputs[i]->get_param("id")];
if (ovar)
{
if (!outputs[i]->set_value(sval)) ret = false;
}
else if (tmp != "")
{
if (!outputs[i]->set_value(tmp)) ret = false;
}
break;
}
default: break;
}
}
if (ret)
cDebugDom("rule.action.standard") << "Ok";
else
cErrorDom("rule.action.standard") << "Failed !";
return ret;
}
ActionStd::~ActionStd()
{
cDebugDom("rule.action.standard");
}
