Subversion Repositories HomeAutomation

Rev

Rev 1614 | Rev 1625 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | SVN | RSS feed

Rev Author Line No. Line
1602 runge 1 
/*
2 
 *
3 
 *  Copyright (C) 2010  Mattias Runge
4 
 *
5 
 *  This program is free software; you can redistribute it and/or modify
6 
 *  it under the terms of the GNU General Public License as published by
7 
 *  the Free Software Foundation; either version 2 of the License, or
8 
 *  (at your option) any later version.
9 
 *
10 
 *  This program is distributed in the hope that it will be useful,
11 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 
 *  GNU General Public License for more details.
14 
 *
15 
 *  You should have received a copy of the GNU General Public License along
16 
 *  with this program; if not, write to the Free Software Foundation, Inc.,
17 
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 
 *
19 
 */
20 
 
21 
#include "Module.h"
22 
 
23 
#include <boost/lexical_cast.hpp>
24 
 
25 
#include "can/Manager.h"
1619 runge 26 
#include "vm/Manager.h"
1602 runge 27 
 
28 
namespace atom {
29 
namespace vm {
30 
namespace plugin {
31 
 
32 
logging::Logger Module::LOG("vm::plugin::module");
33 
 
34 
Module::Module()
35 
{
36 
    this->name_ = "module";
37 
 
38 
    this->ExportFunction("Module_SendMessage", Module::Export_SendModuleMessage);
1604 runge 39 
    this->ExportFunction("Module_IsModuleAvailable", Module::Export_IsModuleAvailable);
1602 runge 40 
}
41 
 
42 
Module::~Module()
43 
{
44 
    this->tracker_.reset();
45 
}
46 
 
47 
void Module::InitializeDone()
48 
{
49 
    Plugin::InitializeDone();
50 
 
1608 runge 51 
    this->ImportFunction("Module_OnChange");
52 
    this->ImportFunction("Module_OnMessage");
53 
 
1614 runge 54 
    can::Manager::Instance()->ConnectSlots(can::Manager::SignalOnNodeChange::slot_type(&Module::SlotOnNodeChange, this, _1, _2).track(this->tracker_),
55 
                                           can::Manager::SignalOnModuleChange::slot_type(&Module::SlotOnModuleChange, this, _1, _2).track(this->tracker_),
1602 runge 56 
                                           can::Manager::SignalOnModuleMessage::slot_type(&Module::SlotOnModuleMessage, this, _1, _2, _3).track(this->tracker_));
57 
}
58 
 
1614 runge 59 
void Module::SlotOnNodeChange(unsigned int node_id, bool available)
60 
{
61 
 
62 
}
63 
 
1602 runge 64 
void Module::SlotOnModuleChange(std::string full_id, bool available)
65 
{
66 
    ArgumentListPointer arguments = ArgumentListPointer(new ArgumentList);
67 
    arguments->push_back(v8::String::New(full_id.data()));
68 
    arguments->push_back(v8::Boolean::New(available));
69 
 
1608 runge 70 
    this->Call(0, "Module_OnChange", arguments);
1602 runge 71 
}
72 
 
73 
void Module::SlotOnModuleMessage(std::string full_id, std::string command, type::StringMap variables)
74 
{
1619 runge 75 
    v8::Context::Scope context_scope(vm::Manager::Instance()->GetContext());
76 
 
1609 runge 77 
    //LOG.Debug(std::string(__FUNCTION__) + " called!");
78 
 
1602 runge 79 
    ArgumentListPointer arguments = ArgumentListPointer(new ArgumentList);
80 
 
81 
    arguments->push_back(v8::String::New(full_id.data()));
82 
    arguments->push_back(v8::String::New(command.data()));
83 
 
1619 runge 84 
    v8::Local<v8::Array> vars = v8::Array::New(variables.size());
85 
 
1602 runge 86 
    for (type::StringMap::iterator it = variables.begin(); it != variables.end(); it++)
87 
    {
1619 runge 88 
        vars->Set(v8::String::New(it->first.data()), v8::String::New(it->second.data()));
1602 runge 89 
    }
90 
 
1619 runge 91 
    arguments->push_back(vars);
92 
 
1608 runge 93 
    this->Call(0, "Module_OnMessage", arguments);
1602 runge 94 
}
95 
 
1604 runge 96 
Value Module::Export_SendModuleMessage(const v8::Arguments& args)
1602 runge 97 
{
1609 runge 98 
    //LOG.Debug(std::string(__FUNCTION__) + " called!");
1604 runge 99 
 
100 
    if (args.Length() < 3)
101 
    {
102 
        LOG.Error("To few arguments.");
103 
    }
104 
 
1602 runge 105 
    type::StringMap variables;
106 
 
107 
    v8::String::AsciiValue full_id(args[0]);
108 
    v8::String::AsciiValue command(args[1]);
109 
    unsigned int length = args[2]->Uint32Value();
110 
 
111 
    for (unsigned int n = 3; n < length * 2 + 3; n += 2)
112 
    {
113 
        v8::String::AsciiValue name(args[n]);
114 
        v8::String::AsciiValue value(args[n + 1]);
115 
 
1607 runge 116 
        //LOG.Debug(std::string(*name) + "====" + std::string(*value));
117 
 
1602 runge 118 
        variables[std::string(*name)] = std::string(*value);
119 
    }
120 
 
121 
    can::Manager::Instance()->SendMessage(std::string(*full_id), std::string(*command), variables);
1604 runge 122 
 
123 
    return v8::Undefined();
1602 runge 124 
}
1604 runge 125 
 
126 
Value Module::Export_IsModuleAvailable(const v8::Arguments& args)
127 
{
128 
    LOG.Debug(std::string(__FUNCTION__) + " called!");
1602 runge 129 
 
1604 runge 130 
    if (args.Length() < 1)
131 
    {
132 
        LOG.Error("To few arguments.");
133 
    }
134 
 
135 
    v8::String::AsciiValue full_id(args[0]);
136 
 
137 
    return v8::Boolean::New(can::Manager::Instance()->IsModuleAvailable(std::string(*full_id)));
138 
}
139 
 
1602 runge 140 
}; // namespace plugin
141 
}; // namespace vm
142 
}; // namespace atom