Tekkotsu Homepage
Demos
Overview
Downloads
Dev. Resources
Reference
Credits

EventProxy.cc

Go to the documentation of this file.
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   //For some reason this causes a crash, so it's commented out for now
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       //Get the buffer type
00033       if (!readType(data, bytes)) {
00034         cout << "Error reading buffer type" << endl;
00035       }
00036     } else if (!sizeLeft) {
00037       //Get the size
00038       if (!readSize(data, bytes)) {
00039         cout << "Error reading buffer size" << endl;
00040       }
00041     } else {
00042       //Read some data
00043       if (readData(data, bytes)) {
00044         //Dispatch the chunk of data
00045         switch(bufType) {
00046         case RequestData:
00047           //Dispatch the data
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 /* Encodes and sends the received event */
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     //Send Event to connected robot
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     //Send state information
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 /* Encodes and sends the requested state info */
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   /* Get the source of the data */
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 }

Tekkotsu v4.0
Generated Thu Nov 22 00:54:53 2007 by Doxygen 1.5.4