00001 #include "Events/EventProxy.h"
00002 #include "Shared/WorldState.h"
00003 #include "Events/RemoteRouter.h"
00004 #include "Events/EventRouter.h"
00005
00006 using namespace std;
00007
00008 EventProxy::EventProxy(int port) : RemoteEvents(), listening(true) {
00009 sck = wireless->socket(Socket::SOCK_STREAM, 4096, 4096);
00010 wireless->setReceiver(sck, this);
00011 wireless->setDaemon(sck, true);
00012 wireless->listen(sck, port);
00013
00014 cout << "Adding timer" << endl;
00015 }
00016
00017 EventProxy::~EventProxy() {
00018
00019
00020 if (isConnected())
00021 wireless->close(sck);
00022 }
00023
00024 bool EventProxy::isActive() {
00025 return listening || isConnected();
00026 }
00027
00028 int EventProxy::processData(char *data, int bytes) {
00029 listening = false;
00030 while (bytes) {
00031 if (bufType == Invalid) {
00032
00033 if (!readType(data, bytes)) {
00034 cout << "Error reading buffer type" << endl;
00035 }
00036 } else if (!sizeLeft) {
00037
00038 if (!readSize(data, bytes)) {
00039 cout << "Error reading buffer size" << endl;
00040 }
00041 } else {
00042
00043 if (readData(data, bytes)) {
00044
00045 switch(bufType) {
00046 case RequestData:
00047
00048 handleRemoteRequest((RemoteRequest *)&vecbuf[0]);
00049 break;
00050 case Invalid:
00051 cout << "Error: invalid data. This should never happen." << endl;
00052 return -1;
00053 default:
00054 cout << "Error: data came in that wasn't expected" << endl;
00055 return -1;
00056 }
00057 bufType = Invalid;
00058 }
00059 }
00060 }
00061
00062 return 0;
00063 }
00064
00065
00066 void EventProxy::processEvent(const EventBase &event) {
00067
00068 if (event.getGeneratorID() != EventBase::timerEGID) {
00069 if (!isConnected()) {
00070 cout << "Got an event but not connected!" << endl;
00071 return;
00072 }
00073
00074
00075
00076 int esize = 0;
00077 byte *ebuf = new byte[defaultBufferSize];
00078
00079 if ( (esize = event.saveBinaryBuffer((char *)ebuf, defaultBufferSize)) ) {
00080 NetworkBuffer nBuf;
00081 nBuf.addItem(EventData);
00082 nBuf.addBuffer(ebuf, esize);
00083
00084 if (!nBuf.send(sck)) {
00085 cout << "Error sending event to remote dog" << endl;
00086 return;
00087 }
00088 } else {
00089 cout << "Unable to save event to a buffer, aborting transmission" << endl;
00090 }
00091
00092 delete[] ebuf;
00093 } else {
00094
00095 sendState((RemoteState::StateType)event.getSourceID());
00096 }
00097 }
00098
00099 void EventProxy::handleRemoteRequest(RemoteRequest *info) {
00100 switch (info->type) {
00101 case EventListenerRequest:
00102 cout << "Adding remote event listener request: " << info->numElements
00103 << " for host " << remoteIPString() << endl;
00104
00105 switch (info->numElements) {
00106 case 1:
00107 erouter->addListener(this, info->egid);
00108 break;
00109
00110 case 2:
00111 erouter->addListener(this, info->egid, info->sid);
00112 break;
00113
00114 case 3:
00115 erouter->addListener(this, info->egid, info->sid, info->etid);
00116 break;
00117
00118 default:
00119 cout << "Invalid number of elements in event listener request." << endl;
00120 break;
00121 }
00122 break;
00123
00124
00125 case RemoveEventListenerRequest:
00126 cout << "Removing remote event listener: " << info->numElements
00127 << " for host " << remoteIPString() << endl;
00128
00129 switch (info->numElements) {
00130 case 1:
00131 erouter->removeListener(this, info->egid);
00132 break;
00133
00134 case 2:
00135 erouter->removeListener(this, info->egid, info->sid);
00136 break;
00137
00138 case 3:
00139 erouter->removeListener(this, info->egid, info->sid, info->etid);
00140 break;
00141
00142 default:
00143 cout << "Invalid number of elements in event listener removal request."
00144 << endl;
00145 break;
00146 }
00147 break;
00148
00149
00150 case StateUpdateRequest:
00151 cout << "Adding remote state update request for host "
00152 << remoteIPString() << endl;
00153
00154 erouter->addTimer(this, info->sType, info->interval, true);
00155 break;
00156
00157 case StopStateUpdateRequest:
00158 cout << "Removing remote state update request" << endl;
00159
00160 erouter->removeTimer(this, info->sType);
00161 break;
00162
00163 }
00164 }
00165
00166
00167 void EventProxy::sendState(RemoteState::StateType stype) {
00168 if (!isConnected()) {
00169 cout << "Got a request to send state data but not connected!" << endl;
00170 return;
00171 }
00172
00173 float *src = NULL;
00174 int size = RemoteState::sizes[stype];
00175
00176
00177 switch (stype) {
00178 case RemoteState::OutputState:
00179 src = state->outputs;
00180 break;
00181
00182 case RemoteState::ButtonState:
00183 src = state->buttons;
00184 break;
00185
00186 case RemoteState::SensorState:
00187 src = state->sensors;
00188 break;
00189
00190 default:
00191 cout << "Unrecognized state type, aborting" << endl;
00192 return;
00193 }
00194
00195 NetworkBuffer nBuf;
00196 nBuf.addItem(StateData);
00197 nBuf.addItem(size + 2*sizeof(int));
00198 nBuf.addItem(stype);
00199 nBuf.addBuffer((byte *)src, size);
00200
00201 if (!nBuf.send(sck)) {
00202 cout << "Error sending state buffer" << endl;
00203 }
00204 }