Changeset bdd95b


Ignore:
Timestamp:
02/27/12 16:51:52 (9 years ago)
Author:
Micke Prag <micke.prag@…>
Branches:
('master', 'cc326285c5d9e5d35ef50c97ddab57539e602594')
Children:
9500c4c898404ccef239eb50336d2ad3d4046c94
Parents:
842a042cdbf502f00883b8655f442d261fc5ecf35fcc391c9565dc5d4ae3edcf84132b6a3fcc024c
git-author:
Micke Prag <micke.prag@telldus.se>2012-02-27 16:51:33+01:00
git-committer:
Micke Prag <micke.prag@telldus.se>2012-02-27 16:51:52+01:00
Message:

Merge branch 't108' into master
Closes #108

Files:
18 added
36 edited

Legend:

Unmodified
Added
Removed
  • telldus-core/client/CallbackDispatcher.cpp

    rc049b9 r246b42  
    1212using namespace TelldusCore; 
    1313 
    14 TDDeviceEventDispatcher::TDDeviceEventDispatcher(CallbackStruct<TDDeviceEvent> *data, int id, int m, const std::string &strD, TelldusCore::EventRef cbDone) 
    15 :Thread(), d(data), deviceId(id), method(m), strData(strD), doneRunning(false), callbackExecuted(cbDone) 
     14TDEventDispatcher::TDEventDispatcher(EventDataRef cbd, CallbackStruct *cb, EventRef cbDone) 
     15        :Thread(), doneRunning(false), callbackData(cbd), callback(cb), callbackExecuted(cbDone) 
    1616{ 
    17         this->startAndLock(&d->mutex); 
     17        this->startAndLock(&callback->mutex); 
    1818} 
    1919 
    20 TDDeviceEventDispatcher::~TDDeviceEventDispatcher() { 
     20TDEventDispatcher::~TDEventDispatcher() { 
    2121        this->wait(); 
    2222} 
    2323 
    24 bool TDDeviceEventDispatcher::done() const { 
     24bool TDEventDispatcher::done() const { 
    2525        return doneRunning; 
    2626} 
    2727 
    28 void TDDeviceEventDispatcher::run() { 
    29         char *str = wrapStdString(strData); 
    30         d->event(deviceId, method, strData.c_str(), d->id, d->context); 
     28void TDEventDispatcher::run() { 
     29        this->fireEvent(); 
    3130        doneRunning = true; 
    3231        callbackExecuted->signal(); 
    3332} 
    3433 
    35 TDDeviceChangeEventDispatcher::TDDeviceChangeEventDispatcher(CallbackStruct<TDDeviceChangeEvent> *data, int id, int event, int type, TelldusCore::EventRef cbDone) 
    36 :Thread(), d(data), deviceId(id), changeEvent(event), changeType(type), doneRunning(false), callbackExecuted(cbDone) 
    37 { 
    38         this->startAndLock(&d->mutex); 
     34void TDEventDispatcher::fireEvent() { 
     35        if (callback->type == CallbackStruct::DeviceEvent) { 
     36                DeviceEventCallbackData *data = dynamic_cast<DeviceEventCallbackData *>(callbackData.get()); 
     37                if (!data) { 
     38                        return; 
     39                } 
     40                ((TDDeviceEvent)callback->event)(data->deviceId, data->deviceState, data->deviceStateValue.c_str(), callback->id, callback->context); 
     41 
     42        } else if (callback->type == CallbackStruct::DeviceChangeEvent) { 
     43                DeviceChangeEventCallbackData *data = dynamic_cast<DeviceChangeEventCallbackData *>(callbackData.get()); 
     44                if (!data) { 
     45                        return; 
     46                } 
     47                ((TDDeviceChangeEvent)callback->event)(data->deviceId, data->changeEvent, data->changeType, callback->id, callback->context); 
     48 
     49        } else if (callback->type == CallbackStruct::RawDeviceEvent) { 
     50                RawDeviceEventCallbackData *data = dynamic_cast<RawDeviceEventCallbackData *>(callbackData.get()); 
     51                if (!data) { 
     52                        return; 
     53                } 
     54                ((TDRawDeviceEvent)callback->event)(data->data.c_str(), data->controllerId, callback->id, callback->context); 
     55 
     56        } else if (callback->type == CallbackStruct::SensorEvent) { 
     57                SensorEventCallbackData *data = dynamic_cast<SensorEventCallbackData *>(callbackData.get()); 
     58                if (!data) { 
     59                        return; 
     60                } 
     61                ((TDSensorEvent)callback->event)(data->protocol.c_str(), data->model.c_str(), data->id, data->dataType, data->value.c_str(), data->timestamp, callback->id, callback->context); 
     62 
     63        } else if (callback->type == CallbackStruct::ControllerEvent) { 
     64                ControllerEventCallbackData *data = dynamic_cast<ControllerEventCallbackData *>(callbackData.get()); 
     65                if (!data) { 
     66                        return; 
     67                } 
     68                ((TDControllerEvent)callback->event)(data->controllerId, data->changeEvent, data->changeType, data->newValue.c_str(), callback->id, callback->context); 
     69 
     70        } 
    3971} 
    40  
    41 TDDeviceChangeEventDispatcher::~TDDeviceChangeEventDispatcher() { 
    42         this->wait(); 
    43 } 
    44  
    45 bool TDDeviceChangeEventDispatcher::done() const { 
    46         return doneRunning; 
    47 } 
    48  
    49 void TDDeviceChangeEventDispatcher::run() { 
    50         d->event(deviceId, changeEvent, changeType, d->id, d->context); 
    51         doneRunning = true; 
    52         callbackExecuted->signal(); 
    53 } 
    54  
    55 TDRawDeviceEventDispatcher::TDRawDeviceEventDispatcher( CallbackStruct<TDRawDeviceEvent> *data, const std::string &strD, int id, TelldusCore::EventRef cbDone) 
    56 :Thread(), d(data), controllerId(id), strData(strD), doneRunning(false), callbackExecuted(cbDone) 
    57 { 
    58         this->startAndLock(&d->mutex); 
    59 } 
    60  
    61 TDRawDeviceEventDispatcher::~TDRawDeviceEventDispatcher() { 
    62         this->wait(); 
    63 } 
    64  
    65 bool TDRawDeviceEventDispatcher::done() const { 
    66         return doneRunning; 
    67 } 
    68  
    69 void TDRawDeviceEventDispatcher::run() { 
    70         d->event(strData.c_str(), controllerId, d->id, d->context); 
    71         doneRunning = true; 
    72         callbackExecuted->signal(); 
    73 } 
    74  
    75 TDSensorEventDispatcher::TDSensorEventDispatcher( CallbackStruct<TDSensorEvent> *data, const std::string &p, const std::string &m, int id, int type, const std::string &v, int t, TelldusCore::EventRef cbDone) 
    76         :Thread(), d(data), protocol(p), model(m), sensorId(id), dataType(type), value(v), timestamp(t), doneRunning(false), callbackExecuted(cbDone) 
    77 { 
    78         this->startAndLock(&d->mutex); 
    79 } 
    80  
    81 TDSensorEventDispatcher::~TDSensorEventDispatcher() { 
    82         this->wait(); 
    83 } 
    84  
    85 bool TDSensorEventDispatcher::done() const { 
    86         return doneRunning; 
    87 } 
    88  
    89 void TDSensorEventDispatcher::run() { 
    90         d->event(protocol.c_str(), model.c_str(), sensorId, dataType, value.c_str(), timestamp, d->id, d->context); 
    91         doneRunning = true; 
    92         callbackExecuted->signal(); 
    93 } 
  • telldus-core/client/CallbackDispatcher.h

    rc049b9 r246b42  
    1818 
    1919namespace TelldusCore { 
    20         template <typename T> struct CallbackStruct { 
     20 
     21        /*template <typename T> struct CallbackStruct { 
    2122                T event; 
    2223                int id; 
    2324                void *context; 
    2425                TelldusCore::Mutex mutex; 
     26        };*/ 
     27        struct CallbackStruct { 
     28                enum CallbackType { DeviceEvent, DeviceChangeEvent, RawDeviceEvent, SensorEvent, ControllerEvent }; 
     29                CallbackType type; 
     30                void *event; 
     31                int id; 
     32                void *context; 
     33                TelldusCore::Mutex mutex; 
     34        }; 
     35        /*typedef CallbackStruct<TDDeviceChangeEvent> DeviceChangeEvent; 
     36        typedef CallbackStruct<TDRawDeviceEvent> RawDeviceEvent; 
     37        typedef CallbackStruct<TDSensorEvent> SensorEvent;*/ 
     38 
     39        class CallbackData: public EventDataBase { 
     40        public: 
     41                explicit CallbackData(CallbackStruct::CallbackType t) : EventDataBase(), type(t) {} 
     42                CallbackStruct::CallbackType type; 
    2543        }; 
    2644 
    27         class TDDeviceEventDispatcher : public Thread { 
     45        class DeviceEventCallbackData : public CallbackData { 
    2846        public: 
    29                 TDDeviceEventDispatcher(CallbackStruct<TDDeviceEvent> *data, int deviceId, int method, const std::string &strData, TelldusCore::EventRef cbDone); 
    30                 virtual ~TDDeviceEventDispatcher(); 
     47                DeviceEventCallbackData() : CallbackData(CallbackStruct::DeviceEvent) {} 
     48                int deviceId; 
     49                int deviceState; 
     50                std::string deviceStateValue; 
     51        }; 
     52        class DeviceChangeEventCallbackData : public CallbackData { 
     53        public: 
     54                DeviceChangeEventCallbackData() : CallbackData(CallbackStruct::DeviceChangeEvent) {} 
     55                int deviceId; 
     56                int changeEvent; 
     57                int changeType; 
     58        }; 
     59 
     60        class RawDeviceEventCallbackData : public CallbackData { 
     61        public: 
     62                RawDeviceEventCallbackData() : CallbackData(CallbackStruct::RawDeviceEvent) {} 
     63                std::string data; 
     64                int controllerId; 
     65        }; 
     66 
     67        class SensorEventCallbackData : public CallbackData { 
     68        public: 
     69                SensorEventCallbackData() : CallbackData(CallbackStruct::SensorEvent) {} 
     70                std::string protocol; 
     71                std::string model; 
     72                int id; 
     73                int dataType; 
     74                std::string value; 
     75                int timestamp; 
     76        }; 
     77        class ControllerEventCallbackData : public CallbackData { 
     78        public: 
     79                ControllerEventCallbackData() : CallbackData(CallbackStruct::ControllerEvent) {} 
     80                int controllerId; 
     81                int changeEvent; 
     82                int changeType; 
     83                std::string newValue; 
     84        }; 
     85 
     86        class TDEventDispatcher : public Thread { 
     87        public: 
     88                TDEventDispatcher(EventDataRef callbackData, CallbackStruct *callback, TelldusCore::EventRef cbDone); 
     89                virtual ~TDEventDispatcher(); 
    3190                bool done() const; 
    3291        protected: 
     
    3493                bool doneRunning; 
    3594        private: 
    36                 CallbackStruct<TDDeviceEvent> *d; 
    37                 int deviceId, method; 
    38                 std::string strData; 
    39                 TelldusCore::EventRef callbackExecuted; 
    40         }; 
    41         class TDDeviceChangeEventDispatcher : public Thread { 
    42         public: 
    43                 TDDeviceChangeEventDispatcher(CallbackStruct<TDDeviceChangeEvent> *data, int deviceId, int changeEvent, int changeType, TelldusCore::EventRef cbDone); 
    44                 virtual ~TDDeviceChangeEventDispatcher(); 
    45                 bool done() const; 
    46         protected: 
    47                 virtual void run(); 
    48                 bool doneRunning; 
    49         private: 
    50                 CallbackStruct<TDDeviceChangeEvent> *d; 
    51                 int deviceId, changeEvent, changeType; 
    52                 TelldusCore::EventRef callbackExecuted; 
    53         }; 
    54         class TDRawDeviceEventDispatcher : public Thread { 
    55         public: 
    56                 TDRawDeviceEventDispatcher( CallbackStruct<TDRawDeviceEvent> *data, const std::string &strData, int controllerId, TelldusCore::EventRef cbDone); 
    57                 virtual ~TDRawDeviceEventDispatcher(); 
    58                 bool done() const; 
    59         protected: 
    60                 virtual void run(); 
    61                 bool doneRunning; 
    62         private: 
    63                 CallbackStruct<TDRawDeviceEvent> *d; 
    64                 int controllerId; 
    65                 std::string strData; 
    66                 TelldusCore::EventRef callbackExecuted; 
    67         }; 
    68         class TDSensorEventDispatcher : public Thread { 
    69         public: 
    70                 TDSensorEventDispatcher( CallbackStruct<TDSensorEvent> *data, const std::string &protocol, const std::string &model, int id, int dataType, const std::string &value, int timestamp, TelldusCore::EventRef cbDone); 
    71                 virtual ~TDSensorEventDispatcher(); 
    72                 bool done() const; 
    73         protected: 
    74                 virtual void run(); 
    75                 bool doneRunning; 
    76         private: 
    77                 CallbackStruct<TDSensorEvent> *d; 
    78                 std::string protocol; 
    79                 std::string model; 
    80                 int sensorId; 
    81                 int dataType; 
    82                 std::string value; 
    83                 int timestamp; 
    84                 TelldusCore::EventRef callbackExecuted; 
     95                void fireEvent(); 
     96                EventDataRef callbackData; 
     97                CallbackStruct *callback; 
     98                EventRef callbackExecuted; 
    8599        }; 
    86100} 
  • telldus-core/client/CallbackMainDispatcher.cpp

    rf0a07f r148fd5  
    1414using namespace TelldusCore; 
    1515 
     16typedef std::list<CallbackStruct *> CallbackList; 
     17 
    1618class CallbackMainDispatcher::PrivateData { 
    1719public: 
     
    1921        EventRef stopEvent, generalCallbackEvent, janitor; 
    2022 
    21         std::list<std::tr1::shared_ptr<TDDeviceEventDispatcher> > deviceEventThreadList; 
    22         std::list<std::tr1::shared_ptr<TDDeviceChangeEventDispatcher> > deviceChangeEventThreadList; 
    23         std::list<std::tr1::shared_ptr<TDRawDeviceEventDispatcher> > rawDeviceEventThreadList; 
    24         std::list<std::tr1::shared_ptr<TDSensorEventDispatcher> > sensorEventThreadList; 
     23        Mutex mutex; 
     24        std::list<std::tr1::shared_ptr<TelldusCore::TDEventDispatcher> > eventThreadList; 
    2525 
    26         Mutex mutex; 
     26        CallbackList callbackList; 
     27 
     28        int lastCallbackId; 
    2729}; 
    2830 
     
    3436        d->generalCallbackEvent = d->eventHandler.addEvent(); 
    3537        d->janitor = d->eventHandler.addEvent(); //Used for cleanups 
     38 
     39        d->lastCallbackId = 0; 
    3640} 
    3741 
     
    4953} 
    5054 
     55int CallbackMainDispatcher::registerCallback(CallbackStruct::CallbackType type, void *eventFunction, void *context) { 
     56        TelldusCore::MutexLocker locker(&d->mutex); 
     57        int id = ++d->lastCallbackId; 
     58        CallbackStruct *callback = new CallbackStruct; 
     59        callback->type = type; 
     60        callback->event = eventFunction; 
     61        callback->id = id; 
     62        callback->context = context; 
     63        d->callbackList.push_back(callback); 
     64        return id; 
     65} 
     66 
     67bool CallbackMainDispatcher::unregisterCallback(int callbackId) { 
     68        CallbackList newEventList; 
     69        { 
     70                TelldusCore::MutexLocker locker(&d->mutex); 
     71                for(CallbackList::iterator callback_it = d->callbackList.begin(); callback_it != d->callbackList.end(); ++callback_it) { 
     72                        if ( (*callback_it)->id != callbackId ) { 
     73                                continue; 
     74                        } 
     75                        newEventList.splice(newEventList.begin(), d->callbackList, callback_it); 
     76                        break; 
     77                } 
     78        } 
     79        if (newEventList.size()) { 
     80                CallbackList::iterator it = newEventList.begin(); 
     81                { //Lock and unlock to make sure no one else uses the object 
     82                        TelldusCore::MutexLocker locker( &(*it)->mutex ); 
     83                } 
     84                delete (*it); 
     85                newEventList.erase(it); 
     86                return true; 
     87        } 
     88        return false; 
     89} 
     90 
    5191void CallbackMainDispatcher::run(){ 
    5292 
     
    5898                if(d->generalCallbackEvent->isSignaled()){ 
    5999                        EventDataRef eventData = d->generalCallbackEvent->takeSignal(); 
    60                          
    61                         DeviceEventCallbackData *decd = dynamic_cast<DeviceEventCallbackData*>(eventData.get()); 
    62                         if(decd){ 
    63                                 std::tr1::shared_ptr<TDDeviceEventDispatcher> ptr(new TDDeviceEventDispatcher(decd->data, decd->deviceId, decd->deviceState, decd->deviceStateValue, d->janitor)); 
    64                                 MutexLocker locker(&d->mutex); 
    65                                 d->deviceEventThreadList.push_back(ptr); 
     100 
     101                        CallbackData *cbd = dynamic_cast<CallbackData *>(eventData.get()); 
     102                        if (!cbd) { 
    66103                                continue; 
    67104                        } 
    68  
    69                         DeviceChangeEventCallbackData *dcecd = dynamic_cast<DeviceChangeEventCallbackData*>(eventData.get()); 
    70                         if(dcecd){ 
    71                                 std::tr1::shared_ptr<TDDeviceChangeEventDispatcher> ptr(new TDDeviceChangeEventDispatcher(dcecd->data, dcecd->deviceId, dcecd->eventDeviceChanges, dcecd->eventChangeType, d->janitor)); 
    72                                 MutexLocker locker(&d->mutex); 
    73                                 d->deviceChangeEventThreadList.push_back(ptr); 
    74                                 continue; 
    75                         } 
    76                          
    77                         RawDeviceEventCallbackData *rdecd = dynamic_cast<RawDeviceEventCallbackData*>(eventData.get()); 
    78                         if(rdecd){ 
    79                                 std::tr1::shared_ptr<TDRawDeviceEventDispatcher> ptr(new TDRawDeviceEventDispatcher(rdecd->data, rdecd->command, rdecd->controllerId, d->janitor)); 
    80                                 MutexLocker locker(&d->mutex); 
    81                                 d->rawDeviceEventThreadList.push_back(ptr); 
    82                                 continue; 
    83                         } 
    84                          
    85                         SensorEventCallbackData *secd = dynamic_cast<SensorEventCallbackData*>(eventData.get()); 
    86                         if(secd){ 
    87                                 std::tr1::shared_ptr<TDSensorEventDispatcher> ptr(new TDSensorEventDispatcher(secd->data, secd->protocol, secd->model, secd->id, secd->dataType, secd->value, secd->timestamp, d->janitor)); 
    88                                 MutexLocker locker(&d->mutex); 
    89                                 d->sensorEventThreadList.push_back(ptr); 
    90                                 continue; 
     105                        TelldusCore::MutexLocker locker(&d->mutex); 
     106                        for(CallbackList::iterator callback_it = d->callbackList.begin(); callback_it != d->callbackList.end(); ++callback_it) { 
     107                                if ( (*callback_it)->type == cbd->type ) { 
     108                                        std::tr1::shared_ptr<TelldusCore::TDEventDispatcher> ptr(new TelldusCore::TDEventDispatcher(eventData, *callback_it, d->janitor)); 
     109                                        d->eventThreadList.push_back(ptr); 
     110                                } 
    91111                        } 
    92112                } 
     
    108128                again = false; 
    109129                MutexLocker locker(&d->mutex); 
    110                 std::list<std::tr1::shared_ptr<TDDeviceEventDispatcher> >::iterator it = d->deviceEventThreadList.begin(); 
    111                 for (;it != d->deviceEventThreadList.end(); ++it) { 
     130                std::list<std::tr1::shared_ptr<TDEventDispatcher> >::iterator it = d->eventThreadList.begin(); 
     131                for (;it != d->eventThreadList.end(); ++it) { 
    112132                        if ((*it)->done()) { 
    113                                 d->deviceEventThreadList.erase(it); 
    114                                 again = true; 
    115                                 break; 
    116                         } 
    117                 } 
    118         } while (again); 
    119  
    120         //Device Change Event 
    121         do { 
    122                 again = false; 
    123                 MutexLocker locker(&d->mutex); 
    124                 std::list<std::tr1::shared_ptr<TDDeviceChangeEventDispatcher> >::iterator it = d->deviceChangeEventThreadList.begin(); 
    125                 for (;it != d->deviceChangeEventThreadList.end(); ++it) { 
    126                         if ((*it)->done()) { 
    127                                 d->deviceChangeEventThreadList.erase(it); 
    128                                 again = true; 
    129                                 break; 
    130                         } 
    131                 } 
    132         } while (again); 
    133  
    134         //Raw Device Event 
    135         do { 
    136                 again = false; 
    137                 MutexLocker locker(&d->mutex); 
    138                 std::list<std::tr1::shared_ptr<TDRawDeviceEventDispatcher> >::iterator it = d->rawDeviceEventThreadList.begin(); 
    139                 for (;it != d->rawDeviceEventThreadList.end(); ++it) { 
    140                         if ((*it)->done()) { 
    141                                 d->rawDeviceEventThreadList.erase(it); 
    142                                 again = true; 
    143                                 break; 
    144                         } 
    145                 } 
    146         } while (again); 
    147  
    148         //Sensor Event 
    149         do { 
    150                 again = false; 
    151                 MutexLocker locker(&d->mutex); 
    152                 std::list<std::tr1::shared_ptr<TDSensorEventDispatcher> >::iterator it = d->sensorEventThreadList.begin(); 
    153                 for (;it != d->sensorEventThreadList.end(); ++it) { 
    154                         if ((*it)->done()) { 
    155                                 d->sensorEventThreadList.erase(it); 
     133                                d->eventThreadList.erase(it); 
    156134                                again = true; 
    157135                                break; 
  • telldus-core/client/CallbackMainDispatcher.h

    rf0a07f r148fd5  
    1717 
    1818namespace TelldusCore { 
    19         class DeviceChangeEventCallbackData : public EventDataBase { 
    20         public: 
    21                 CallbackStruct<TDDeviceChangeEvent> *data; 
    22                 int deviceId; 
    23                 int eventDeviceChanges; 
    24                 int eventChangeType; 
    25         }; 
    26  
    27         class DeviceEventCallbackData : public EventDataBase { 
    28         public: 
    29                 CallbackStruct<TDDeviceEvent> *data; 
    30                 int deviceId; 
    31                 int deviceState; 
    32                 std::string deviceStateValue; 
    33         }; 
    34  
    35         class RawDeviceEventCallbackData : public EventDataBase { 
    36         public: 
    37                 CallbackStruct<TDRawDeviceEvent> *data; 
    38                 int controllerId; 
    39                 std::string command; 
    40         }; 
    41  
    42         class SensorEventCallbackData : public EventDataBase { 
    43         public: 
    44                 CallbackStruct<TDSensorEvent> *data; 
    45                 std::string protocol; 
    46                 std::string model; 
    47                 int id; 
    48                 int dataType; 
    49                 std::string value; 
    50                 int timestamp; 
    51         }; 
    5219 
    5320        class CallbackMainDispatcher  : public Thread 
     
    5825 
    5926                EventRef retrieveCallbackEvent(); 
    60                  
     27 
     28                int registerCallback( TelldusCore::CallbackStruct::CallbackType type, void *eventFunction, void *context ); 
     29                bool unregisterCallback( int callbackId ); 
     30 
    6131        protected: 
    6232                void run(); 
  • telldus-core/client/Client.cpp

    rc049b9 r246b42  
    1010using namespace TelldusCore; 
    1111 
    12 typedef CallbackStruct<TDDeviceEvent> DeviceEvent; 
    13 typedef CallbackStruct<TDDeviceChangeEvent> DeviceChangeEvent; 
    14 typedef CallbackStruct<TDRawDeviceEvent> RawDeviceEvent; 
    15 typedef CallbackStruct<TDSensorEvent> SensorEvent; 
    16 typedef std::list<DeviceEvent *> DeviceEventList; 
    17 typedef std::list<DeviceChangeEvent *> DeviceChangeList; 
    18 typedef std::list<RawDeviceEvent *> RawDeviceEventList; 
    19 typedef std::list<SensorEvent *> SensorEventList; 
    20  
    2112class Client::PrivateData { 
    2213public: 
    23         int lastCallbackId; 
    24         DeviceEventList deviceEventList; 
    25         DeviceChangeList deviceChangeEventList; 
    2614        Socket eventSocket; 
    27         RawDeviceEventList rawDeviceEventList; 
    28         SensorEventList sensorEventList; 
    29         bool running, sensorCached; 
    30         std::wstring sensorCache; 
     15        bool running, sensorCached, controllerCached; 
     16        std::wstring sensorCache, controllerCache; 
    3117        TelldusCore::Mutex mutex; 
    3218        CallbackMainDispatcher callbackMainDispatcher; 
     
    4026{ 
    4127        d = new PrivateData; 
    42         d->lastCallbackId = 0; 
    4328        d->running = true; 
    4429        d->sensorCached = false; 
     30        d->controllerCached = false; 
    4531        d->callbackMainDispatcher.start(); 
    4632        start(); 
     
    7056} 
    7157 
    72 void Client::callbackDeviceEvent(int deviceId, int deviceState, const std::wstring &deviceStateValue){ 
    73         TelldusCore::MutexLocker locker(&d->mutex); 
    74         for(DeviceEventList::iterator callback_it = d->deviceEventList.begin(); callback_it != d->deviceEventList.end(); ++callback_it) { 
    75                 DeviceEventCallbackData *deviceEventCallbackData = new DeviceEventCallbackData(); 
    76                 deviceEventCallbackData->data = *callback_it; 
    77                 deviceEventCallbackData->deviceId = deviceId; 
    78                 deviceEventCallbackData->deviceState = deviceState; 
    79                 deviceEventCallbackData->deviceStateValue = TelldusCore::wideToString(deviceStateValue); 
    80  
    81                 d->callbackMainDispatcher.retrieveCallbackEvent()->signal(deviceEventCallbackData); 
    82         } 
    83 } 
    84  
    85 void Client::callbackDeviceChangeEvent(int deviceId, int eventDeviceChanges, int eventChangeType){ 
    86          
    87         TelldusCore::MutexLocker locker(&d->mutex); 
    88         for(DeviceChangeList::iterator callback_it = d->deviceChangeEventList.begin(); callback_it != d->deviceChangeEventList.end(); ++callback_it) { 
    89                 DeviceChangeEventCallbackData *deviceChangeEventCallbackData = new DeviceChangeEventCallbackData(); 
    90                 deviceChangeEventCallbackData->data = *callback_it; 
    91                 deviceChangeEventCallbackData->deviceId = deviceId; 
    92                 deviceChangeEventCallbackData->eventDeviceChanges = eventDeviceChanges; 
    93                 deviceChangeEventCallbackData->eventChangeType = eventChangeType; 
    94  
    95                 d->callbackMainDispatcher.retrieveCallbackEvent()->signal(deviceChangeEventCallbackData); 
    96         } 
    97 } 
    98  
    99 void Client::callbackRawEvent(std::wstring command, int controllerId) { 
    100          
    101         TelldusCore::MutexLocker locker(&d->mutex); 
    102         for(RawDeviceEventList::iterator callback_it = d->rawDeviceEventList.begin(); callback_it != d->rawDeviceEventList.end(); ++callback_it) { 
    103                 RawDeviceEventCallbackData *rawDeviceEventCallbackData = new RawDeviceEventCallbackData(); 
    104                 rawDeviceEventCallbackData->data = *callback_it; 
    105                 rawDeviceEventCallbackData->controllerId = controllerId; 
    106                 rawDeviceEventCallbackData->command = TelldusCore::wideToString(command); 
    107                  
    108                 d->callbackMainDispatcher.retrieveCallbackEvent()->signal(rawDeviceEventCallbackData); 
    109         } 
    110 } 
    111  
    112 void Client::callbackSensorEvent(const std::wstring &protocol, const std::wstring &model, int id, int dataType, const std::wstring &value, int timestamp) { 
    113          
    114         TelldusCore::MutexLocker locker(&d->mutex); 
    115         for(SensorEventList::iterator callback_it = d->sensorEventList.begin(); callback_it != d->sensorEventList.end(); ++callback_it) { 
    116                 SensorEventCallbackData *sensorEventCallbackData = new SensorEventCallbackData(); 
    117                 sensorEventCallbackData->data = *callback_it; 
    118                 sensorEventCallbackData->protocol = TelldusCore::wideToString(protocol); 
    119                 sensorEventCallbackData->model = TelldusCore::wideToString(model); 
    120                 sensorEventCallbackData->id = id; 
    121                 sensorEventCallbackData->dataType = dataType; 
    122                 sensorEventCallbackData->value = TelldusCore::wideToString(value); 
    123                 sensorEventCallbackData->timestamp = timestamp; 
    124  
    125                 d->callbackMainDispatcher.retrieveCallbackEvent()->signal(sensorEventCallbackData); 
    126         } 
    127 } 
    128  
    12958bool Client::getBoolFromService(const Message &msg) { 
    13059        return getIntegerFromService(msg) == TELLSTICK_SUCCESS; 
     
    14473} 
    14574 
    146 int Client::registerDeviceEvent( TDDeviceEvent eventFunction, void *context ) { 
    147         TelldusCore::MutexLocker locker(&d->mutex); 
    148         int id = ++d->lastCallbackId; 
    149         DeviceEvent *callback = new DeviceEvent; 
    150         callback->event = eventFunction; 
    151         callback->id = id; 
    152         callback->context = context; 
    153         d->deviceEventList.push_back(callback); 
    154         return id; 
    155 } 
    156  
    157 int Client::registerDeviceChangeEvent( TDDeviceChangeEvent eventFunction, void *context ) { 
    158         TelldusCore::MutexLocker locker(&d->mutex); 
    159         int id = ++d->lastCallbackId; 
    160         DeviceChangeEvent *callback = new DeviceChangeEvent; 
    161         callback->event = eventFunction; 
    162         callback->id = id; 
    163         callback->context = context; 
    164         d->deviceChangeEventList.push_back(callback); 
    165         return id; 
    166 } 
    167  
    168 int Client::registerRawDeviceEvent( TDRawDeviceEvent eventFunction, void *context ) { 
    169         TelldusCore::MutexLocker locker(&d->mutex); 
    170         int id = ++d->lastCallbackId; 
    171         RawDeviceEvent *callback = new RawDeviceEvent; 
    172         callback->event = eventFunction; 
    173         callback->id = id; 
    174         callback->context = context; 
    175         d->rawDeviceEventList.push_back(callback); 
    176         return id; 
    177 } 
    178  
    179 int Client::registerSensorEvent( TDSensorEvent eventFunction, void *context ) { 
    180         TelldusCore::MutexLocker locker(&d->mutex); 
    181         int id = ++d->lastCallbackId; 
    182         SensorEvent *callback = new SensorEvent; 
    183         callback->event = eventFunction; 
    184         callback->id = id; 
    185         callback->context = context; 
    186         d->sensorEventList.push_back(callback); 
    187         return id; 
     75int Client::registerEvent( CallbackStruct::CallbackType type, void *eventFunction, void *context ) { 
     76        return d->callbackMainDispatcher.registerCallback(type, eventFunction, context ); 
    18877} 
    18978 
     
    20493 
    20594                std::wstring clientMessage = d->eventSocket.read(1000); //testing 5 second timeout 
    206                  
     95 
    20796                while(clientMessage != L""){ 
    20897                        //a message arrived 
    20998                        std::wstring type = Message::takeString(&clientMessage); 
    21099                        if(type == L"TDDeviceChangeEvent"){ 
    211                                 int deviceId = Message::takeInt(&clientMessage); 
    212                                 int eventDeviceChanges = Message::takeInt(&clientMessage); 
    213                                 int eventChangeType = Message::takeInt(&clientMessage); 
    214                                 callbackDeviceChangeEvent(deviceId, eventDeviceChanges, eventChangeType); 
    215                         } 
    216                         else if(type == L"TDDeviceEvent"){ 
    217                                 int deviceId = Message::takeInt(&clientMessage); 
    218                                 int eventState = Message::takeInt(&clientMessage); 
    219                                 std::wstring eventValue = Message::takeString(&clientMessage); 
    220                                 callbackDeviceEvent(deviceId, eventState, eventValue); 
    221                         } 
    222                         else if(type == L"TDRawDeviceEvent"){ 
    223                                 std::wstring command = Message::takeString(&clientMessage); 
    224                                 int controllerId = Message::takeInt(&clientMessage); 
    225                                 callbackRawEvent(command, controllerId); 
    226                         } 
    227                         else if(type == L"TDSensorEvent"){ 
    228                                 std::wstring protocol = Message::takeString(&clientMessage); 
    229                                 std::wstring model = Message::takeString(&clientMessage); 
    230                                 int sensorId = Message::takeInt(&clientMessage); 
    231                                 int dataType = Message::takeInt(&clientMessage); 
    232                                 std::wstring value = Message::takeString(&clientMessage); 
    233                                 int timestamp = Message::takeInt(&clientMessage); 
    234                                 callbackSensorEvent(protocol, model, sensorId, dataType, value, timestamp); 
    235                         } 
    236                         else{ 
     100                                DeviceChangeEventCallbackData *data = new DeviceChangeEventCallbackData(); 
     101                                data->deviceId = Message::takeInt(&clientMessage); 
     102                                data->changeEvent = Message::takeInt(&clientMessage); 
     103                                data->changeType = Message::takeInt(&clientMessage); 
     104                                d->callbackMainDispatcher.retrieveCallbackEvent()->signal(data); 
     105 
     106                        } else if(type == L"TDDeviceEvent"){ 
     107                                DeviceEventCallbackData *data = new DeviceEventCallbackData(); 
     108                                data->deviceId = Message::takeInt(&clientMessage); 
     109                                data->deviceState = Message::takeInt(&clientMessage); 
     110                                data->deviceStateValue = TelldusCore::wideToString(Message::takeString(&clientMessage)); 
     111                                d->callbackMainDispatcher.retrieveCallbackEvent()->signal(data); 
     112 
     113                        } else if(type == L"TDRawDeviceEvent"){ 
     114                                RawDeviceEventCallbackData *data = new RawDeviceEventCallbackData(); 
     115                                data->data = TelldusCore::wideToString(Message::takeString(&clientMessage)); 
     116                                data->controllerId = Message::takeInt(&clientMessage); 
     117                                d->callbackMainDispatcher.retrieveCallbackEvent()->signal(data); 
     118 
     119                        } else if(type == L"TDSensorEvent"){ 
     120                                SensorEventCallbackData *data = new SensorEventCallbackData(); 
     121                                data->protocol = TelldusCore::wideToString(Message::takeString(&clientMessage)); 
     122                                data->model = TelldusCore::wideToString(Message::takeString(&clientMessage)); 
     123                                data->id = Message::takeInt(&clientMessage); 
     124                                data->dataType = Message::takeInt(&clientMessage); 
     125                                data->value = TelldusCore::wideToString(Message::takeString(&clientMessage)); 
     126                                data->timestamp = Message::takeInt(&clientMessage); 
     127                                d->callbackMainDispatcher.retrieveCallbackEvent()->signal(data); 
     128 
     129                        } else if(type == L"TDControllerEvent") { 
     130                                ControllerEventCallbackData *data = new ControllerEventCallbackData(); 
     131                                data->controllerId = Message::takeInt(&clientMessage); 
     132                                data->changeEvent = Message::takeInt(&clientMessage); 
     133                                data->changeType = Message::takeInt(&clientMessage); 
     134                                data->newValue = TelldusCore::wideToString(Message::takeString(&clientMessage)); 
     135                                d->callbackMainDispatcher.retrieveCallbackEvent()->signal(data); 
     136 
     137                        } else { 
    237138                                clientMessage = L"";  //cleanup, if message contained garbage/unhandled data 
    238139                        } 
     
    242143 
    243144std::wstring Client::sendToService(const Message &msg) { 
    244          
     145 
    245146        int tries = 0; 
    246147        std::wstring readData; 
     
    269170                        //TODO perhaps break here instead? 
    270171                } 
    271                  
     172 
    272173                if (!s.isConnected()) { //Connection failed sometime during operation... 
    273174                        msleep(500); 
     
    286187 
    287188bool Client::unregisterCallback( int callbackId ) { 
    288         DeviceEventList newDEList; 
    289         { 
    290                 TelldusCore::MutexLocker locker(&d->mutex); 
    291                 for(DeviceEventList::iterator callback_it = d->deviceEventList.begin(); callback_it != d->deviceEventList.end(); ++callback_it) { 
    292                         if ( (*callback_it)->id != callbackId ) { 
    293                                 continue; 
    294                         } 
    295                         newDEList.splice(newDEList.begin(), d->deviceEventList, callback_it); 
    296                         break; 
    297                 } 
    298         } 
    299         if (newDEList.size()) { 
    300                 DeviceEventList::iterator it = newDEList.begin(); 
    301                 { //Lock and unlock to make sure no one else uses the object 
    302                         TelldusCore::MutexLocker locker( &(*it)->mutex ); 
    303                 } 
    304                 delete (*it); 
    305                 newDEList.erase(it); 
    306                 return true; 
    307         } 
    308  
    309         DeviceChangeList newDCList; 
    310         { 
    311                 TelldusCore::MutexLocker locker(&d->mutex); 
    312                 for(DeviceChangeList::iterator callback_it = d->deviceChangeEventList.begin(); callback_it != d->deviceChangeEventList.end(); ++callback_it) { 
    313                         if ( (*callback_it)->id != callbackId ) { 
    314                                 continue; 
    315                         } 
    316                         newDCList.splice(newDCList.begin(), d->deviceChangeEventList, callback_it); 
    317                         break; 
    318                 } 
    319         } 
    320         if (newDCList.size()) { 
    321                 DeviceChangeList::iterator it = newDCList.begin(); 
    322                 {TelldusCore::MutexLocker locker( &(*it)->mutex );} 
    323                 delete (*it); 
    324                 newDCList.erase(it); 
    325                 return true; 
    326         } 
    327  
    328         RawDeviceEventList newRDEList; 
    329         { 
    330                 TelldusCore::MutexLocker locker(&d->mutex); 
    331                 for(RawDeviceEventList::iterator callback_it = d->rawDeviceEventList.begin(); callback_it != d->rawDeviceEventList.end(); ++callback_it) { 
    332                         if ( (*callback_it)->id != callbackId ) { 
    333                                 continue; 
    334                         } 
    335                         newRDEList.splice(newRDEList.begin(), d->rawDeviceEventList, callback_it ); 
    336                         break; 
    337                 } 
    338         } 
    339         if (newRDEList.size()) { 
    340                 RawDeviceEventList::iterator it = newRDEList.begin(); 
    341                 {TelldusCore::MutexLocker locker( &(*it)->mutex );} 
    342                 delete (*it); 
    343                 newRDEList.erase(it); 
    344                 return true; 
    345         } 
    346  
    347         SensorEventList newSEList; 
    348         { 
    349                 TelldusCore::MutexLocker locker(&d->mutex); 
    350                 for(SensorEventList::iterator callback_it = d->sensorEventList.begin(); callback_it != d->sensorEventList.end(); ++callback_it) { 
    351                         if ( (*callback_it)->id != callbackId ) { 
    352                                 continue; 
    353                         } 
    354                         newSEList.splice(newSEList.begin(), d->sensorEventList, callback_it ); 
    355                         break; 
    356                 } 
    357         } 
    358         if (newSEList.size()) { 
    359                 SensorEventList::iterator it = newSEList.begin(); 
    360                 {TelldusCore::MutexLocker locker( &(*it)->mutex );} 
    361                 delete (*it); 
    362                 newSEList.erase(it); 
    363                 return true; 
    364         } 
    365  
    366         return false; 
     189        return d->callbackMainDispatcher.unregisterCallback(callbackId); 
    367190} 
    368191 
     
    404227        return TELLSTICK_SUCCESS; 
    405228} 
     229 
     230int Client::getController(int *controllerId, int *controllerType, char *name, int nameLen, int *available) { 
     231        if (!d->controllerCached) { 
     232                Message msg(L"tdController"); 
     233                std::wstring response = Client::getWStringFromService(msg); 
     234                int count = Message::takeInt(&response); 
     235                d->controllerCached = true; 
     236                d->controllerCache = L""; 
     237                if (count > 0) { 
     238                        d->controllerCache = response; 
     239                } 
     240        } 
     241 
     242        if (d->controllerCache == L"") { 
     243                d->controllerCached = false; 
     244                return TELLSTICK_ERROR_NOT_FOUND; 
     245        } 
     246 
     247        int id = Message::takeInt(&d->controllerCache); 
     248        int type = Message::takeInt(&d->controllerCache); 
     249        std::wstring n = Message::takeString(&d->controllerCache); 
     250        int a = Message::takeInt(&d->controllerCache); 
     251 
     252        if (controllerId) { 
     253                (*controllerId) = id; 
     254        } 
     255        if (controllerType) { 
     256                (*controllerType) = type; 
     257        } 
     258        if (name && nameLen) { 
     259                strncpy(name, TelldusCore::wideToString(n).c_str(), nameLen); 
     260        } 
     261        if (available) { 
     262                (*available) = a; 
     263        } 
     264 
     265        return TELLSTICK_SUCCESS; 
     266} 
  • telldus-core/client/Client.h

    rc049b9 r148fd5  
    55#include "telldus-core.h" 
    66#include "Thread.h" 
     7#include "CallbackDispatcher.h" 
    78 
    89namespace TelldusCore { 
     
    1516                static void close(); 
    1617 
    17                 void callbackDeviceEvent(int deviceId, int deviceState, const std::wstring &deviceStateValue); 
    18                 void callbackDeviceChangeEvent(int deviceId, int eventDeviceChanges, int eventChangeType); 
    19                 void callbackRawEvent(std::wstring command, int controllerId); 
    20                 void callbackSensorEvent(const std::wstring &protocol, const std::wstring &model, int id, int dataType, const std::wstring &value, int timestamp); 
    21                 int registerDeviceEvent( TDDeviceEvent eventFunction, void *context ); 
    22                 int registerDeviceChangeEvent( TDDeviceChangeEvent eventFunction, void *context ); 
    23                 int registerRawDeviceEvent( TDRawDeviceEvent eventFunction, void *context ); 
    24                 int registerSensorEvent( TDSensorEvent eventFunction, void *context ); 
     18                int registerEvent(CallbackStruct::CallbackType type, void *eventFunction, void *context ); 
    2519                void stopThread(void); 
    2620                bool unregisterCallback( int callbackId ); 
    2721 
    2822                int getSensor(char *protocol, int protocolLen, char *model, int modelLen, int *id, int *dataTypes); 
     23                int getController(int *controllerId, int *controllerType, char *name, int nameLen, int *available); 
    2924 
    3025                static bool getBoolFromService(const Message &msg); 
     
    3833                Client(); 
    3934                static std::wstring sendToService(const Message &msg); 
    40                  
     35 
    4136                class PrivateData; 
    4237                PrivateData *d; 
  • telldus-core/client/libtelldus-core.def

    r59325d r246b42  
    5454        tdSensorValue @39 
    5555         
     56        tdController @40 
     57        tdControllerValue @41 
     58        tdSetControllerValue @42 
     59        tdRemoveController @43 
     60        tdRegisterControllerEvent @44 
  • telldus-core/client/telldus-core.cpp

    r795123 r246b42  
    111111 **/ 
    112112int WINAPI tdRegisterDeviceEvent( TDDeviceEvent eventFunction, void *context ) { 
    113         Client *client = Client::getInstance(); 
    114         return client->registerDeviceEvent( eventFunction, context ); 
     113        eventFunction;  Client *client = Client::getInstance(); 
     114        return client->registerEvent( CallbackStruct::DeviceEvent, (void *)eventFunction, context ); 
    115115} 
    116116 
     
    120120int WINAPI tdRegisterRawDeviceEvent( TDRawDeviceEvent eventFunction, void *context ) { 
    121121        Client *client = Client::getInstance(); 
    122         return client->registerRawDeviceEvent( eventFunction, context ); 
     122        return client->registerEvent( CallbackStruct::RawDeviceEvent, (void *)eventFunction, context ); 
    123123} 
    124124 
     
    128128int WINAPI tdRegisterDeviceChangeEvent( TDDeviceChangeEvent eventFunction, void *context) { 
    129129        Client *client = Client::getInstance(); 
    130         return client->registerDeviceChangeEvent( eventFunction, context ); 
     130        return client->registerEvent( CallbackStruct::DeviceChangeEvent, (void *)eventFunction, context ); 
    131131} 
    132132 
     
    136136int WINAPI tdRegisterSensorEvent( TDSensorEvent eventFunction, void *context) { 
    137137        Client *client = Client::getInstance(); 
    138         return client->registerSensorEvent( eventFunction, context ); 
     138        return client->registerEvent( CallbackStruct::SensorEvent, (void *)eventFunction, context ); 
     139} 
     140 
     141/** 
     142 * Added in version 2.1.2. 
     143 **/ 
     144int WINAPI tdRegisterControllerEvent( TDControllerEvent eventFunction, void *context) { 
     145        Client *client = Client::getInstance(); 
     146        return client->registerEvent( CallbackStruct::ControllerEvent, (void *)eventFunction, context ); 
    139147} 
    140148 
     
    698706} 
    699707 
     708/** 
     709 * Use this function to iterate over all controllers. Iterate until 
     710 * TELLSTICK_SUCCESS is not returned 
     711 * 
     712 * Added in version 2.1.2. 
     713 * @param controllerId A byref int where the id of the controller will be placed 
     714 * @param controllerType A byref int where the type of the controller will be placed 
     715 * @param name A byref string where the name of the controller will be placed 
     716 * @param nameLen The length of the \c name parameter 
     717 * @param available A byref int if the controller is currently available or maybe disconnected 
     718 * @returns TELLSTICK_SUCCESS if there is more sensors to be fetched 
     719 * @sa TELLSTICK_CONTROLLER_TELLSTICK 
     720 * @sa TELLSTICK_CONTROLLER_TELLSTICK_DUO 
     721 * @sa TELLSTICK_CONTROLLER_TELLSTICK_NET 
     722 **/ 
     723int WINAPI tdController(int *controllerId, int *controllerType, char *name, int nameLen, int *available) { 
     724        Client *client = Client::getInstance(); 
     725        return client->getController(controllerId, controllerType, name, nameLen, available); 
     726} 
     727 
     728/** 
     729 * This function gets a parameter on a controller. 
     730 * Valid parameters are: \c serial \c and firmware 
     731 * 
     732 * Added in version 2.1.2. 
     733 * @param controllerId The controller to change 
     734 * @param name The parameter to get. 
     735 * @param value A byref string where the value of the parameter will be placed 
     736 **/ 
     737int WINAPI tdControllerValue(int controllerId, const char *name, char *value, int valueLen) { 
     738        Message msg(L"tdControllerValue"); 
     739        msg.addArgument(controllerId); 
     740        msg.addArgument(name); 
     741        std::wstring retval = Client::getWStringFromService(msg); 
     742        if (retval.length() == 0) { 
     743                return TELLSTICK_ERROR_METHOD_NOT_SUPPORTED; 
     744        } 
     745 
     746        if (value && valueLen) { 
     747                strncpy(value, TelldusCore::wideToString(retval).c_str(), valueLen); 
     748        } 
     749        return TELLSTICK_SUCCESS; 
     750} 
     751 
     752/** 
     753 * This function sets a parameter on a controller. 
     754 * Valid parameters are: \c name 
     755 * 
     756 * Added in version 2.1.2. 
     757 * @param controllerId The controller to change 
     758 * @param name The parameter to change. 
     759 * @param value The new value for the parameter. 
     760 **/ 
     761int WINAPI tdSetControllerValue(int controllerId, const char *name, const char *value) { 
     762        Message msg(L"tdSetControllerValue"); 
     763        msg.addArgument(controllerId); 
     764        msg.addArgument(name); 
     765        msg.addArgument(value); 
     766        return Client::getIntegerFromService(msg); 
     767} 
     768 
     769/** 
     770 * This function removes a controller from the list 
     771 * of controllers. The controller must not be 
     772 * available (disconnected) for this to work. 
     773 * 
     774 * Added in version 2.1.2. 
     775 * @param controllerId The controller to remove 
     776 * @returns TELLSTICK_SUCCESS if the controller was 
     777 * removed, TELLSTICK_ERROR_NOT_FOUND if the controller was 
     778 * not found, and TELLSTICK_ERROR_PERMISSION_DENIED if the 
     779 * controller is still connected. 
     780 **/ 
     781int WINAPI tdRemoveController(int controllerId) { 
     782        Message msg(L"tdRemoveController"); 
     783        msg.addArgument(controllerId); 
     784        return Client::getIntegerFromService(msg); 
     785} 
    700786 
    701787/* @} */ 
  • telldus-core/client/telldus-core.h

    r46d70a rd72866  
    3030typedef void (WINAPI *TDRawDeviceEvent)(const char *data, int controllerId, int callbackId, void *context); 
    3131typedef void (WINAPI *TDSensorEvent)(const char *protocol, const char *model, int id, int dataType, const char *value, int timestamp, int callbackId, void *context); 
     32typedef void (WINAPI *TDControllerEvent)(int controllerId, int changeEvent, int changeType, const char *newValue, int callbackId, void *context); 
    3233 
    3334#ifndef __cplusplus 
     
    4344        TELLSTICK_API int WINAPI tdRegisterRawDeviceEvent( TDRawDeviceEvent eventFunction, void *context ); 
    4445        TELLSTICK_API int WINAPI tdRegisterSensorEvent( TDSensorEvent eventFunction, void *context ); 
     46        TELLSTICK_API int WINAPI tdRegisterControllerEvent( TDControllerEvent eventFunction, void *context); 
    4547        TELLSTICK_API int WINAPI tdUnregisterCallback( int callbackId ); 
    4648        TELLSTICK_API void WINAPI tdClose(void); 
     
    8789        TELLSTICK_API int WINAPI tdSensorValue(const char *protocol, const char *model, int id, int dataType, char *value, int len, int *timestamp); 
    8890 
     91        TELLSTICK_API int WINAPI tdController(int *controllerId, int *controllerType, char *name, int nameLen, int *available); 
     92        TELLSTICK_API int WINAPI tdControllerValue(int controllerId, const char *name, char *value, int valueLen); 
     93        TELLSTICK_API int WINAPI tdSetControllerValue(int controllerId, const char *name, const char *value); 
     94        TELLSTICK_API int WINAPI tdRemoveController(int controllerId); 
     95 
    8996#ifdef __cplusplus 
    9097} 
     
    126133#define TELLSTICK_TYPE_SCENE    3 
    127134 
     135//Controller typedef 
     136#define TELLSTICK_CONTROLLER_TELLSTICK      1 
     137#define TELLSTICK_CONTROLLER_TELLSTICK_DUO  2 
     138#define TELLSTICK_CONTROLLER_TELLSTICK_NET  3 
     139 
    128140//Device changes 
    129141#define TELLSTICK_DEVICE_ADDED                  1 
     
    137149#define TELLSTICK_CHANGE_MODEL                  3 
    138150#define TELLSTICK_CHANGE_METHOD                 4 
     151#define TELLSTICK_CHANGE_AVAILABLE              5 
     152#define TELLSTICK_CHANGE_FIRMWARE               6 
    139153 
    140154#endif 
  • telldus-core/common/common.h

    r4d2b80 r5d4ee9  
    55// 
    66// 
     7 
     8#ifndef COMMON_H 
     9#define COMMON_H 
    710 
    811#ifdef _WINDOWS 
     
    7679        return wrapStdString(TelldusCore::wideToString(wstring)); 
    7780} 
     81 
     82#endif //COMMON_H 
  • telldus-core/service/ClientCommunicationHandler.cpp

    re83416 ra766fe  
    1111        bool done; 
    1212        DeviceManager *deviceManager; 
     13        ControllerManager *controllerManager; 
    1314}; 
    1415 
     
    1718} 
    1819 
    19 ClientCommunicationHandler::ClientCommunicationHandler(TelldusCore::Socket *clientSocket, TelldusCore::EventRef event, DeviceManager *deviceManager, TelldusCore::EventRef deviceUpdateEvent) 
     20ClientCommunicationHandler::ClientCommunicationHandler(TelldusCore::Socket *clientSocket, TelldusCore::EventRef event, DeviceManager *deviceManager, TelldusCore::EventRef deviceUpdateEvent, ControllerManager *controllerManager) 
    2021        :Thread() 
    2122{ 
     
    2627        d->deviceManager = deviceManager; 
    2728        d->deviceUpdateEvent = deviceUpdateEvent; 
    28  
     29        d->controllerManager = controllerManager; 
    2930} 
    3031 
     
    231232                (*wstringReturn) = d->deviceManager->getSensorValue(protocol, model, id, dataType); 
    232233 
    233         } 
    234         else{ 
     234        } else if (function == L"tdController") { 
     235                (*wstringReturn) = d->controllerManager->getControllers(); 
     236 
     237        } else if (function == L"tdControllerValue") { 
     238                int id = TelldusCore::Message::takeInt(&msg); 
     239                std::wstring name = TelldusCore::Message::takeString(&msg); 
     240                (*wstringReturn) = d->controllerManager->getControllerValue(id, name); 
     241 
     242        } else if (function == L"tdSetControllerValue") { 
     243                int id = TelldusCore::Message::takeInt(&msg); 
     244                std::wstring name = TelldusCore::Message::takeString(&msg); 
     245                std::wstring value = TelldusCore::Message::takeString(&msg); 
     246                (*intReturn) = d->controllerManager->setControllerValue(id, name, value); 
     247 
     248        } else if (function == L"tdRemoveController") { 
     249                int controllerId = TelldusCore::Message::takeInt(&msg); 
     250                (*intReturn) = d->controllerManager->removeController(controllerId); 
     251 
     252        } else{ 
    235253                (*intReturn) = TELLSTICK_ERROR_UNKNOWN; 
    236254        } 
  • telldus-core/service/ClientCommunicationHandler.h

    re83416 r00eeea  
    1313public: 
    1414        ClientCommunicationHandler(); 
    15         ClientCommunicationHandler(TelldusCore::Socket *clientSocket, TelldusCore::EventRef event, DeviceManager *deviceManager, TelldusCore::EventRef deviceUpdateEvent); 
     15        ClientCommunicationHandler( 
     16                TelldusCore::Socket *clientSocket, 
     17                TelldusCore::EventRef event, 
     18                DeviceManager *deviceManager, 
     19                TelldusCore::EventRef deviceUpdateEvent, 
     20                ControllerManager *controllerManager 
     21        ); 
    1622        ~ClientCommunicationHandler(void); 
    1723 
  • telldus-core/service/Controller.cpp

    re83416 rd72866  
    11#include "Controller.h" 
    22#include "Protocol.h" 
    3 #include <stdio.h> //TODO DEBUG 
     3#include "EventUpdateManager.h" 
     4#include "Strings.h" 
    45 
    56class Controller::PrivateData { 
    67public: 
    7         TelldusCore::Event *event; 
    8         int id; 
     8        TelldusCore::EventRef event, updateEvent; 
     9        int id, firmwareVersion; 
    910}; 
    1011 
    11 Controller::Controller(int id, TelldusCore::Event *event){ 
     12Controller::Controller(int id, TelldusCore::EventRef event, TelldusCore::EventRef updateEvent){ 
    1213        d = new PrivateData; 
    1314        d->event = event; 
     15        d->updateEvent = updateEvent; 
    1416        d->id = id; 
     17        d->firmwareVersion = 0; 
    1518} 
    1619 
     
    3437        } 
    3538} 
     39 
     40int Controller::firmwareVersion() const { 
     41        return d->firmwareVersion; 
     42} 
     43 
     44void Controller::setFirmwareVersion(int version) { 
     45        d->firmwareVersion = version; 
     46        EventUpdateData *eventData = new EventUpdateData(); 
     47        eventData->messageType = L"TDControllerEvent"; 
     48        eventData->controllerId = d->id; 
     49        eventData->eventState = TELLSTICK_DEVICE_CHANGED; 
     50        eventData->eventChangeType = TELLSTICK_CHANGE_FIRMWARE; 
     51        eventData->eventValue = TelldusCore::intToWstring(version); 
     52        d->updateEvent->signal(eventData); 
     53} 
  • telldus-core/service/Controller.h

    re83416 rd72866  
    1515        virtual ~Controller(); 
    1616 
    17         virtual int firmwareVersion() = 0; 
     17        virtual int firmwareVersion() const; 
    1818        virtual int send( const std::string &message ) = 0; 
    1919        virtual int reset() = 0; 
    2020 
    2121protected: 
    22         Controller(int id, TelldusCore::Event *event); 
     22        Controller(int id, TelldusCore::EventRef event, TelldusCore::EventRef updateEvent); 
    2323        void publishData(const std::string &data) const; 
    2424        void decodePublishData(const std::string &data) const; 
     25        void setFirmwareVersion(int version); 
    2526 
    2627private: 
  • telldus-core/service/ControllerManager.cpp

    re83416 rd72866  
    44#include "TellStick.h" 
    55#include "Log.h" 
     6#include "Message.h" 
     7#include "Strings.h" 
     8#include "Settings.h" 
     9#include "EventUpdateManager.h" 
    610#include "../client/telldus-core.h" 
    711 
     
    913#include <stdio.h> 
    1014 
    11 typedef std::map<int, Controller *> ControllerMap; 
     15class ControllerDescriptor { 
     16public: 
     17        std::wstring name, serial; 
     18        int type; 
     19        Controller *controller; 
     20}; 
     21 
     22typedef std::map<int, ControllerDescriptor> ControllerMap; 
    1223 
    1324class ControllerManager::PrivateData { 
    1425public: 
    1526        int lastControllerId; 
     27        Settings settings; 
    1628        ControllerMap controllers; 
    17         TelldusCore::Event *event; 
     29        TelldusCore::EventRef event, updateEvent; 
    1830        TelldusCore::Mutex mutex; 
    1931}; 
    2032 
    21 ControllerManager::ControllerManager(TelldusCore::Event *event){ 
     33ControllerManager::ControllerManager(TelldusCore::EventRef event, TelldusCore::EventRef updateEvent){ 
    2234        d = new PrivateData; 
    2335        d->lastControllerId = 0; 
    2436        d->event = event; 
     37        d->updateEvent = updateEvent; 
     38        this->loadStoredControllers(); 
    2539        this->loadControllers(); 
    2640} 
     
    2842ControllerManager::~ControllerManager() { 
    2943        for (ControllerMap::iterator it = d->controllers.begin(); it != d->controllers.end(); ++it) { 
    30                 delete( it->second ); 
     44                if (it->second.controller) { 
     45                        delete( it->second.controller ); 
     46                } 
    3147        } 
    3248        delete d; 
     
    4258                        while(d->controllers.size()) { 
    4359                                ControllerMap::iterator it = d->controllers.begin(); 
    44                                 delete it->second; 
    45                                 d->controllers.erase(it); 
     60                                delete it->second.controller; 
     61                                it->second.controller = 0; 
     62                                signalControllerEvent(it->first, TELLSTICK_DEVICE_STATE_CHANGED, TELLSTICK_CHANGE_AVAILABLE, L"0"); 
    4663                        } 
    4764                } 
     
    5976                //Autodetect which has been disconnected 
    6077                TelldusCore::MutexLocker locker(&d->mutex); 
    61                 bool again = true; 
    62                 while(again) { 
    63                         again = false; 
    64                         for(ControllerMap::iterator it = d->controllers.begin(); it != d->controllers.end(); ++it) { 
    65                                 TellStick *tellstick = reinterpret_cast<TellStick*>(it->second); 
    66                                 if (!tellstick) { 
     78                for(ControllerMap::iterator it = d->controllers.begin(); it != d->controllers.end(); ++it) { 
     79                        if (!it->second.controller) { 
     80                                continue; 
     81                        } 
     82                        TellStick *tellstick = reinterpret_cast<TellStick*>(it->second.controller); 
     83                        if (!tellstick) { 
     84                                continue; 
     85                        } 
     86                        if (serial.compare("") != 0) { 
     87                                TellStickDescriptor tsd; 
     88                                tsd.vid = vid; 
     89                                tsd.pid = pid; 
     90                                tsd.serial = serial; 
     91                                if (!tellstick->isSameAsDescriptor(tsd)) { 
    6792                                        continue; 
    6893                                } 
    69                                 if (serial.compare("") != 0) { 
    70                                         TellStickDescriptor tsd; 
    71                                         tsd.vid = vid; 
    72                                         tsd.pid = pid; 
    73                                         tsd.serial = serial; 
    74                                         if (!tellstick->isSameAsDescriptor(tsd)) { 
    75                                                 continue; 
    76                                         } 
    77                                 } else if (tellstick->stillConnected()) { 
    78                                         continue; 
    79                                 } 
    80  
    81                                 d->controllers.erase(it); 
    82                                 delete tellstick; 
    83                                 again=true; 
    84                                 break; 
    85                         } 
     94                        } else if (tellstick->stillConnected()) { 
     95                                continue; 
     96                        } 
     97 
     98                        it->second.controller = 0; 
     99                        delete tellstick; 
     100                        signalControllerEvent(it->first, TELLSTICK_DEVICE_STATE_CHANGED, TELLSTICK_CHANGE_AVAILABLE, L"0"); 
    86101                } 
    87102        } 
     
    94109        } 
    95110        ControllerMap::const_iterator it = d->controllers.find(id); 
    96         if (it != d->controllers.end()) { 
    97                 return it->second; 
    98         } 
    99         return d->controllers.begin()->second; 
     111        if (it != d->controllers.end() && it->second.controller) { 
     112                return it->second.controller; 
     113        } 
     114        //Find first available controller 
     115        for(it = d->controllers.begin(); it != d->controllers.end(); ++it) { 
     116                if (it->second.controller) { 
     117                        return it->second.controller; 
     118                } 
     119        } 
     120        return 0; 
    100121 
    101122} 
     
    113134                ControllerMap::const_iterator cit = d->controllers.begin(); 
    114135                for(; cit != d->controllers.end(); ++cit) { 
    115                         TellStick *tellstick = reinterpret_cast<TellStick*>(cit->second); 
     136                        if (!cit->second.controller) { 
     137                                continue; 
     138                        } 
     139                        TellStick *tellstick = reinterpret_cast<TellStick*>(cit->second.controller); 
    116140                        if (!tellstick) { 
    117141                                continue; 
     
    126150                } 
    127151 
    128                 int controllerId = d->lastControllerId-1; 
    129                 TellStick *controller = new TellStick(controllerId, d->event, *it); 
     152                int type = TELLSTICK_CONTROLLER_TELLSTICK; 
     153                if ((*it).pid == 0x0c31) { 
     154                        type = TELLSTICK_CONTROLLER_TELLSTICK_DUO; 
     155                } 
     156                int controllerId = 0; 
     157                //See if the controller matches one of the loaded, non available controllers 
     158                std::wstring serial = TelldusCore::charToWstring((*it).serial.c_str()); 
     159                for(cit = d->controllers.begin(); cit != d->controllers.end(); ++cit) { 
     160                        if (cit->second.type == type && cit->second.serial.compare(serial) == 0) { 
     161                                controllerId = cit->first; 
     162                                break; 
     163                        } 
     164                } 
     165                bool isNew = false; 
     166                if (!controllerId) { 
     167                        controllerId = d->settings.addNode(Settings::Controller); 
     168                        if(controllerId < 0){ 
     169                                //TODO: How to handle this? 
     170                                continue; 
     171                        } 
     172                        isNew = true; 
     173                        d->controllers[controllerId].type = type; 
     174                        d->settings.setControllerType(controllerId, type); 
     175                        d->controllers[controllerId].serial = TelldusCore::charToWstring((*it).serial.c_str()); 
     176                        d->settings.setControllerSerial(controllerId, d->controllers[controllerId].serial); 
     177                } 
     178 
     179                //int controllerId = d->lastControllerId+1; 
     180                TellStick *controller = new TellStick(controllerId, d->event, d->updateEvent, *it); 
    130181                if (!controller->isOpen()) { 
    131182                        delete controller; 
    132183                        continue; 
    133184                } 
    134                 d->lastControllerId = controllerId; 
    135                 d->controllers[d->lastControllerId] = controller; 
     185                d->controllers[controllerId].controller = controller; 
     186                if (isNew) { 
     187                        signalControllerEvent(controllerId, TELLSTICK_DEVICE_ADDED, type, L""); 
     188                } else { 
     189                        signalControllerEvent(controllerId, TELLSTICK_DEVICE_STATE_CHANGED, TELLSTICK_CHANGE_AVAILABLE, L"1"); 
     190                } 
     191        } 
     192} 
     193 
     194void ControllerManager::loadStoredControllers() { 
     195        int numberOfControllers = d->settings.getNumberOfNodes(Settings::Controller); 
     196        TelldusCore::MutexLocker locker(&d->mutex); 
     197 
     198        for (int i = 0; i < numberOfControllers; ++i) { 
     199                int id = d->settings.getNodeId(Settings::Controller, i); 
     200                d->controllers[id].controller = NULL; 
     201                d->controllers[id].name = d->settings.getName(Settings::Controller, id); 
     202                d->controllers[id].type = d->settings.getControllerType(id); 
     203                d->controllers[id].serial = d->settings.getControllerSerial(id); 
     204                signalControllerEvent(id, TELLSTICK_DEVICE_ADDED, 0, L""); 
    136205        } 
    137206} 
     
    144213                TelldusCore::MutexLocker locker(&d->mutex); 
    145214                for(ControllerMap::iterator it = d->controllers.begin(); it != d->controllers.end(); ++it) { 
    146                         TellStick *tellstick = reinterpret_cast<TellStick*>(it->second); 
     215                        if (!it->second.controller) { 
     216                                continue; 
     217                        } 
     218                        TellStick *tellstick = reinterpret_cast<TellStick*>(it->second.controller); 
    147219                        if (tellstick) { 
    148220                                tellStickControllers.push_back(tellstick); 
     
    180252        return success; 
    181253} 
     254 
     255std::wstring ControllerManager::getControllers() const { 
     256        TelldusCore::MutexLocker locker(&d->mutex); 
     257 
     258        TelldusCore::Message msg; 
     259 
     260        msg.addArgument((int)d->controllers.size()); 
     261 
     262        for(ControllerMap::iterator it = d->controllers.begin(); it != d->controllers.end(); ++it) { 
     263                msg.addArgument(it->first); 
     264                msg.addArgument(it->second.type); 
     265                msg.addArgument(it->second.name.c_str()); 
     266                msg.addArgument(it->second.controller ? 1 : 0); 
     267        } 
     268        return msg; 
     269} 
     270 
     271std::wstring ControllerManager::getControllerValue(int id, const std::wstring &name) { 
     272        TelldusCore::MutexLocker locker(&d->mutex); 
     273 
     274        ControllerMap::iterator it = d->controllers.find(id); 
     275        if (it == d->controllers.end()) { 
     276                return L""; 
     277        } 
     278        if (name == L"serial") { 
     279                return it->second.serial; 
     280        } else if (name == L"firmware") { 
     281                if (!it->second.controller) { 
     282                        return L"-1"; 
     283                } 
     284                return TelldusCore::intToWstring(it->second.controller->firmwareVersion()); 
     285        } 
     286        return L""; 
     287} 
     288 
     289int ControllerManager::removeController(int id) { 
     290        TelldusCore::MutexLocker locker(&d->mutex); 
     291 
     292        ControllerMap::iterator it = d->controllers.find(id); 
     293        if (it == d->controllers.end()) { 
     294                return TELLSTICK_ERROR_NOT_FOUND; 
     295        } 
     296        if (it->second.controller) { 
     297                //Still connected 
     298                return TELLSTICK_ERROR_PERMISSION_DENIED; 
     299        } 
     300 
     301        int ret = d->settings.removeNode(Settings::Controller, id); 
     302        if (ret != TELLSTICK_SUCCESS) { 
     303                return ret; 
     304        } 
     305 
     306        d->controllers.erase(it); 
     307 
     308        signalControllerEvent(id, TELLSTICK_DEVICE_REMOVED, 0, L""); 
     309        return TELLSTICK_SUCCESS; 
     310} 
     311 
     312int ControllerManager::setControllerValue(int id, const std::wstring &name, const std::wstring &value) { 
     313        TelldusCore::MutexLocker locker(&d->mutex); 
     314 
     315        ControllerMap::iterator it = d->controllers.find(id); 
     316        if (it == d->controllers.end()) { 
     317                return TELLSTICK_ERROR_NOT_FOUND; 
     318        } 
     319        if (name == L"name") { 
     320                it->second.name = value; 
     321                d->settings.setName(Settings::Controller, id, value); 
     322                signalControllerEvent(id, TELLSTICK_DEVICE_CHANGED, TELLSTICK_CHANGE_NAME, value); 
     323        } else { 
     324                return TELLSTICK_ERROR_SYNTAX; //TODO: Is this the best error? 
     325        } 
     326        return TELLSTICK_SUCCESS; 
     327} 
     328 
     329void ControllerManager::signalControllerEvent(int controllerId, int changeEvent, int changeType, const std::wstring &newValue) { 
     330        EventUpdateData *eventData = new EventUpdateData(); 
     331        eventData->messageType = L"TDControllerEvent"; 
     332        eventData->controllerId = controllerId; 
     333        eventData->eventState = changeEvent; 
     334        eventData->eventChangeType = changeType; 
     335        eventData->eventValue = newValue; 
     336        d->updateEvent->signal(eventData); 
     337} 
  • telldus-core/service/ControllerManager.h

    re83416 r237cf4  
    22#define CONTROLLERMANAGER_H 
    33 
     4#include "Event.h" 
    45class Controller; 
    5 namespace TelldusCore { 
    6         class Event; 
    7 } 
    86 
    97#include <string> 
     
    119class ControllerManager { 
    1210public: 
    13         ControllerManager(TelldusCore::Event *event); 
     11        ControllerManager(TelldusCore::EventRef event, TelldusCore::EventRef updateEvent); 
    1412        ~ControllerManager(void); 
    1513 
     
    1816        Controller *getBestControllerById(int id); 
    1917        void loadControllers(); 
     18        void loadStoredControllers(); 
    2019        void queryControllerStatus(); 
    2120        int resetController(Controller *controller); 
    2221 
     22        std::wstring getControllers() const; 
     23        std::wstring getControllerValue(int id, const std::wstring &name); 
     24        int removeController(int id); 
     25        int setControllerValue(int id, const std::wstring &name, const std::wstring &value); 
     26 
    2327private: 
     28        void signalControllerEvent(int controllerId, int changeEvent, int changeType, const std::wstring &newValue); 
    2429        class PrivateData; 
    2530        PrivateData *d; 
  • telldus-core/service/DeviceManager.cpp

    re83416 r39265c  
    4848 
    4949void DeviceManager::fillDevices(){ 
    50         int numberOfDevices = d->set.getNumberOfDevices(); 
     50        int numberOfDevices = d->set.getNumberOfNodes(Settings::Device); 
    5151        TelldusCore::MutexLocker deviceListLocker(&d->lock); 
    5252 
    5353        for (int i = 0; i < numberOfDevices; ++i) { 
    54                 int id = d->set.getDeviceId(i); 
     54                int id = d->set.getNodeId(Settings::Device, i); 
    5555                d->devices[id] = new Device(id); 
    56                 d->devices[id]->setName(d->set.getName(id)); 
     56                d->devices[id]->setName(d->set.getName(Settings::Device, id)); 
    5757                d->devices[id]->setModel(d->set.getModel(id)); 
    5858                d->devices[id]->setProtocolName(d->set.getProtocol(id)); 
     
    236236        if (it != d->devices.end()) { 
    237237                TelldusCore::MutexLocker deviceLocker(it->second); 
    238                 int ret = d->set.setName(deviceId, name); 
     238                int ret = d->set.setName(Settings::Device, deviceId, name); 
    239239                if (ret != TELLSTICK_SUCCESS) { 
    240240                        return ret; 
     
    331331int DeviceManager::addDevice(){ 
    332332 
    333         int id = d->set.addDevice(); 
     333        int id = d->set.addNode(Settings::Device); 
    334334        if(id < 0){ 
    335335                return id; 
     
    345345 
    346346int DeviceManager::getDeviceId(int deviceIndex) { 
    347         return d->set.getDeviceId(deviceIndex); 
     347        return d->set.getNodeId(Settings::Device, deviceIndex); 
    348348} 
    349349 
     
    574574        Device *device = 0; 
    575575        { 
    576                 int ret = d->set.removeDevice(deviceId);                //remove from register/settings 
     576                int ret = d->set.removeNode(Settings::Device, deviceId);                //remove from register/settings 
    577577                if (ret != TELLSTICK_SUCCESS) { 
    578578                        return ret; 
  • telldus-core/service/EventUpdateManager.cpp

    re83416 r237cf4  
    106106                                msg.addArgument(data->timestamp); 
    107107                        } 
     108                        else if(data->messageType == L"TDControllerEvent") { 
     109                                msg.addArgument("TDControllerEvent"); 
     110                                msg.addArgument(data->controllerId); 
     111                                msg.addArgument(data->eventState); 
     112                                msg.addArgument(data->eventChangeType); 
     113                                msg.addArgument(data->eventValue); 
     114                        } 
    108115 
    109116                        (*it)->write(msg); 
  • telldus-core/service/Settings.cpp

    r8d1520 r5bc43a  
    11#include "Settings.h" 
     2 
     3TelldusCore::Mutex Settings::mutex; 
    24 
    35/* 
    46* Get the name of the device 
    57*/ 
    6 std::wstring Settings::getName(int intDeviceId) const { 
     8std::wstring Settings::getName(Node type, int intNodeId) const { 
    79        TelldusCore::MutexLocker locker(&mutex); 
    8         return getStringSetting(intDeviceId, L"name", false); 
     10        return getStringSetting(type, intNodeId, L"name", false); 
    911} 
    1012 
     
    1214* Set the name of the device 
    1315*/ 
    14 int Settings::setName(int intDeviceId, const std::wstring &strNewName){ 
     16int Settings::setName(Node type, int intDeviceId, const std::wstring &strNewName){ 
    1517        TelldusCore::MutexLocker locker(&mutex); 
    16         return setStringSetting(intDeviceId, L"name", strNewName, false); 
     18        return setStringSetting(type, intDeviceId, L"name", strNewName, false); 
    1719} 
    1820 
     
    2224std::wstring Settings::getProtocol(int intDeviceId) const { 
    2325        TelldusCore::MutexLocker locker(&mutex); 
    24         return getStringSetting(intDeviceId, L"protocol", false); 
     26        return getStringSetting(Device, intDeviceId, L"protocol", false); 
    2527} 
    2628 
     
    3032int Settings::setProtocol(int intDeviceId, const std::wstring &strVendor){ 
    3133        TelldusCore::MutexLocker locker(&mutex); 
    32         return setStringSetting(intDeviceId, L"protocol", strVendor, false); 
     34        return setStringSetting(Device, intDeviceId, L"protocol", strVendor, false); 
    3335} 
    3436 
     
    3840std::wstring Settings::getModel(int intDeviceId) const { 
    3941        TelldusCore::MutexLocker locker(&mutex); 
    40         return getStringSetting(intDeviceId, L"model", false); 
     42        return getStringSetting(Device, intDeviceId, L"model", false); 
    4143} 
    4244 
     
    4648int Settings::setModel(int intDeviceId, const std::wstring &strModel){ 
    4749        TelldusCore::MutexLocker locker(&mutex); 
    48         return setStringSetting(intDeviceId, L"model", strModel, false); 
     50        return setStringSetting(Device, intDeviceId, L"model", strModel, false); 
    4951} 
    5052 
     
    5456int Settings::setDeviceParameter(int intDeviceId, const std::wstring &strName, const std::wstring &strValue){ 
    5557        TelldusCore::MutexLocker locker(&mutex); 
    56         return setStringSetting(intDeviceId, strName, strValue, true); 
     58        return setStringSetting(Device, intDeviceId, strName, strValue, true); 
    5759} 
    5860 
     
    6264std::wstring Settings::getDeviceParameter(int intDeviceId, const std::wstring &strName) const { 
    6365        TelldusCore::MutexLocker locker(&mutex); 
    64         return getStringSetting(intDeviceId, strName, true); 
     66        return getStringSetting(Device, intDeviceId, strName, true); 
    6567} 
    6668 
     
    7072int Settings::setPreferredControllerId(int intDeviceId, int value){ 
    7173        TelldusCore::MutexLocker locker(&mutex); 
    72         return setIntSetting(intDeviceId,  L"controller", value, false); 
     74        return setIntSetting(Device, intDeviceId,  L"controller", value, false); 
    7375} 
    7476 
     
    7880int Settings::getPreferredControllerId(int intDeviceId) { 
    7981        TelldusCore::MutexLocker locker(&mutex); 
    80         return getIntSetting(intDeviceId, L"controller", false); 
     82        return getIntSetting(Device, intDeviceId, L"controller", false); 
     83} 
     84 
     85std::wstring Settings::getControllerSerial(int intControllerId) const { 
     86        TelldusCore::MutexLocker locker(&mutex); 
     87        return getStringSetting(Controller, intControllerId, L"serial", false); 
     88} 
     89 
     90int Settings::setControllerSerial(int intControllerId, const std::wstring &serial) { 
     91        TelldusCore::MutexLocker locker(&mutex); 
     92        return setStringSetting(Controller, intControllerId,  L"serial", serial, false); 
     93} 
     94 
     95int Settings::getControllerType(int intControllerId) const { 
     96        TelldusCore::MutexLocker locker(&mutex); 
     97        return getIntSetting(Controller, intControllerId, L"type", false); 
     98} 
     99 
     100int Settings::setControllerType(int intControllerId, int type) { 
     101        TelldusCore::MutexLocker locker(&mutex); 
     102        return setIntSetting(Controller, intControllerId,  L"type", type, false); 
     103} 
     104 
     105std::string Settings::getNodeString(Settings::Node type) const { 
     106        if (type == Device) { 
     107                return "device"; 
     108        } else if (type == Controller) { 
     109                return "controller"; 
     110        } 
    81111} 
    82112 
     
    85115bool Settings::setDeviceState( int intDeviceId, int intDeviceState, const std::wstring &strDeviceStateValue ) { 
    86116        TelldusCore::MutexLocker locker(&mutex); 
    87         bool retval = setIntSetting( intDeviceId, L"state", intDeviceState, true ); 
    88         setStringSetting( intDeviceId, L"stateValue", strDeviceStateValue, true ); 
     117        bool retval = setIntSetting( Settings::Device, intDeviceId, L"state", intDeviceState, true ); 
     118        setStringSetting( Settings::Device, intDeviceId, L"stateValue", strDeviceStateValue, true ); 
    89119        return retval; 
    90120} 
     
    92122int Settings::getDeviceState( int intDeviceId ) const { 
    93123        TelldusCore::MutexLocker locker(&mutex); 
    94         return getIntSetting( intDeviceId, L"state", true ); 
     124        return getIntSetting( Settings::Device, intDeviceId, L"state", true ); 
    95125} 
    96126 
    97127std::wstring Settings::getDeviceStateValue( int intDeviceId ) const { 
    98128        TelldusCore::MutexLocker locker(&mutex); 
    99         return getStringSetting( intDeviceId, L"stateValue", true ); 
     129        return getStringSetting( Settings::Device, intDeviceId, L"stateValue", true ); 
    100130} 
    101131 
  • telldus-core/service/Settings.h

    r8d1520 rbfb24c  
    77class Settings { 
    88public: 
     9        enum Node { Device, Controller }; 
     10 
    911        Settings(void); 
    1012        virtual ~Settings(void); 
    1113 
    1214        std::wstring getSetting(const std::wstring &strName) const; 
    13         int getNumberOfDevices(void) const; 
    14         std::wstring getName(int intDeviceId) const; 
    15         int setName(int intDeviceId, const std::wstring &strNewName); 
     15        int getNumberOfNodes(Node type) const; 
     16        std::wstring getName(Node type, int intNodeId) const; 
     17        int setName(Node type, int intDeviceId, const std::wstring &strNewName); 
    1618        std::wstring getProtocol(int intDeviceId) const; 
    1719        int setProtocol(int intDeviceId, const std::wstring &strVendor); 
     
    2628        int setPreferredControllerId(int intDeviceId, int value); 
    2729 
    28         int addDevice(); 
    29         int getDeviceId(int intDeviceIndex) const; 
    30         int removeDevice(int intDeviceId); 
     30        int addNode(Node type); 
     31        int getNodeId(Node type, int intDeviceIndex) const; 
     32        int removeNode(Node type, int intNodeId); 
     33 
     34        std::wstring getControllerSerial(int intControllerId) const; 
     35        int setControllerSerial(int intControllerId, const std::wstring &serial); 
     36        int getControllerType(int intControllerId) const; 
     37        int setControllerType(int intControllerId, int type); 
    3138 
    3239protected: 
    33         std::wstring getStringSetting(int intDeviceId, const std::wstring &name, bool parameter) const; 
    34         int setStringSetting(int intDeviceId, const std::wstring &name, const std::wstring &value, bool parameter); 
    35         int getIntSetting(int intDeviceId, const std::wstring &name, bool parameter) const; 
    36         int setIntSetting(int intDeviceId, const std::wstring &name, int value, bool parameter); 
     40        std::wstring getStringSetting(Node type, int intNodeId, const std::wstring &name, bool parameter) const; 
     41        int setStringSetting(Node type, int intDeviceId, const std::wstring &name, const std::wstring &value, bool parameter); 
     42        int getIntSetting(Node type, int intDeviceId, const std::wstring &name, bool parameter) const; 
     43        int setIntSetting(Node type, int intDeviceId, const std::wstring &name, int value, bool parameter); 
    3744 
    3845private: 
    39         int getNextDeviceId() const; 
     46        int getNextNodeId(Node type) const; 
     47        std::string getNodeString(Node type) const; 
    4048 
    4149        class PrivateData; 
    4250        PrivateData *d; 
    43         mutable TelldusCore::Mutex mutex; 
     51        static TelldusCore::Mutex mutex; 
    4452}; 
    4553 
  • telldus-core/service/SettingsConfuse.cpp

    rd7cce5 r39265c  
    7777* Return the number of stored devices 
    7878*/ 
    79 int Settings::getNumberOfDevices(void) const { 
     79int Settings::getNumberOfNodes(Node node) const { 
    8080        TelldusCore::MutexLocker locker(&mutex); 
    8181        if (d->cfg > 0) { 
    82                 return cfg_size(d->cfg, "device"); 
     82                if (node == Device) { 
     83                        return cfg_size(d->cfg, "device"); 
     84                } else if (node == Controller) { 
     85                        return cfg_size(d->cfg, "controller"); 
     86                } 
    8387        } 
    8488        return 0; 
    8589} 
    8690 
    87 int Settings::getDeviceId(int intDeviceIndex) const { 
    88         if (intDeviceIndex >= getNumberOfDevices()) { //Out of bounds 
     91int Settings::getNodeId(Node type, int intDeviceIndex) const { 
     92        if (intDeviceIndex >= getNumberOfNodes(type)) { //Out of bounds 
    8993                return -1; 
    9094        } 
    9195        TelldusCore::MutexLocker locker(&mutex); 
    92         cfg_t *cfg_device = cfg_getnsec(d->cfg, "device", intDeviceIndex); 
    93         int id = cfg_getint(cfg_device, "id"); 
     96        cfg_t *cfg_node; 
     97        if (type == Device) { 
     98                cfg_node = cfg_getnsec(d->cfg, "device", intDeviceIndex); 
     99        } else if (type == Controller) { 
     100                cfg_node = cfg_getnsec(d->cfg, "controller", intDeviceIndex); 
     101        } 
     102        int id = cfg_getint(cfg_node, "id"); 
    94103        return id; 
    95104} 
    96105 
    97106/* 
    98 * Add a new device 
    99 */ 
    100 int Settings::addDevice(){ 
    101         TelldusCore::MutexLocker locker(&mutex); 
    102         int intDeviceId = getNextDeviceId(); 
     107* Add a new node 
     108*/ 
     109int Settings::addNode(Node type){ 
     110        TelldusCore::MutexLocker locker(&mutex); 
     111        int intNodeId = getNextNodeId(type); 
    103112 
    104113        FILE *fp = fopen(CONFIG_FILE, "w"); 
     
    107116        } 
    108117        cfg_print(d->cfg, fp); //Print the config-file 
    109         fprintf(fp, "device {\n  id=%d\n}\n", intDeviceId); //Print the new device 
     118        if (type == Device) { 
     119                fprintf(fp, "device {\n  id=%d\n}\n", intNodeId); //Print the new device 
     120        } else if (type == Controller) { 
     121                fprintf(fp, "controller {\n  id=%d\n}\n", intNodeId); //Print the new controller 
     122        } 
    110123        fclose(fp); 
    111124 
     
    113126        cfg_free(d->cfg); 
    114127        readConfig(&d->cfg); 
    115         return intDeviceId; 
    116 } 
    117  
    118 /* 
    119 * Get next available device id 
    120 */ 
    121 int Settings::getNextDeviceId() const { 
     128        return intNodeId; 
     129} 
     130 
     131/* 
     132* Get next available node id 
     133*/ 
     134int Settings::getNextNodeId(Node type) const { 
    122135        //Private, no locks needed 
    123         int intDeviceId = 0; 
    124         cfg_t *cfg_device; 
    125         for (int i = 0; i < cfg_size(d->cfg, "device"); ++i) { 
    126                 cfg_device = cfg_getnsec(d->cfg, "device", i); 
    127                 if (cfg_getint(cfg_device, "id") >= intDeviceId)  { 
    128                         intDeviceId = cfg_getint(cfg_device, "id"); 
    129                 } 
    130         } 
    131         intDeviceId++; 
    132         return intDeviceId; 
     136        int intNodeId = 0; 
     137        cfg_t *cfg_node; 
     138        std::string strType; 
     139        if (type == Device) { 
     140                strType = "device"; 
     141        } else if (type == Controller) { 
     142                strType = "controller"; 
     143        } 
     144        for (int i = 0; i < cfg_size(d->cfg, strType.c_str()); ++i) { 
     145                cfg_node = cfg_getnsec(d->cfg, strType.c_str(), i); 
     146                if (cfg_getint(cfg_node, "id") >= intNodeId)  { 
     147                        intNodeId = cfg_getint(cfg_node, "id"); 
     148                } 
     149        } 
     150        intNodeId++; 
     151        return intNodeId; 
    133152} 
    134153 
     
    136155* Remove a device 
    137156*/ 
    138 int Settings::removeDevice(int intDeviceId){ 
     157int Settings::removeNode(Node type, int intNodeId){ 
    139158        TelldusCore::MutexLocker locker(&mutex); 
    140159        FILE *fp = fopen(CONFIG_FILE, "w"); 
     
    143162        } 
    144163 
     164        std::string strType = getNodeString(type); 
     165 
    145166        // Print all opts 
    146167        for(int i = 0; d->cfg->opts[i].name; i++) { 
    147168 
    148169                // Check if it isn't a device section 
    149                 if (strcmp(d->cfg->opts[i].name, "device") != 0) { 
     170                if (strcmp(d->cfg->opts[i].name, strType.c_str()) != 0) { 
    150171                        cfg_opt_print(&d->cfg->opts[i], fp); 
    151172                } else { 
    152173                        // Print all sections except the one to remove 
    153                         cfg_t *cfg_device; 
    154                         for (int i = 0; i < cfg_size(d->cfg, "device"); ++i) { 
    155                                 cfg_device = cfg_getnsec(d->cfg, "device", i); 
    156                                 if (cfg_getint(cfg_device, "id") != intDeviceId) { //This isn't the one to skip 
    157                                         fprintf(fp, "device {\n"); 
    158                                         cfg_print_indent(cfg_device, fp, 1); 
     174                        cfg_t *cfg_node; 
     175                        for (int i = 0; i < cfg_size(d->cfg, strType.c_str()); ++i) { 
     176                                cfg_node = cfg_getnsec(d->cfg, strType.c_str(), i); 
     177                                if (cfg_getint(cfg_node, "id") != intNodeId) { //This isn't the one to skip 
     178                                        fprintf(fp, "%s {\n", strType.c_str()); 
     179                                        cfg_print_indent(cfg_node, fp, 1); 
    159180                                        fprintf(fp, "}\n"); 
    160181                                } 
     
    245266} 
    246267 
    247 std::wstring Settings::getStringSetting(int intDeviceId, const std::wstring &name, bool parameter) const { 
     268std::wstring Settings::getStringSetting(Node type, int intNodeId, const std::wstring &name, bool parameter) const { 
    248269        //already locked 
    249270        if (d->cfg == 0) { 
    250271                return L""; 
    251272        } 
    252         cfg_t *cfg_device; 
    253         for (int i = 0; i < cfg_size(d->cfg, "device"); ++i) { 
    254                 cfg_device = cfg_getnsec(d->cfg, "device", i); 
    255                 if (cfg_getint(cfg_device, "id") == intDeviceId)  { 
     273        std::string strType = getNodeString(type); 
     274 
     275        cfg_t *cfg_device; 
     276        for (int i = 0; i < cfg_size(d->cfg, strType.c_str()); ++i) { 
     277                cfg_device = cfg_getnsec(d->cfg, strType.c_str(), i); 
     278                if (cfg_getint(cfg_device, "id") == intNodeId)  { 
    256279                        if (parameter) { 
    257280                                cfg_device = cfg_getsec(cfg_device, "parameters"); 
     
    268291} 
    269292 
    270 int Settings::setStringSetting(int intDeviceId, const std::wstring &name, const std::wstring &value, bool parameter) { 
     293int Settings::setStringSetting(Node type, int intDeviceId, const std::wstring &name, const std::wstring &value, bool parameter) { 
    271294        //already locked 
    272295        if (d->cfg == 0) { 
    273296                return TELLSTICK_ERROR_PERMISSION_DENIED; 
    274297        } 
    275         cfg_t *cfg_device; 
    276         for (int i = 0; i < cfg_size(d->cfg, "device"); ++i) { 
    277                 cfg_device = cfg_getnsec(d->cfg, "device", i); 
     298        std::string strType = getNodeString(type); 
     299        cfg_t *cfg_device; 
     300        for (int i = 0; i < cfg_size(d->cfg, strType.c_str()); ++i) { 
     301                cfg_device = cfg_getnsec(d->cfg, strType.c_str(), i); 
    278302                if (cfg_getint(cfg_device, "id") == intDeviceId)  { 
    279303                        std::string newValue = TelldusCore::wideToString(value); 
     
    296320} 
    297321 
    298 int Settings::getIntSetting(int intDeviceId, const std::wstring &name, bool parameter) const { 
     322int Settings::getIntSetting(Node type, int intDeviceId, const std::wstring &name, bool parameter) const { 
    299323        //already locked 
    300324        if (d->cfg == 0) { 
    301325                return 0; 
    302326        } 
    303         cfg_t *cfg_device; 
    304         for(int i = 0; i < cfg_size(d->cfg, "device"); ++i) { 
    305                 cfg_device = cfg_getnsec(d->cfg, "device", i); 
    306                 if (cfg_getint(cfg_device, "id") == intDeviceId) { 
     327        std::string strType = getNodeString(type); 
     328        cfg_t *cfg_node; 
     329        for(int i = 0; i < cfg_size(d->cfg, strType.c_str()); ++i) { 
     330                cfg_node = cfg_getnsec(d->cfg, strType.c_str(), i); 
     331                if (cfg_getint(cfg_node, "id") == intDeviceId) { 
    307332                        if (parameter) { 
    308                                 cfg_device = cfg_getsec(cfg_device, "parameters"); 
    309                         } 
    310                         return cfg_getint(cfg_device, TelldusCore::wideToString(name).c_str()); 
     333                                cfg_node = cfg_getsec(cfg_node, "parameters"); 
     334                        } 
     335                        return cfg_getint(cfg_node, TelldusCore::wideToString(name).c_str()); 
    311336                } 
    312337        } 
     
    314339} 
    315340 
    316 int Settings::setIntSetting(int intDeviceId, const std::wstring &name, int value, bool parameter) { 
     341int Settings::setIntSetting(Node type, int intDeviceId, const std::wstring &name, int value, bool parameter) { 
    317342        //already locked 
    318343        if (d->cfg == 0) { 
    319344                return TELLSTICK_ERROR_PERMISSION_DENIED; 
    320345        } 
    321         cfg_t *cfg_device; 
    322         for (int i = 0; i < cfg_size(d->cfg, "device"); ++i) { 
    323                 cfg_device = cfg_getnsec(d->cfg, "device", i); 
     346        std::string strType = getNodeString(type); 
     347        cfg_t *cfg_device; 
     348        for (int i = 0; i < cfg_size(d->cfg, strType.c_str()); ++i) { 
     349                cfg_device = cfg_getnsec(d->cfg, strType.c_str(), i); 
    324350                if (cfg_getint(cfg_device, "id") == intDeviceId)  { 
    325351                        if (parameter) { 
     
    346372        cfg_opt_t controller_opts[] = { 
    347373                CFG_INT(const_cast<char *>("id"), -1, CFGF_NONE), 
     374                CFG_STR(const_cast<char *>("name"), const_cast<char *>(""), CFGF_NONE), 
     375                CFG_INT(const_cast<char *>("type"), 0, CFGF_NONE), 
     376                CFG_STR(const_cast<char *>("serial"), const_cast<char *>(""), CFGF_NONE), 
     377 
     378                CFG_END() 
    348379        }; 
    349380 
     
    378409                CFG_STR(const_cast<char *>("ignoreControllerConfirmation"), const_cast<char *>("false"), CFGF_NONE), 
    379410                CFG_SEC(const_cast<char *>("device"), device_opts, CFGF_MULTI), 
     411                CFG_SEC(const_cast<char *>("controller"), controller_opts, CFGF_MULTI), 
    380412                CFG_END() 
    381413        }; 
  • telldus-core/service/SettingsCoreFoundationPreferences.cpp

    rd53543 r5fcc39  
    22// C++ Implementation: telldussettingsconfuse 
    33// 
    4 // Description:  
     4// Description: 
    55// 
    66// 
     
    3131        CFStringRef hostName; 
    3232}; 
    33          
     33 
    3434/* 
    3535* Constructor 
     
    6161* Return the number of stored devices 
    6262*/ 
    63 int Settings::getNumberOfDevices(void) const { 
     63int Settings::getNumberOfNodes(Node type) const { 
    6464        CFArrayRef cfarray = CFPreferencesCopyKeyList( d->app_ID, d->userName, d->hostName ); 
    6565        if (!cfarray) return 0; 
    6666        CFIndex size = CFArrayGetCount( cfarray ); 
    67         int devices = 0; 
     67        int nodes = 0; 
    6868        for (CFIndex k = 0; k < size; ++k) { 
    6969                CFStringRef key = (CFStringRef) CFArrayGetValueAtIndex(cfarray, k); 
    70                 if (CFStringHasPrefix( key, CFSTR("devices.") ) && 
    71                         CFStringHasSuffix( key, CFSTR(".name") ) ) { 
    72                         devices++; 
    73                 } 
    74         }        
    75         return devices; 
    76 } 
    77  
    78 int Settings::getDeviceId(int intDeviceIndex) const { 
     70                if (!CFStringHasSuffix( key, CFSTR(".name") )) { 
     71                        continue; 
     72                } 
     73                if (type == Device && CFStringHasPrefix( key, CFSTR("devices.") )) { 
     74                        ++nodes; 
     75                } else if (type == Controller && CFStringHasPrefix( key, CFSTR("controllers.") )) { 
     76                        ++nodes; 
     77                } 
     78        } 
     79        return nodes; 
     80} 
     81 
     82int Settings::getNodeId(Node type, int intNodeIndex) const { 
    7983        CFArrayRef cfarray = CFPreferencesCopyKeyList( d->app_ID, d->userName, d->hostName ); 
    8084        if (!cfarray) return 0; 
     
    8488        for (CFIndex k = 0; k < size; ++k) { 
    8589                CFStringRef key = (CFStringRef) CFArrayGetValueAtIndex(cfarray, k); 
    86                 if (CFStringHasPrefix( key, CFSTR("devices.") ) && 
    87                         CFStringHasSuffix( key, CFSTR(".name") ) ) { 
    88                          
    89                         if (index == intDeviceIndex) {                    
    90                                 CFArrayRef split = CFStringCreateArrayBySeparatingStrings( 0, key, CFSTR(".") ); 
    91                                 if ( !split || CFArrayGetCount( split ) != 3 ) continue; 
    92  
    93                                 // This code crashes! 
    94                                 //CFNumberRef cfid = (CFNumberRef) CFArrayGetValueAtIndex( split, 1 ); 
    95                                 //if (cfid) 
    96                                 //      CFNumberGetValue( cfid, kCFNumberIntType, &id); 
    97  
    98                                 CFStringRef cfid = (CFStringRef) CFArrayGetValueAtIndex( split, 1 );                             
    99                                 char *cp = NULL; 
    100                                 CFIndex size = CFStringGetMaximumSizeForEncoding( CFStringGetLength( cfid ), kCFStringEncodingUTF8) + 1; 
    101                                 cp = (char *)malloc(size); 
    102                                 CFStringGetCString( cfid, cp, size, kCFStringEncodingUTF8 ); 
    103                                 char *newcp = (char *)realloc( cp, strlen(cp) + 1); 
    104                                 if (newcp != NULL) { 
    105                                         cp = newcp; 
    106                                         id = atoi(cp); 
    107                                 } else { 
    108                                         //Should not happen 
    109                                         id = 0; 
    110                                 } 
    111                                 free(cp); 
    112  
    113                                 CFRelease(key); 
    114                                 CFRelease(split); 
    115                                 CFRelease(cfid);         
    116                                 break; 
     90                if (!CFStringHasSuffix( key, CFSTR(".name") )) { 
     91                        CFRelease( key ); 
     92                        continue; 
     93                } 
     94                if ( type == Device && !CFStringHasPrefix(key, CFSTR("devices.")) ) { 
     95                        CFRelease( key ); 
     96                        continue; 
     97                } 
     98                if ( type == Controller && !CFStringHasPrefix(key, CFSTR("controllers.")) ) { 
     99                        CFRelease( key ); 
     100                        continue; 
     101                } 
     102                if (index == intNodeIndex) { 
     103                        CFArrayRef split = CFStringCreateArrayBySeparatingStrings( 0, key, CFSTR(".") ); 
     104                        if ( !split || CFArrayGetCount( split ) != 3 ) continue; 
     105 
     106                        // This code crashes! 
     107                        //CFNumberRef cfid = (CFNumberRef) CFArrayGetValueAtIndex( split, 1 ); 
     108                        //if (cfid) 
     109                        //      CFNumberGetValue( cfid, kCFNumberIntType, &id); 
     110 
     111                        CFStringRef cfid = (CFStringRef) CFArrayGetValueAtIndex( split, 1 ); 
     112                        char *cp = NULL; 
     113                        CFIndex size = CFStringGetMaximumSizeForEncoding( CFStringGetLength( cfid ), kCFStringEncodingUTF8) + 1; 
     114                        cp = (char *)malloc(size); 
     115                        CFStringGetCString( cfid, cp, size, kCFStringEncodingUTF8 ); 
     116                        char *newcp = (char *)realloc( cp, strlen(cp) + 1); 
     117                        if (newcp != NULL) { 
     118                                cp = newcp; 
     119                                id = atoi(cp); 
     120                        } else { 
     121                                //Should not happen 
     122                                id = 0; 
    117123                        } 
    118                         index++; 
    119                 } 
    120                 CFRelease( key ); 
     124                        free(cp); 
     125 
     126                        CFRelease(key); 
     127                        CFRelease(split); 
     128                        CFRelease(cfid); 
     129                        break; 
     130                } 
     131                index++; 
    121132        } 
    122133        return id; 
     
    124135 
    125136/* 
    126 * Add a new device 
    127 */ 
    128 int Settings::addDevice() { 
    129         int id = getNextDeviceId(); 
    130         setStringSetting( id, L"name", L"", false ); //Create a empty name so the device has an entry 
    131         setStringSetting( id, L"model", L"", false ); 
     137* Add a new node 
     138*/ 
     139int Settings::addNode(Node type) { 
     140        int id = getNextNodeId(type); 
     141        setStringSetting( type, id, L"name", L"", false ); //Create a empty name so the node has an entry 
     142        if (type == Device) { 
     143                //Is there a reason we do this? 
     144                setStringSetting( type, id, L"model", L"", false ); 
     145        } 
    132146        return id; 
    133147} 
    134148 
    135149/* 
    136 * Get next available device id 
    137 */ 
    138 int Settings::getNextDeviceId() const { 
     150* Get next available node id 
     151*/ 
     152int Settings::getNextNodeId(Node type) const { 
    139153        int id = 0, max = 0; 
    140         int numberOfDevices = getNumberOfDevices(); 
    141         for( int i = 0; i < numberOfDevices; i++) { 
    142                 id = getDeviceId( i ); 
     154        int numberOfNodes = getNumberOfNodes(type); 
     155        for( int i = 0; i < numberOfNodes; i++) { 
     156                id = getNodeId( type, i ); 
    143157                if (id > max) { 
    144158                        max = id; 
     
    152166* Remove a device 
    153167*/ 
    154 int Settings::removeDevice(int intDeviceId){ 
     168int Settings::removeNode(Node type, int intNodeId){ 
    155169        int ret = TELLSTICK_ERROR_DEVICE_NOT_FOUND; 
    156         CFStringRef filterKey = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d."), intDeviceId); // The key to search for 
     170        CFStringRef filterKey = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d."), getNodeString(type).c_str(), intNodeId); // The key to search for 
    157171 
    158172        CFArrayRef cfarray = CFPreferencesCopyKeyList( d->app_ID, d->userName, d->hostName ); 
     
    168182                } 
    169183        } 
    170          
     184 
    171185        CFPreferencesSynchronize( d->app_ID, d->userName, d->hostName ); 
    172186        return ret; 
    173187} 
    174188 
    175 std::wstring Settings::getStringSetting(int intDeviceId, const std::wstring &wname, bool parameter) const { 
    176         std::string name(TelldusCore::wideToString(wname)); 
    177         CFStringRef cfname = CFStringCreateWithCString( 0, name.c_str(), kCFStringEncodingUTF8 ); 
    178          
    179         CFStringRef key; 
    180         if (parameter) { 
    181                 key = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d.parameters.%@"), intDeviceId, cfname); 
    182         } else { 
    183                 key = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d.%@"), intDeviceId, cfname);            
    184         } 
    185          
     189std::wstring Settings::getStringSetting(Node type, int intNodeId, const std::wstring &wname, bool parameter) const { 
     190        std::string name(TelldusCore::wideToString(wname)); 
     191        CFStringRef cfname = CFStringCreateWithCString( 0, name.c_str(), kCFStringEncodingUTF8 ); 
     192 
     193        CFStringRef key; 
     194        if (parameter) { 
     195                key = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d.parameters.%@"), getNodeString(type).c_str(), intNodeId, cfname); 
     196        } else { 
     197                key = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d.%@"), getNodeString(type).c_str(), intNodeId, cfname); 
     198        } 
     199 
    186200        CFStringRef value; 
    187          
     201 
    188202        value = (CFStringRef)CFPreferencesCopyValue(key, d->app_ID, d->userName, d->hostName); 
    189203        if (!value) { 
    190204                return L""; 
    191205        } 
    192          
     206 
    193207        std::wstring retval; 
    194208        char *cp = NULL; 
     
    205219        } 
    206220        free(cp); 
    207          
     221 
    208222        CFRelease(value); 
    209223        return retval; 
    210224} 
    211225 
    212 int Settings::setStringSetting(int intDeviceId, const std::wstring &wname, const std::wstring &wvalue, bool parameter) { 
     226int Settings::setStringSetting(Node type, int intNodeId, const std::wstring &wname, const std::wstring &wvalue, bool parameter) { 
    213227        std::string name(TelldusCore::wideToString(wname)); 
    214228        std::string value(TelldusCore::wideToString(wvalue)); 
    215229        CFStringRef cfname = CFStringCreateWithCString( 0, name.c_str(), kCFStringEncodingUTF8 ); 
    216230        CFStringRef cfvalue = CFStringCreateWithCString( 0, value.c_str(), kCFStringEncodingUTF8 ); 
    217          
    218         CFStringRef key; 
    219         if (parameter) { 
    220                 key = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d.parameters.%@"), intDeviceId, cfname); 
    221         } else { 
    222                 key = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d.%@"), intDeviceId, cfname);            
     231 
     232        CFStringRef key; 
     233        if (parameter) { 
     234                key = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d.parameters.%@"), getNodeString(type).c_str(), intNodeId, cfname); 
     235        } else { 
     236                key = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d.%@"), getNodeString(type).c_str(), intNodeId, cfname); 
    223237        } 
    224238 
     
    228242} 
    229243 
    230 int Settings::getIntSetting(int intDeviceId, const std::wstring &wname, bool parameter) const { 
     244int Settings::getIntSetting(Node type, int intNodeId, const std::wstring &wname, bool parameter) const { 
    231245        int retval = 0; 
    232246        std::string name(TelldusCore::wideToString(wname)); 
    233247        CFStringRef cfname = CFStringCreateWithCString( 0, name.c_str(), kCFStringEncodingUTF8 ); 
    234248        CFNumberRef cfvalue; 
    235          
    236         CFStringRef key; 
    237         if (parameter) { 
    238                 key = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d.parameters.%@"), intDeviceId, cfname); 
    239         } else { 
    240                 key = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d.%@"), intDeviceId, cfname);            
    241         } 
    242          
     249 
     250        CFStringRef key; 
     251        if (parameter) { 
     252                key = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d.parameters.%@"), getNodeString(type).c_str(), intNodeId, cfname); 
     253        } else { 
     254                key = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d.%@"), getNodeString(type).c_str(), intNodeId, cfname); 
     255        } 
     256 
    243257        cfvalue = (CFNumberRef)CFPreferencesCopyValue(key, d->app_ID, d->userName, d->hostName); 
    244258 
     
    255269                } 
    256270        } 
    257          
     271 
    258272        return retval; 
    259273} 
    260274 
    261 int Settings::setIntSetting(int intDeviceId, const std::wstring &wname, int value, bool parameter) { 
     275int Settings::setIntSetting(Node type, int intNodeId, const std::wstring &wname, int value, bool parameter) { 
    262276        std::string name(TelldusCore::wideToString(wname)); 
    263277        CFStringRef cfname = CFStringCreateWithCString( 0, name.c_str(), kCFStringEncodingUTF8 ); 
    264278        CFNumberRef cfvalue = CFNumberCreate(NULL, kCFNumberIntType, &value); 
    265          
    266         CFStringRef key; 
    267         if (parameter) { 
    268                 key = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d.parameters.%@"), intDeviceId, cfname); 
    269         } else { 
    270                 key = CFStringCreateWithFormat(0, NULL, CFSTR("devices.%d.%@"), intDeviceId, cfname);            
    271         } 
    272          
     279 
     280        CFStringRef key; 
     281        if (parameter) { 
     282                key = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d.parameters.%@"), getNodeString(type).c_str(), intNodeId, cfname); 
     283        } else { 
     284                key = CFStringCreateWithFormat(0, NULL, CFSTR("%ss.%d.%@"), getNodeString(type).c_str(), intNodeId, cfname); 
     285        } 
     286 
    273287        CFPreferencesSetValue( key, cfvalue, d->app_ID, d->userName, d->hostName ); 
    274288        CFPreferencesSynchronize( d->app_ID, d->userName, d->hostName ); 
    275         return TELLSTICK_SUCCESS;        
    276 } 
     289        return TELLSTICK_SUCCESS; 
     290} 
  • telldus-core/service/SettingsWinRegistry.cpp

    r670e5f r5bc43a  
    1616public: 
    1717        HKEY rootKey; 
    18         std::wstring strRegPathDevice; 
    19         std::wstring strRegPath;         
     18        std::wstring strRegPath; 
     19        std::wstring getNodePath(Settings::Node type); 
    2020}; 
     21 
     22std::wstring Settings::PrivateData::getNodePath(Settings::Node type) { 
     23        if (type == Settings::Device) { 
     24                return L"SOFTWARE\\Telldus\\Devices\\"; 
     25        } else if (type == Settings::Controller) { 
     26                return L"SOFTWARE\\Telldus\\Controllers\\"; 
     27        } 
     28        return L""; 
     29} 
    2130 
    2231/* 
     
    2534Settings::Settings(void) { 
    2635        d = new PrivateData(); 
    27         d->strRegPathDevice = L"SOFTWARE\\Telldus\\Devices\\"; 
    2836        d->strRegPath = L"SOFTWARE\\Telldus\\"; 
    2937        d->rootKey = HKEY_LOCAL_MACHINE; 
     
    4048* Return the number of stored devices 
    4149*/ 
    42 int Settings::getNumberOfDevices(void) const { 
    43         TelldusCore::MutexLocker locker(&mutex); 
    44  
    45         int intNumberOfDevices = 0; 
    46         HKEY hk; 
    47          
    48         long lnExists = RegOpenKeyEx(d->rootKey, d->strRegPathDevice.c_str(), 0, KEY_QUERY_VALUE, &hk); 
    49                                  
     50int Settings::getNumberOfNodes(Node type) const { 
     51        TelldusCore::MutexLocker locker(&mutex); 
     52 
     53        int intNumberOfNodes = 0; 
     54        HKEY hk; 
     55         
     56        long lnExists = RegOpenKeyEx(d->rootKey, d->getNodePath(type).c_str(), 0, KEY_QUERY_VALUE, &hk); 
     57                                         
    5058        if(lnExists == ERROR_SUCCESS){ 
    5159         
     
    5462                RegQueryInfoKey(hk, NULL, NULL, NULL, &dNumSubKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL); 
    5563                 
    56                 intNumberOfDevices = (int)dNumSubKeys; 
     64                intNumberOfNodes = (int)dNumSubKeys; 
    5765 
    5866                RegCloseKey(hk); 
    5967        } 
    60         return intNumberOfDevices; 
    61 } 
    62  
    63  
    64 int Settings::getDeviceId(int intDeviceIndex) const { 
     68        return intNumberOfNodes; 
     69} 
     70 
     71 
     72int Settings::getNodeId(Node type, int intNodeIndex) const { 
    6573        TelldusCore::MutexLocker locker(&mutex); 
    6674 
     
    6876        HKEY hk; 
    6977         
    70         long lnExists = RegOpenKeyEx(d->rootKey, d->strRegPathDevice.c_str(), 0, KEY_READ, &hk); 
     78        long lnExists = RegOpenKeyEx(d->rootKey, d->getNodePath(type).c_str(), 0, KEY_READ, &hk); 
    7179                                 
    7280        if(lnExists == ERROR_SUCCESS){ 
     
    7482                wchar_t* Buff = new wchar_t[intMaxRegValueLength]; 
    7583                DWORD size = intMaxRegValueLength; 
    76                 if (RegEnumKeyEx(hk, intDeviceIndex, (LPWSTR)Buff, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { 
     84                if (RegEnumKeyEx(hk, intNodeIndex, (LPWSTR)Buff, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) { 
    7785                        intReturn = _wtoi(Buff); 
    7886                } 
     
    8593 
    8694/* 
    87 * Add a new device 
    88 */ 
    89 int Settings::addDevice() { 
    90         TelldusCore::MutexLocker locker(&mutex); 
    91  
    92         int intDeviceId = -1; 
     95* Add a new node 
     96*/ 
     97int Settings::addNode(Node type) { 
     98        TelldusCore::MutexLocker locker(&mutex); 
     99 
     100        int intNodeId = -1; 
    93101        HKEY hk; 
    94102 
    95103        DWORD dwDisp; 
    96         intDeviceId = getNextDeviceId(); 
    97  
    98         std::wstring strCompleteRegPath = d->strRegPathDevice; 
    99         strCompleteRegPath.append(TelldusCore::intToWstring(intDeviceId)); 
     104        intNodeId = getNextNodeId(type); 
     105 
     106        std::wstring strCompleteRegPath = d->getNodePath(type); 
     107        strCompleteRegPath.append(TelldusCore::intToWstring(intNodeId)); 
    100108                 
    101109        if (RegCreateKeyEx(d->rootKey, strCompleteRegPath.c_str(), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hk, &dwDisp)) { 
    102110                //fail 
    103                 intDeviceId = -1; 
    104         } 
    105  
    106         RegCloseKey(hk); 
    107         return intDeviceId; 
     111                intNodeId = -1; 
     112        } 
     113 
     114        RegCloseKey(hk); 
     115        return intNodeId; 
    108116} 
    109117 
     
    111119* Get next available device id 
    112120*/ 
    113 int Settings::getNextDeviceId() const { 
     121int Settings::getNextNodeId(Node type) const { 
    114122        //Private, no locks needed 
    115123        int intReturn = -1; 
     
    117125        DWORD dwDisp; 
    118126 
    119         long lnExists = RegCreateKeyEx(d->rootKey, d->strRegPathDevice.c_str(), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hk, &dwDisp);  //create or open if already created 
     127        long lnExists = RegCreateKeyEx(d->rootKey, d->getNodePath(type).c_str(), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hk, &dwDisp); //create or open if already created 
    120128                                 
    121129        if(lnExists == ERROR_SUCCESS){ 
    122130                         
    123                 DWORD dwLength; 
     131                DWORD dwLength = sizeof(DWORD); 
    124132                DWORD nResult(0); 
    125133 
     
    142150* Remove a device 
    143151*/ 
    144 int Settings::removeDevice(int intDeviceId) { 
    145         TelldusCore::MutexLocker locker(&mutex); 
    146          
    147         std::wstring strCompleteRegPath = d->strRegPathDevice; 
    148         strCompleteRegPath.append(TelldusCore::intToWstring(intDeviceId)); 
     152int Settings::removeNode(Node type, int intNodeId) { 
     153        TelldusCore::MutexLocker locker(&mutex); 
     154         
     155        std::wstring strCompleteRegPath = d->getNodePath(type); 
     156        strCompleteRegPath.append(TelldusCore::intToWstring(intNodeId)); 
    149157 
    150158        long lngSuccess = RegDeleteKey(d->rootKey, strCompleteRegPath.c_str()); 
     
    185193} 
    186194 
    187 std::wstring Settings::getStringSetting(int intDeviceId, const std::wstring &name, bool parameter) const { 
     195std::wstring Settings::getStringSetting(Node type, int intNodeId, const std::wstring &name, bool parameter) const { 
    188196        std::wstring strReturn; 
    189197        HKEY hk; 
    190198 
    191         std::wstring strCompleteRegPath = d->strRegPathDevice; 
    192         strCompleteRegPath.append(TelldusCore::intToWstring(intDeviceId)); 
     199        std::wstring strCompleteRegPath = d->getNodePath(type); 
     200        strCompleteRegPath.append(TelldusCore::intToWstring(intNodeId)); 
    193201        long lnExists = RegOpenKeyEx(d->rootKey, strCompleteRegPath.c_str(), 0, KEY_QUERY_VALUE, &hk); 
    194202                         
     
    213221} 
    214222 
    215 int Settings::setStringSetting(int intDeviceId, const std::wstring &name, const std::wstring &value, bool parameter) { 
     223int Settings::setStringSetting(Node type, int intNodeId, const std::wstring &name, const std::wstring &value, bool parameter) { 
    216224 
    217225        HKEY hk; 
    218226        int ret = TELLSTICK_SUCCESS; 
    219227                 
    220         std::wstring bla = TelldusCore::intToWstring(intDeviceId); 
    221         std::wstring strCompleteRegPath = d->strRegPathDevice; 
    222         strCompleteRegPath.append(bla); 
     228        std::wstring strNodeId = TelldusCore::intToWstring(intNodeId); 
     229        std::wstring strCompleteRegPath = d->getNodePath(type); 
     230        strCompleteRegPath.append(strNodeId); 
    223231        long lnExists = RegOpenKeyEx(d->rootKey, strCompleteRegPath.c_str(), 0, KEY_WRITE, &hk); 
    224232                                 
     
    235243} 
    236244 
    237 int Settings::getIntSetting(int intDeviceId, const std::wstring &name, bool parameter) const { 
     245int Settings::getIntSetting(Node type, int intNodeId, const std::wstring &name, bool parameter) const { 
    238246        int intReturn = 0; 
    239247 
    240         std::wstring strSetting = getStringSetting(intDeviceId, name, parameter); 
     248        std::wstring strSetting = getStringSetting(type, intNodeId, name, parameter); 
    241249        if (strSetting.length()) { 
    242                 intReturn = (int)strSetting[0]; 
    243         } 
    244  
    245         return intReturn; 
    246 } 
    247  
    248 int Settings::setIntSetting(int intDeviceId, const std::wstring &name, int value, bool parameter) { 
     250                intReturn = (int)strSetting[0]; //TODO: do real conversion instead 
     251        } 
     252 
     253        return intReturn; 
     254} 
     255 
     256int Settings::setIntSetting(Node type, int intNodeId, const std::wstring &name, int value, bool parameter) { 
    249257        int intReturn = TELLSTICK_ERROR_UNKNOWN; 
    250258        HKEY hk; 
    251259 
    252         std::wstring strCompleteRegPath =  d->strRegPathDevice; 
    253         strCompleteRegPath.append(TelldusCore::intToWstring(intDeviceId)); 
     260        std::wstring strCompleteRegPath =  d->getNodePath(type); 
     261        strCompleteRegPath.append(TelldusCore::intToWstring(intNodeId)); 
    254262        long lnExists = RegOpenKeyEx(d->rootKey, strCompleteRegPath.c_str(), 0, KEY_WRITE, &hk); 
    255263        if (lnExists == ERROR_SUCCESS) { 
  • telldus-core/service/TellStick.h

    re83416 rd72866  
    2525class TellStick : public Controller, public TelldusCore::Thread { 
    2626public: 
    27         TellStick(int controllerId, TelldusCore::Event *event, const TellStickDescriptor &d); 
     27        TellStick(int controllerId, TelldusCore::EventRef event, TelldusCore::EventRef updateEvent, const TellStickDescriptor &d); 
    2828        virtual ~TellStick(); 
    2929 
    30         virtual int firmwareVersion(); 
    3130        virtual int pid() const; 
    3231        virtual int vid() const; 
  • telldus-core/service/TellStick_ftd2xx.cpp

    r670e5f rd72866  
    2525public: 
    2626        bool open, running, ignoreControllerConfirmation; 
    27         int vid, pid, fwVersion; 
     27        int vid, pid; 
    2828        std::string serial, message; 
    2929        FT_HANDLE ftHandle; 
     
    4141}; 
    4242 
    43 TellStick::TellStick(int controllerId, TelldusCore::Event *event, const TellStickDescriptor &td ) 
    44         :Controller(controllerId, event) 
     43TellStick::TellStick(int controllerId, TelldusCore::EventRef event, TelldusCore::EventRef updateEvent, const TellStickDescriptor &td ) 
     44        :Controller(controllerId, event, updateEvent) 
    4545{ 
    4646        d = new PrivateData; 
     
    5555        d->vid = td.vid; 
    5656        d->pid = td.pid; 
    57         d->fwVersion = 0; 
    5857        d->serial = td.serial; 
    5958        Settings set; 
     
    110109} 
    111110 
    112 int TellStick::firmwareVersion() { 
    113         return d->fwVersion; 
    114 } 
    115  
    116111int TellStick::pid() const { 
    117112        return d->pid; 
     
    149144                } else if (data[i] == 10) { // \n found 
    150145                        if (d->message.substr(0,2).compare("+V") == 0) { 
    151                                 d->fwVersion = TelldusCore::charToInteger(d->message.substr(2).c_str()); 
     146                                setFirmwareVersion(TelldusCore::charToInteger(d->message.substr(2).c_str())); 
    152147                        } else if (d->message.substr(0,2).compare("+R") == 0) { 
    153148                                this->publishData(d->message.substr(2)); 
  • telldus-core/service/TellStick_libftdi.cpp

    re83416 r5dd66b  
    3535public: 
    3636        bool open, ignoreControllerConfirmation; 
    37         int vid, pid, fwVersion; 
     37        int vid, pid; 
    3838        std::string serial, message; 
    3939        ftdi_context ftHandle; 
     
    4343}; 
    4444 
    45 TellStick::TellStick(int controllerId, TelldusCore::Event *event, const TellStickDescriptor &td ) 
    46         :Controller(controllerId, event) 
     45TellStick::TellStick(int controllerId, TelldusCore::EventRef event, TelldusCore::EventRef updateEvent, const TellStickDescriptor &td ) 
     46        :Controller(controllerId, event, updateEvent) 
    4747{ 
    4848        d = new PrivateData; 
     
    5050        d->vid = td.vid; 
    5151        d->pid = td.pid; 
    52         d->fwVersion = 0; 
    5352        d->serial = td.serial; 
    5453        d->running = false; 
     
    9594        } 
    9695        delete d; 
    97 } 
    98  
    99 int TellStick::firmwareVersion() { 
    100         return d->fwVersion; 
    10196} 
    10297 
     
    136131                } else if (data[i] == 10) { // \n found 
    137132                        if (d->message.substr(0,2).compare("+V") == 0) { 
    138                                 d->fwVersion = TelldusCore::charToInteger(d->message.substr(2).c_str()); 
     133                                setFirmwareVersion(TelldusCore::charToInteger(d->message.substr(2).c_str())); 
    139134                        } else if (d->message.substr(0,2).compare("+R") == 0) { 
    140135                                this->publishData(d->message.substr(2)); 
  • telldus-core/service/TelldusMain.cpp

    re83416 r237cf4  
    6565        supervisor.start(); 
    6666 
    67         ControllerManager controllerManager(dataEvent.get()); 
    6867        EventUpdateManager eventUpdateManager; 
    6968        TelldusCore::EventRef deviceUpdateEvent = eventUpdateManager.retrieveUpdateEvent(); 
    7069        eventUpdateManager.start(); 
     70        ControllerManager controllerManager(dataEvent, deviceUpdateEvent); 
    7171        DeviceManager deviceManager(&controllerManager, deviceUpdateEvent); 
    7272 
     
    9292                        ConnectionListenerEventData *data = reinterpret_cast<ConnectionListenerEventData*>(eventDataRef.get()); 
    9393                        if (data) { 
    94                                 ClientCommunicationHandler *clientCommunication = new ClientCommunicationHandler(data->socket, handlerEvent, &deviceManager, deviceUpdateEvent); 
     94                                ClientCommunicationHandler *clientCommunication = new ClientCommunicationHandler(data->socket, handlerEvent, &deviceManager, deviceUpdateEvent, &controllerManager); 
    9595                                clientCommunication->start(); 
    9696                                clientCommunicationHandlerList.push_back(clientCommunication); 
  • telldus-gui/Plugins/CMakeLists.txt

    rcb6b30 r3de0a9  
    99ENDIF (BUILD_LIBTELLDUS-GUI) 
    1010 
     11SET(BUILD_PLUGIN_CONTROLLERS    FALSE   CACHE BOOL "Build plugin 'Controllers admin plugin'") 
    1112SET(BUILD_PLUGIN_DBUS   FALSE   CACHE BOOL "Build plugin 'DBus'") 
    1213SET(BUILD_PLUGIN_LIVE   FALSE   CACHE BOOL "Build plugin 'Telldus Live!'") 
    13 SET(BUILD_PLUGIN_XPL    FALSE   CACHE BOOL "Build plugin 'xPL'") 
    1414SET(BUILD_PLUGIN_SCHEDULERGUISIMPLE     FALSE   CACHE BOOL "Build plugin 'Simple Scheduler GUI'") 
    1515SET(BUILD_PLUGIN_SENSORS        TRUE    CACHE BOOL "Build plugin 'Sensors'") 
     16SET(BUILD_PLUGIN_XPL    FALSE   CACHE BOOL "Build plugin 'xPL'") 
    1617 
    1718ADD_SUBDIRECTORY(telldus) 
     
    2829        ADD_SUBDIRECTORY(Systray) 
    2930ENDIF(BUILD_PLUGIN_SYSTRAY) 
     31 
     32IF(BUILD_PLUGIN_CONTROLLERS) 
     33        ADD_SUBDIRECTORY(Controllers) 
     34ENDIF() 
    3035 
    3136IF(BUILD_PLUGIN_DBUS) 
  • telldus-gui/Plugins/QML/qmlview.cpp

    r5531d6 r210b41  
    7070        } 
    7171} 
     72 
     73void QMLView::sizeRootObjectToView(bool enable) { 
     74        if (enable) { 
     75                this->setResizeMode(QDeclarativeView::SizeRootObjectToView); 
     76        } else { 
     77                this->setResizeMode(QDeclarativeView::SizeViewToRootObject); 
     78        } 
     79} 
  • telldus-gui/Plugins/QML/qmlview.h

    ra9b68f r210b41  
    1818        void load(const QString &url); 
    1919        void setProperty( const QString & name, const QScriptValue &value ); 
     20        void sizeRootObjectToView(bool enable); 
    2021 
    2122private: 
  • telldus-gui/Plugins/TelldusCore/tellduscoreobject.cpp

    r12fdaf rd5166d  
    137137} 
    138138 
     139QVariant TelldusCoreObject::controller() const { 
     140        const int DATA_LENGTH = 255; 
     141        char name[DATA_LENGTH]; 
     142        int controllerId = 0, available = 0, controllerType = 0; 
     143 
     144        if (tdController(&controllerId, &controllerType, name, DATA_LENGTH, &available) != TELLSTICK_SUCCESS) { 
     145                qDebug() << "Return null"; 
     146                return 0; 
     147        } 
     148 
     149        QVariantMap retval; 
     150 
     151        retval["id"] = controllerId; 
     152        retval["type"] = controllerType; 
     153        retval["name"] = name; 
     154        retval["available"] = available; 
     155 
     156        return retval; 
     157} 
     158 
    139159void TelldusCoreObject::triggerError(int deviceId, int errorId) { 
    140160        char *errorString = tdGetErrorString( errorId ); 
  • telldus-gui/Plugins/TelldusCore/tellduscoreobject.h

    r12fdaf rd5166d  
    3333        QVariant sensorValue(const QString &protocol, const QString &model, int id, int dataType) const; 
    3434 
     35        QVariant controller() const; 
     36 
    3537        int turnOn( int deviceId ); 
    3638        int turnOff( int deviceId ); 
  • telldus-gui/TelldusCenter/configurationdialog.cpp

    r7213d9 rf8226b  
    8888        file.close(); 
    8989 
     90        return this->addPage(name, widget, icon); 
     91} 
     92 
     93QScriptValue ConfigurationDialog::addPage(const QString &name, QWidget *widget, const QString &icon) { 
     94        QDir dir = this->baseDir(); 
     95 
    9096        int index = d->stackedLayout->addWidget(widget); 
    9197 
  • telldus-gui/TelldusCenter/configurationdialog.h

    r0b8076 rf8226b  
    2121public slots: 
    2222        QScriptValue addPage( const QString &name, const QString &file, const QString &icon ); 
     23        QScriptValue addPage( const QString &name, QWidget *widget, const QString &icon); 
    2324        void open(); 
    2425        void valueChanged(); 
  • telldus-core/tdadmin/udev.sh

    r0fda29 r11950d  
    11#!/bin/sh 
    22 
    3 if [ "${ID_VENDOR_ID}" == "1781" ]; then 
    4         if [ "${ACTION}" == "add" ]; then 
     3if [ "${ID_VENDOR_ID}" = "1781" ]; then 
     4        if [ "${ACTION}" = "add" ]; then 
    55                @CMAKE_INSTALL_PREFIX@/sbin/tdadmin controller connect --pid=${ID_MODEL_ID} --vid=${ID_VENDOR_ID} --serial=${ID_SERIAL_SHORT} 
    6         elif [ "${ACTION}" == "remove" ]; then 
     6        elif [ "${ACTION}" = "remove" ]; then 
    77                @CMAKE_INSTALL_PREFIX@/sbin/tdadmin controller disconnect --pid=${ID_MODEL_ID} --vid=${ID_VENDOR_ID} --serial=${ID_SERIAL_SHORT} 
    88        fi 
  • telldus-core/tdtool/main.cpp

    r12ecb1 r842a04  
    2626        printf("Options:\n"); 
    2727        printf("         -[bdefhlnrv] [ --list ] [ --help ]\n"); 
     28        printf("                      [ --list-sensors ] [ --list-devices ]\n"); 
    2829        printf("                      [ --on device ] [ --off device ] [ --bell device ]\n"); 
    2930        printf("                      [ --learn device ]\n"); 
     
    3334        printf("       --list (-l short option)\n"); 
    3435        printf("             List currently configured devices and all discovered sensors.\n"); 
     36        printf("\n"); 
     37        printf("       --list-sensors\n"); 
     38        printf("       --list-devices\n"); 
     39        printf("             Alternative devices/sensors listing:\n"); 
     40        printf("             Shows devices and/or sensors using key=value format (with tabs as\n"); 
     41        printf("             separators, one device/sensor per line, no header lines.)\n"); 
    3542        printf("\n"); 
    3643        printf("       --help (-h short option)\n"); 
     
    142149                humidityvalue[0] = 0; 
    143150                char timeBuf[80]; 
     151                timeBuf[0] = 0; 
    144152                time_t timestamp = 0; 
    145153 
     
    168176        return TELLSTICK_SUCCESS; 
    169177} 
     178 
     179/* list sensors using key=value format, one sensor/line, no header lines 
     180 * and no degree or percent signs attached to the numbers - just 
     181 * plain values. */ 
     182int list_kv_sensors() { 
     183        char protocol[DATA_LENGTH], model[DATA_LENGTH]; 
     184 
     185        tdInit(); 
     186        int sensorId = 0, dataTypes = 0; 
     187        time_t now = 0; 
     188        int sensorStatus; 
     189 
     190        time(&now); 
     191        while(1) { 
     192                sensorStatus = tdSensor(protocol, DATA_LENGTH, model, DATA_LENGTH, &sensorId, &dataTypes); 
     193                if (sensorStatus != 0) break; 
     194 
     195                printf("type=sensor\tprotocol=%s\tmodel=%s\tid=%d", 
     196                        protocol, model, sensorId); 
     197 
     198                time_t timestamp = 0; 
     199 
     200                if (dataTypes & TELLSTICK_TEMPERATURE) { 
     201                        char tempvalue[DATA_LENGTH]; 
     202                        tdSensorValue(protocol, model, sensorId, TELLSTICK_TEMPERATURE, tempvalue, DATA_LENGTH, (int *)&timestamp); 
     203                        printf("\ttemperature=%s", tempvalue); 
     204                } 
     205 
     206                if (dataTypes & TELLSTICK_HUMIDITY) { 
     207                        char humidityvalue[DATA_LENGTH]; 
     208                        tdSensorValue(protocol, model, sensorId, TELLSTICK_HUMIDITY, humidityvalue, DATA_LENGTH, (int *)&timestamp); 
     209                        printf("\thumidity=%s", humidityvalue); 
     210                } 
     211 
     212                if (dataTypes & (TELLSTICK_TEMPERATURE | TELLSTICK_HUMIDITY)) { 
     213                        /* timestamp has been set, print time & age */ 
     214                        /* (age is more useful on e.g. embedded systems 
     215                         * which may not have real-time clock chips => 
     216                         * time is useful only as a relative value) */ 
     217                        char timeBuf[80]; 
     218                        strftime(timeBuf, sizeof(timeBuf), "%Y-%m-%d %H:%M:%S", localtime(&timestamp)); 
     219                        printf("\ttime=%s\tage=%d", timeBuf, (int)(now - timestamp)); 
     220                } 
     221                printf("\n"); 
     222 
     223        } 
     224        if(sensorStatus != TELLSTICK_ERROR_DEVICE_NOT_FOUND){ 
     225                char *errorString = tdGetErrorString(sensorStatus); 
     226                fprintf(stderr, "Error fetching sensors: %s\n", errorString); 
     227                tdReleaseString(errorString); 
     228                return sensorStatus; 
     229        } 
     230        return TELLSTICK_SUCCESS; 
     231} 
     232 
     233/* list devices using key=value format, one device/line, no header lines */ 
     234int list_kv_devices() { 
     235        tdInit(); 
     236        int intNum = tdGetNumberOfDevices(); 
     237        if (intNum < 0) { 
     238                char *errorString = tdGetErrorString(intNum); 
     239                fprintf(stderr, "Error fetching devices: %s\n", errorString); 
     240                tdReleaseString(errorString); 
     241                return intNum; 
     242        } 
     243        int index = 0; 
     244        while (index < intNum) { 
     245                tdInit(); 
     246                int intId = tdGetDeviceId(index); 
     247                char *name = tdGetName(intId); 
     248                printf("type=device\tid=%i\tname=%s", intId, name); 
     249                tdReleaseString(name); 
     250 
     251                int lastSentCommand = tdLastSentCommand(intId, SUPPORTED_METHODS); 
     252                char *level = 0; 
     253                switch(lastSentCommand) { 
     254                        case TELLSTICK_TURNON: 
     255                                printf("\tlastsentcommand=ON"); 
     256                                break; 
     257                        case TELLSTICK_TURNOFF: 
     258                                printf("\tlastsentcommand=OFF"); 
     259                                break; 
     260                        case TELLSTICK_DIM: 
     261                                level = tdLastSentValue(intId); 
     262                                printf("\tlastsentcommand=DIMMED\tdimlevel=%s", level); 
     263                                tdReleaseString(level); 
     264                                break; 
     265                        /* default: state is unknown, print nothing. */ 
     266                } 
     267                printf("\n"); 
     268                index++; 
     269        } 
     270} 
     271 
    170272 
    171273int find_device( char *device ) { 
     
    296398} 
    297399 
     400#define LIST_KV_SENSORS 1 
     401#define LIST_KV_DEVICES 2 
     402 
    298403int main(int argc, char **argv) 
    299404{ 
     
    302407        static struct option long_opts[] = { 
    303408                { "list", 0, 0, 'l' }, 
     409                { "list-sensors", 0, 0, LIST_KV_SENSORS }, 
     410                { "list-devices", 0, 0, LIST_KV_DEVICES }, 
    304411                { "on", 1, 0, 'n' }, 
    305412                { "off", 1, 0, 'f' }, 
     
    349456                                success = list_devices(); 
    350457                                break; 
     458                        case LIST_KV_SENSORS: 
     459                                success = list_kv_sensors(); 
     460                                break; 
     461                        case LIST_KV_DEVICES: 
     462                                success = list_kv_devices(); 
     463                                break; 
    351464                        case 'n' : 
    352465                                success = switch_device(true, &optarg[0]); 
Note: See TracChangeset for help on using the changeset viewer.