i need to send an event to the server...
the event which i hav to send is...
d->asyncEvent.printOn(std::cout);
of the prog given below..
#include "Mouse3D.h"
#include "DevicesManager.h"
#include"Event.h"
#include <iostream>
using namespace hid;
namespace connexion_3d
{
const UInt32 Usage::MULTIAXIS_CONTROLLER_USAGE = 0x08;
const UInt32 Usage::PRIMARY_USAGE_PAGE = 0x01;
const UInt32 Usage::USAGE_PAGE_BUTTON = 0x09;
const UInt32 Usage::USAGE_X = 0x30;
const UInt32 Usage::USAGE_Y = 0x31;
const UInt32 Usage::USAGE_Z = 0x32;
const UInt32 Usage::USAGE_RX = 0x33;
const UInt32 Usage::USAGE_RY = 0x34;
const UInt32 Usage::USAGE_RZ = 0x35;
const UInt32 Usage::USAGE_PAGE_LED = 0x08;
const UInt32 Usage::USAGE_GENERIC_INDICATOR = 0x4B;
Usage::Usage():
txMin(0), txMax(0), rxMin(0), rxMax(0),
tyMin(0), tyMax(0), ryMin(0), ryMax(0),
tzMin(0), tzMax(0), rzMin(0), rzMax(0),
buttonsNumber(0)
{}
const unsigned int Mouse3D::QUEUE_SZ = 256;
const unsigned char Mouse3D::LED_ON = 0x01;
const unsigned char Mouse3D::LED_OFF = 0x00;
Mouse3D::Mouse3D(const IOHIDDeviceRef& _device):device(_device),usages(), queue(HIDDevice::makeQueue(_device, QUEUE_SZ)), valid(false), ledElement(NULL), isOpen(false), asyncEvent()
{
setup();
}
Mouse3D::~Mouse3D()
{
releaseQueue();
}
void Mouse3D:: releaseQueue()
{
if (queue)
{
IOHIDQueueStop(queue);
CFRelease(queue);
queue = NULL;
}
}
void Mouse3D::setup()
{
if (device && queue)
{
if (setupElements())
{
asyncEvent.buttons.resize(usages.buttonsNumber);
IOHIDQueueStart(queue);
valid = true;
}
}
}
void Mouse3D::open()
{
isOpen = true;
ledOn();
}
void Mouse3D::close()
{
isOpen = false;
ledOff();
}
unsigned short Mouse3D::buttonsNumber() const
{
return usages.buttonsNumber;
}
const Usage& Mouse3D::usage() const
{
return usages;
}
bool Mouse3D::ledOn() const
{
return writeOnLed(LED_ON);
}
bool Mouse3D::ledOff() const
{
return writeOnLed(LED_OFF);
}
bool Mouse3D::writeOnLed(unsigned char v) const
{
if (ledElement)
{
IOHIDValueRef vref = IOHIDValueCreateWithIntegerValue( kCFAllocatorDefault, ledElement, 0, v );
if ( vref )
{
IOReturn tIOReturn = IOHIDDeviceSetValue(device, ledElement, vref );
CFRelease( vref );
return kIOReturnSuccess == tIOReturn;
}
}
return false;
}
bool Mouse3D::setupElements()
{
CFArrayRef elements = IOHIDDeviceCopyMatchingElements( device, NULL, 0 );
if ( elements )
{
usages.buttonsNumber = 0;
CFIndex idx, cnt = CFArrayGetCount( elements );
for ( idx = 0; idx < cnt; idx++ )
{
IOHIDElementRef eref = ( IOHIDElementRef ) CFArrayGetValueAtIndex( elements, idx );
if ( eref )
{
if (!HIDIsValidElement(eref)) continue;
uint32_t usagePage = IOHIDElementGetUsagePage( eref );
uint32_t usage = IOHIDElementGetUsage( eref );
IOHIDElementType eleType = IOHIDElementGetType( eref );
if ( eleType == kIOHIDElementTypeOutput )
{
if (usagePage== Usage::USAGE_PAGE_LED && usage == Usage::USAGE_GENERIC_INDICATOR)
ledElement = eref;
}
if ( eleType > kIOHIDElementTypeInput_ScanCodes ) continue; // skip non-input element types
if ( !usagePage || !usage ) continue;
if ( -1 == usage ) continue;
//HIDDumpElementInfo(eref);
switch (usagePage)
{
case Usage::PRIMARY_USAGE_PAGE:
switch(usage)
{
case Usage::USAGE_X:
IOHIDQueueAddElement(queue, eref);
usages.txMin = IOHIDElementGetLogicalMin( eref );
usages.txMax = IOHIDElementGetLogicalMax( eref );
break;
case Usage::USAGE_Y:
IOHIDQueueAddElement(queue, eref);
usages.tyMin = IOHIDElementGetLogicalMin( eref );
usages.tyMax = IOHIDElementGetLogicalMax( eref );
break;
case Usage::USAGE_Z:
IOHIDQueueAddElement(queue, eref);
usages.tzMin = IOHIDElementGetLogicalMin( eref );
usages.tzMax = IOHIDElementGetLogicalMax( eref );
break;
case Usage::USAGE_RX:
IOHIDQueueAddElement(queue, eref);
usages.rxMin = IOHIDElementGetLogicalMin( eref );
usages.rxMax = IOHIDElementGetLogicalMax( eref );
break;
case Usage::USAGE_RY:
IOHIDQueueAddElement(queue, eref);
usages.ryMin = IOHIDElementGetLogicalMin( eref );
usages.ryMax = IOHIDElementGetLogicalMax( eref );
break;
case Usage::USAGE_RZ:
IOHIDQueueAddElement(queue, eref);
usages.rzMin = IOHIDElementGetLogicalMin( eref );
usages.rzMax = IOHIDElementGetLogicalMax( eref );
break;
}
break;
case Usage::USAGE_PAGE_BUTTON:
IOHIDQueueAddElement(queue, eref);
usages.buttonsNumber++;
break;
}
}
}
CFRelease(elements);
return true;
}
return false;
}
bool Mouse3D::read(Event3D& event) const
{
if (!(queue && device)) return false;
IOHIDValueRef vref = IOHIDQueueCopyNextValue(queue);
if (!vref) return false;
CFRelease(vref);
CFIndex value = IOHIDValueGetIntegerValue(vref);
IOHIDElementRef eref = IOHIDValueGetElement( vref );
if ( !eref ) return false;
uint32_t usagePage = IOHIDElementGetUsagePage( eref );
uint32_t usage = IOHIDElementGetUsage( eref );
if ( !usagePage || !usage ) return false;
if ( -1 == usage ) return false;
switch (usagePage)
{
case Usage::PRIMARY_USAGE_PAGE:
switch(usage)
{
case Usage::USAGE_X: event.tx = value; break;
case Usage::USAGE_Y: event.ty = value; break;
case Usage::USAGE_Z: event.tz = value; break;
case Usage::USAGE_RX: event.rx = value; break;
case Usage::USAGE_RY: event.ry = value; break;
case Usage::USAGE_RZ: event.rz = value; break;
}
break;
case Usage::USAGE_PAGE_BUTTON:
event.buttons[usage-1] = (value == 1); break;
break;
}
return true;
}
std::string Mouse3D::manufacturerString()
{
return HIDDevice::toStdString(IOHIDDevice_GetManufacturer(device));
}
std::string Mouse3D::productString()
{
return HIDDevice::toStdString(IOHIDDevice_GetProduct(device));
}
IOHIDDeviceRef Mouse3D::hidDevice()
{
return device;
}
void Mouse3D::hidDevice(IOHIDDeviceRef _device)
{
releaseQueue();
device = _device;
queue = HIDDevice::makeQueue(_device, QUEUE_SZ);
valid = false;
ledElement = NULL;
setup();
if (isOpen) open();
}
bool Mouse3D::isValid() const
{
return valid;
}
void Mouse3D::invalid()
{
valid = false;
}
void Mouse3D::deviceValueCallback( void * inContext, IOReturn inResult, void * inSender, IOHIDValueRef inIOHIDValueRef )
{
//#pragma unused( inSender )
IOHIDElementRef eref = IOHIDValueGetElement( inIOHIDValueRef );
if (!eref) return;
IOHIDDeviceRef tIOHIDDeviceRef = IOHIDElementGetDevice(eref);
if (!tIOHIDDeviceRef) return;
Mouse3D *d = ( Mouse3D* ) inContext;
if (!d) return;
std::cout << std::endl;
UInt32 usagePage = IOHIDElementGetUsagePage( eref );
UInt32 usage = IOHIDElementGetUsage( eref );
if ( !usagePage || !usage ) return;
if ( -1 == usage ) return;
//HIDDumpElementInfo(eref);
CFIndex value = IOHIDValueGetIntegerValue(inIOHIDValueRef);
switch(usagePage)
{
case Usage::PRIMARY_USAGE_PAGE:
switch(usage)
{
case Usage::USAGE_X: d->asyncEvent.tx = value; break;
case Usage::USAGE_Y: d->asyncEvent.ty = value; break;
case Usage::USAGE_Z: d->asyncEvent.tz = value; break;
case Usage::USAGE_RX: d->asyncEvent.rx = value; break;
case Usage::USAGE_RY: d->asyncEvent.ry = value; break;
case Usage::USAGE_RZ: d->asyncEvent.rz = value; break;
}
break;
case Usage::USAGE_PAGE_BUTTON:
d->asyncEvent.buttons[usage-1] = (value == 1); break;
break;
}
d->asyncEvent.printOn(std::cout);
}
}
to the server....
the server program is..
#include <iostream>
#include "jmp_tcp/TcpServer.h"
#include "3d_connexion_poc/Protocol.h"
#include "cfsocket/CFTcpServer.h"
using namespace jmp_tcp;
class ServerTest : public TcpServer
{
protected:
virtual void handleConnection(int cfd)
{
char buff[256];
std::cout << "handles a new connection" << std::endl;
while(true)
{
std::cout << " new read " << std::endl;
bzero((char *) buff, sizeof(buff));
int length = recv(cfd, buff, sizeof(buff), 0);
std::cout << " length " << length << std::endl;
if (length <=0) break;
else
{
send(cfd, buff, length, 0);
std::cout << buff << std::endl;
if (strcmp(buff, "by")==0) break;
}
}
std::cout << "terminate a connection" << std::endl;
}
};
void dynamicPort()
{
ServerTest server;
int port = 8000;
while(!server.setup(port) && port <9000)
{
std::cout << std::endl << "server setup failed for port "<< port << std::endl;
port++;
}
std::cout << std::endl << "server running" << std::endl;
server.acceptConnections();
}
void staticPort()
{
ServerTest server;
int port = 8000;
if(!server.setup(port))
{
std::cout << std::endl << "server setup failed"<< std::endl;
return;
}
std::cout << std::endl << "server running" << std::endl;
server.acceptConnections();
}
void testProtocol()
{
Protocol<int> p;
p.setElementValue("x", 10);
p.setElementValue("y", 23);
p.setElementValue("z",544);
p.printOn(std::cout << std::endl);
int length=0;
const char* frame = p.getBuffer(length);
p.setBuffer(frame, length);
p.printOn(std::cout << std::endl);
}
void testCFTcpServer()
{
CFTcpServer server;
int port = 8000;
if(!server.setup(port))
{
std::cout << std::endl << "server setup failed"<< std::endl;
return;
}
std::cout << std::endl << "server running"<< std::endl;
CFRunLoopRun();
}
int main (int argc, char * const argv[])
{
//staticPort();
//dynamicPort();
//testProtocol();
testCFTcpServer();
return 0;
}
and the client program is..
#include <iostream>
#include "jmp_tcp/TcpClient.h"
using namespace jmp_tcp;
int main (int argc, char * const argv[]) {
TcpClient client;
if(!client.connectByName("localhost", 8000))
{
std::cout << std::endl << "client connection failed"<< std::endl;
return 0;
}
std::string msg;
char buff[256];
while(msg != "by")
{
std::cin >> msg;
if(msg.length() >0)
{
bzero((char *) buff, sizeof(buff));
if (!client.send(msg.c_str(), msg.length()))
{
std::cout<< std::endl << "send error";
break;
}
int len = client.read(buff, sizeof(buff));
std::cout << std::endl << len << " " << buff << std::endl;
if (len <=0) break;
else
{
std::cout << std::endl << len << " " << buff << std::endl;
}
}
}
client.disconnect();
return 0;
}
how should i link this..