void MSAConnection::doRead(void)
{
MSBuffer *hb=headBuffer() ;
MSBuffer *db=readBuffer() ;
int s,n;
if (isSet(MSProtocolConnection<MSA>::Reset)==MSTrue) return;
if((s=hb->put()-hb->get())<4)
{
if((n=readTheBuffer(hb,4-s))<0) return;
if((s=hb->put()-hb->get())<4) return;
_bytesToNextMessage=MSA::longAt(hb->get());
if (_bytesToNextMessage<=0)
{
hb->reset();
unset(MSProtocolConnection<MSA>::Read);
return;
}
}
if((n=readTheBuffer(db,_bytesToNextMessage))<0) return;
if((_bytesToNextMessage-=n)==0)
{
MSA d=MSA::importAObject( (char *) db->get(), db->put()-db->get(), (char *)0);
hb->reset();
db->clear();
unset(MSProtocolConnection<MSA>::Read);
if(d.isNullMSA()==MSTrue){resetWithError(MSProtocolConnection<MSA>::Read);return;}
readNotify(d);
}
return;
}
void MSRawConnection::doRead(void)
{
int n;
MSBuffer *db=headBuffer();
if (isSet(MSProtocolConnection<MSString>::Reset)==MSTrue) return;
if((n=readTheBuffer(db,MaxReadSize))<0) return;
if((n=db->put()-db->get())>0)
{
unset(MSProtocolConnection<MSString>::Read);
MSString d(db->get(),n);
db->get(db->get()+n);
readNotify(d);
}
}
bool EventHub::getEvent(RawEvent* outEvent)
{
outEvent->deviceId = 0;
outEvent->type = 0;
outEvent->scanCode = 0;
outEvent->keyCode = 0;
outEvent->flags = 0;
outEvent->value = 0;
outEvent->when = 0;
status_t err;
LOGV("EventHub::getEvent() enter");
// Note that we only allow one caller to getEvent(), so don't need
// to do locking here... only when adding/removing devices.
if (!mOpened) {
mError = openPlatformInput() ? NO_ERROR : UNKNOWN_ERROR;
mOpened = true;
mNeedToSendFinishedDeviceScan = true;
}
for (;;) {
// Report any devices that had last been added/removed.
if (mClosingDevices != NULL) {
device_t* device = mClosingDevices;
LOGV("Reporting device closed: id=0x%x, name=%s\n",
device->id, device->path.string());
mClosingDevices = device->next;
if (device->id == mFirstKeyboardId) {
outEvent->deviceId = 0;
} else {
outEvent->deviceId = device->id;
}
outEvent->type = DEVICE_REMOVED;
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
delete device;
mNeedToSendFinishedDeviceScan = true;
return true;
}
if (mOpeningDevices != NULL) {
device_t* device = mOpeningDevices;
LOGV("Reporting device opened: id=0x%x, name=%s\n",
device->id, device->path.string());
mOpeningDevices = device->next;
if (device->id == mFirstKeyboardId) {
outEvent->deviceId = 0;
} else {
outEvent->deviceId = device->id;
}
outEvent->type = DEVICE_ADDED;
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
mNeedToSendFinishedDeviceScan = true;
return true;
}
if (mNeedToSendFinishedDeviceScan) {
mNeedToSendFinishedDeviceScan = false;
outEvent->type = FINISHED_DEVICE_SCAN;
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
return true;
}
// Grab the next input event for device mDevices[mInputDeviceIndex].
for (;;) {
#ifdef HAVE_TSLIB
//Checks if we have to send any more TS events read by input-raw plugin
//else we process other events
if (tsSamp.total_events && tsSamp.tsSampleReady) {
LOGV("Processing TS Event");
outEvent->deviceId = mDevices[tsSamp.tsIndex]->id;
outEvent->type = tsSamp.ev[numOfEventsSent].type;
outEvent->scanCode = tsSamp.ev[numOfEventsSent].code;
outEvent->keyCode = tsSamp.ev[numOfEventsSent].code;
outEvent->value = tsSamp.ev[numOfEventsSent].value;
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
switch (outEvent->type) {
case EV_KEY:
outEvent->keyCode = AKEYCODE_UNKNOWN;
outEvent->flags = 0;
break;
case EV_ABS:
switch (outEvent->scanCode) {
case ABS_X:
outEvent->value = tsSamp.x;
LOGV("outEvent->valueX=%d",outEvent->value);
break;
case ABS_Y:
outEvent->value = tsSamp.y;
LOGV("outEvent->valueY=%d",outEvent->value);
break;
case ABS_PRESSURE:
outEvent->value = tsSamp.pressure;
LOGV("outEvent->valueP=%d",outEvent->value);
break;
}
break;
}
LOGV("%s (id: 0x%x) got: t0=%d, t1=%d, type=%d, code=%d, v=%d,"
" keyCode=%d, flags=0x%08x",
mDevices[tsSamp.tsIndex]->path.string(),
outEvent->deviceId,
(int) tsSamp.ev[numOfEventsSent].time.tv_sec,
(int) tsSamp.ev[numOfEventsSent].time.tv_usec,
outEvent->type,outEvent->scanCode, outEvent->value,
outEvent->keyCode,outEvent->flags);
numOfEventsSent++;
LOGV("numOfEventsSent: %d, tsSamp.total_events: %d",
numOfEventsSent, tsSamp.total_events);
LOGV("EventHub::getEvent() exit");
if (numOfEventsSent == tsSamp.total_events){
//All the events from the read call have been dealt with,
//clearing tsSamp for next call.
tsSamp.total_events = 0;
tsSamp.tsSampleReady = 0;
numOfEventsSent = 0;
}
return true;
}
#endif
// Consume buffered input events, if any.
if (mInputBufferIndex < mInputBufferCount) {
const struct input_event& iev = mInputBufferData[mInputBufferIndex++];
const device_t* device = mDevices[mInputDeviceIndex];
LOGV("%s (id: 0x%x) got: t0=%d, t1=%d, type=%d, code=%d, v=%d", device->path.string(),
device->id,(int) iev.time.tv_sec, (int) iev.time.tv_usec, iev.type, iev.code, iev.value);
if (device->id == mFirstKeyboardId) {
outEvent->deviceId = 0;
} else {
outEvent->deviceId = device->id;
}
outEvent->type = iev.type;
outEvent->scanCode = iev.code;
if (iev.type == EV_KEY) {
err = device->layoutMap->map(iev.code,& outEvent->keyCode, & outEvent->flags);
if (err != 0) {
LOGV("EV_KEY event, error (%d) accessing device layout map \n",err);
outEvent->keyCode = AKEYCODE_UNKNOWN;
outEvent->flags = 0;
}
} else {
outEvent->keyCode = iev.code;
}
LOGV("iev.code=%d keyCode=%d flags=0x%08x \n",iev.code, outEvent->keyCode, outEvent->flags);
outEvent->value = iev.value;
// Use an event timestamp in the same timebase as
// java.lang.System.nanoTime() and android.os.SystemClock.uptimeMillis()
// as expected by the rest of the system.
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
LOGV("EventHub::getEvent() exit");
return true;
}
// Finish reading all events from devices identified in previous poll().
// This code assumes that mInputDeviceIndex is initially 0 and that the
// revents member of pollfd is initialized to 0 when the device is first added.
// Since mFDs[0] is used for inotify, we process regular events starting at index 1.
mInputDeviceIndex += 1;
if (mInputDeviceIndex >= mFDCount) {
LOGV("Done processing events received in last poll for all devices.");
break;
}
const struct pollfd& pfd = mFDs[mInputDeviceIndex];
if (pfd.revents & POLLIN) {
#ifdef HAVE_TSLIB
LOGV("Reading events from device. id: 0x%x , mInputDeviceIndex: %d, fd: %d, mTS->fd: %d",
mDevices[mInputDeviceIndex]->id,mInputDeviceIndex, mFDs[mInputDeviceIndex].fd, mTS->fd);
if (mTS != NULL) {
if (mFDs[mInputDeviceIndex].fd != mTS->fd ) {
#endif
int32_t readSize = read(pfd.fd, mInputBufferData, sizeof(struct input_event) * INPUT_BUFFER_SIZE);
if (readSize < 0) {
if (errno != EAGAIN && errno != EINTR) {
LOGW("could not get event (errno=%d)", errno);
}
} else if ((readSize % sizeof(struct input_event)) != 0) {
LOGE("could not get event (wrong size: %d)", readSize);
} else {
mInputBufferCount = readSize / sizeof(struct input_event);
mInputBufferIndex = 0;
LOGV("Buffered %d events from device", mInputBufferCount);
}
#ifdef HAVE_TSLIB
}
else{
int res = ts_read(mTS, &tsSamp, 1);
if (res < 0) {
LOGE("[EventHub::after poll] Error in ts_read()");
}
else {
tsSamp.tsIndex = mInputDeviceIndex;
LOGV("After ts_read call: tsSamp[total_events: %d,"
" tsIndex: %d tsSampleReady: %d] res:%d ",
tsSamp.total_events,tsSamp.tsIndex,
tsSamp.tsSampleReady,res);
//we have read a TS event, we want to process this now.
}
}
}
else {
LOGE("EventHub:: ERROR in setup of mTS: mTS is NULL!");
}
#endif
}//end of if (pfd.revents & POLLIN)
} //end of for(;;) get next input event
#if HAVE_INOTIFY
// readNotify() will modify mFDs and mFDCount, so this must be done after
// processing all other events.
if(mFDs[0].revents & POLLIN) {
readNotify(mFDs[0].fd);
mFDs[0].revents = 0;
LOGV("After readNotify()");
continue; // report added or removed devices immediately
}
#endif
mInputDeviceIndex = 0;
// Poll for events. Mind the wake lock dance!
// We hold a wake lock at all times except during poll(). This works due to some
// subtle choreography. When a device driver has pending (unread) events, it acquires
// a kernel wake lock. However, once the last pending event has been read, the device
// driver will release the kernel wake lock. To prevent the system from going to sleep
// when this happens, the EventHub holds onto its own user wake lock while the client
// is processing events. Thus the system can only sleep if there are no events
// pending or currently being processed.
release_wake_lock(WAKE_LOCK_ID);
LOGV("Calling Poll()");
int pollResult = poll(mFDs, mFDCount, -1);
LOGV("After calling Poll()");
acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
if (pollResult <= 0) {
if (errno != EINTR) {
LOGW("poll failed (errno=%d)\n", errno);
usleep(100000);
}
}
}//end of for(;;)
}//end of getEvent()
void MSAConnection::doReadBurst(void)
{
int burstLength,n;
if (isSet(MSProtocolConnection<MSA>::Reset)==MSTrue) return;
#ifdef MS_WINSOCK
if (ioctlsocket(fd(),FIONREAD,(unsigned long*)&burstLength) == -1)
#else
if (ioctl(fd(),FIONREAD,(caddr_t)&burstLength) == -1)
#endif
{
resetWithError(MSProtocolConnection<MSA>::Read);
return;
}
if (burstLength<0) {return;}
if (burstLength==0)
{
MSMessageLog::infoMessage("MSAConnection: No data to be read on read event\n");
burstLength=4;
}
MSBuffer b(burstLength);
if (n=readTheBuffer(&b,burstLength)<0)
{
return;
}
if (n==0&&burstLength==0)
{
unset(MSProtocolConnection<MSA>::Read);
return;
}
MSA d(getAobjectFromBuffer(&b));
if (d.isNullMSA()==MSTrue) {return;}
int count=1,s=0;
char *cp;
for(cp=b.get();cp<b.put();cp+=s)
{
s=MSA::longAt(cp);
cp+=sizeof(long);
if(b.put()-cp>=s) ++count;
}
MSA z(MSA::gv(MSA::ETYPE,count));
int i;
for(i=0;i<count;++i) z.aStructPtr()->p[i]=0;
int index=0;
z.aStructPtr()->p[index++]=(long)d.aStructPtr();
while(index<count)
{
d=getAobjectFromBuffer(&b);
if(d.isNullMSA()==MSTrue) break;
z.aStructPtr()->p[index++]=(long)d.aStructPtr();
}
if (index<count)
{
MSMessageLog::warningMessage("MSAConnection: Burst Mode Aborted. Possible Data Loss.\n");
}
if (b.get()==b.put()) unset(MSProtocolConnection<MSA>::Read);
else
{
d=getAobjectFromBuffer(&b);
if (d.isNullMSA()==MSFalse || b.get()!=b.put())
{
MSMessageLog::warningMessage("MSAConnection: Burst Buffer Not Cleared\n");
}
}
readNotify(d);
}
bool EventHub::getEvent(RawEvent* outEvent)
{
outEvent->deviceId = 0;
outEvent->type = 0;
outEvent->scanCode = 0;
outEvent->keyCode = 0;
outEvent->flags = 0;
outEvent->value = 0;
outEvent->when = 0;
// Note that we only allow one caller to getEvent(), so don't need
// to do locking here... only when adding/removing devices.
if (!mOpened) {
mError = openPlatformInput() ? NO_ERROR : UNKNOWN_ERROR;
mOpened = true;
mNeedToSendFinishedDeviceScan = true;
}
for (;;) {
// Report any devices that had last been added/removed.
if (mClosingDevices != NULL) {
device_t* device = mClosingDevices;
LOGV("Reporting device closed: id=0x%x, name=%s\n",
device->id, device->path.string());
mClosingDevices = device->next;
if (device->id == mFirstKeyboardId) {
outEvent->deviceId = 0;
} else {
outEvent->deviceId = device->id;
}
outEvent->type = DEVICE_REMOVED;
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
delete device;
mNeedToSendFinishedDeviceScan = true;
return true;
}
if (mOpeningDevices != NULL) {
device_t* device = mOpeningDevices;
LOGV("Reporting device opened: id=0x%x, name=%s\n",
device->id, device->path.string());
mOpeningDevices = device->next;
if (device->id == mFirstKeyboardId) {
outEvent->deviceId = 0;
} else {
outEvent->deviceId = device->id;
}
outEvent->type = DEVICE_ADDED;
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
mNeedToSendFinishedDeviceScan = true;
return true;
}
if (mNeedToSendFinishedDeviceScan) {
mNeedToSendFinishedDeviceScan = false;
outEvent->type = FINISHED_DEVICE_SCAN;
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
return true;
}
// Grab the next input event.
for (;;) {
// Consume buffered input events, if any.
if (mInputBufferIndex < mInputBufferCount) {
const struct input_event& iev = mInputBufferData[mInputBufferIndex++];
const device_t* device = mDevices[mInputDeviceIndex];
LOGV("%s got: t0=%d, t1=%d, type=%d, code=%d, v=%d", device->path.string(),
(int) iev.time.tv_sec, (int) iev.time.tv_usec, iev.type, iev.code, iev.value);
if (device->id == mFirstKeyboardId) {
outEvent->deviceId = 0;
} else {
outEvent->deviceId = device->id;
}
outEvent->type = iev.type;
outEvent->scanCode = iev.code;
if (iev.type == EV_KEY) {
status_t err = device->layoutMap->map(iev.code,
& outEvent->keyCode, & outEvent->flags);
LOGV("iev.code=%d keyCode=%d flags=0x%08x err=%d\n",
iev.code, outEvent->keyCode, outEvent->flags, err);
if (err != 0) {
outEvent->keyCode = AKEYCODE_UNKNOWN;
outEvent->flags = 0;
}
} else {
outEvent->keyCode = iev.code;
}
outEvent->value = iev.value;
// Use an event timestamp in the same timebase as
// java.lang.System.nanoTime() and android.os.SystemClock.uptimeMillis()
// as expected by the rest of the system.
outEvent->when = systemTime(SYSTEM_TIME_MONOTONIC);
return true;
}
// Finish reading all events from devices identified in previous poll().
// This code assumes that mInputDeviceIndex is initially 0 and that the
// revents member of pollfd is initialized to 0 when the device is first added.
// Since mFDs[0] is used for inotify, we process regular events starting at index 1.
mInputDeviceIndex += 1;
if (mInputDeviceIndex >= mFDCount) {
break;
}
const struct pollfd& pfd = mFDs[mInputDeviceIndex];
if (pfd.revents & POLLIN) {
int32_t readSize = read(pfd.fd, mInputBufferData,
sizeof(struct input_event) * INPUT_BUFFER_SIZE);
if (readSize < 0) {
if (errno != EAGAIN && errno != EINTR) {
LOGW("could not get event (errno=%d)", errno);
}
} else if ((readSize % sizeof(struct input_event)) != 0) {
LOGE("could not get event (wrong size: %d)", readSize);
} else {
mInputBufferCount = readSize / sizeof(struct input_event);
mInputBufferIndex = 0;
}
}
}
#if HAVE_INOTIFY
// readNotify() will modify mFDs and mFDCount, so this must be done after
// processing all other events.
if(mFDs[0].revents & POLLIN) {
readNotify(mFDs[0].fd);
mFDs[0].revents = 0;
continue; // report added or removed devices immediately
}
#endif
mInputDeviceIndex = 0;
// Poll for events. Mind the wake lock dance!
// We hold a wake lock at all times except during poll(). This works due to some
// subtle choreography. When a device driver has pending (unread) events, it acquires
// a kernel wake lock. However, once the last pending event has been read, the device
// driver will release the kernel wake lock. To prevent the system from going to sleep
// when this happens, the EventHub holds onto its own user wake lock while the client
// is processing events. Thus the system can only sleep if there are no events
// pending or currently being processed.
release_wake_lock(WAKE_LOCK_ID);
int pollResult = poll(mFDs, mFDCount, -1);
acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
if (pollResult <= 0) {
if (errno != EINTR) {
LOGW("poll failed (errno=%d)\n", errno);
usleep(100000);
}
}
}
}
