void KprPinsInvoke(KprService service, KprMessage message)
{
FskErr err = kFskErrNone;
KprPins self = gPins;
if (KprMessageContinue(message)) {
KprPinsListener listener = NULL;
KprPinsListenerFind(&listener, self, message);
if (!FskStrCompareWithLength(message->parts.path, "close", message->parts.pathLength)) {
if (listener) {
xsBeginHostSandboxCode(listener->the, NULL);
{
KprPinsPoller poller = FskListGetNext(listener->pollers, NULL);
while (poller) {
KprPinsPoller next = FskListGetNext(listener->pollers, poller);
KprPinsPollerDispose(poller);
poller = next;
}
{
xsTry {
(void)xsCall0(xsAccess(listener->pins), xsID("close"));
}
xsCatch {
err = exceptionToFskErr(the);
}
}
}
xsEndHostSandboxCode();
KprPinsListenerDispose(listener, self);
}
else {
err = kFskErrNotFound;
}
}
else if (!FskStrCompareWithLength(message->parts.path, "configure", message->parts.pathLength)) {
FskErr KprHTTPClientAddTarget(KprHTTPTarget target)
{
KprHTTPClient self = gKprHTTPClient;
KprMessage message = target->message;
FskErr err = kFskErrNone;
SInt32 priority = abs(message->priority);
KprHTTPTarget iterator, after = NULL;
if (message->priority < 0) { // new requests with equal priority go to the start of that priority
for (iterator = self->targets; iterator; iterator = FskListGetNext(self->targets, iterator)) {
if (priority >= abs(iterator->message->priority))
break;
else
after = iterator;
}
}
else { // new requests with equal priority go to the end of that priority
for (iterator = self->targets; iterator; iterator = FskListGetNext(self->targets, iterator)) {
if (priority > abs(iterator->message->priority))
break;
else
after = iterator;
}
}
if (after)
FskListInsertAfter(&self->targets, target, after);
else
FskListPrepend(&self->targets, target);
KprHTTPClientIterate();
//bail:
return err;
}
void KprMessageCancelReferrer(char* url)
{
FskList messages = gShell->messages;
KprMessage message = FskListGetNext(messages, NULL);
while (message) {
KprMessage next = FskListGetNext(messages, message);
char* referrer = KprMessageGetRequestHeader(message, "referrer");
if (referrer && !FskStrCompare(referrer, url))
KprMessageCancel(message);
message = next;
}
}
// KplTimeCallbackServiceUntil is called from the KplThreadRunloopCycle() function to call timer callbacks that are due
void KplTimeCallbackServiceUntil(void *param, KplTime until)
{
KplTimeCallback cb;
KplThread thread = (KplThread)param;
cb = (KplTimeCallback)thread->timerCallbacks;
if (NULL == cb)
return;
// mark all those that are due
while (cb) {
if (FskTimeCompare((FskTime)until, (FskTime)&cb->trigger) >= 0)
break;
cb->marked = true;
cb = cb->next;
}
// Remove and call any timer callbacks that are due
while (1) {
cb = (KplTimeCallback)FskListGetNext(thread->timerCallbacks, NULL);
if (!cb)
break;
if (!cb->marked)
break;
FskListRemove(&thread->timerCallbacks, cb);
(*cb->callbackProc)(cb, &cb->trigger, cb->param);
}
if (thread->timerCallbacks)
rescheduleTimer(thread);
}
FskErr androidAudioOutSetOutputBufferSize(FskAudioOut audioOut, UInt32 chunkSize, UInt32 bufferedSamplesTarget) {
if (NULL == audioOuts)
return kFskErrNone;
FskAudioNativePrintfVerbose("androidAudioOutSetOutputBufferSize %u, %u", (unsigned)chunkSize, (unsigned)bufferedSamplesTarget);
if (audioOut) {
audioOut->chunkRequestSize = chunkSize;
audioOut->bufferedSamplesTarget = bufferedSamplesTarget;
return kFskErrNone;
}
else {
FskAudioOut walker = NULL;
sBufferedSamplesTarget = bufferedSamplesTarget;
FskListMutexAcquireMutex(audioOuts);
while (true) {
walker = (FskAudioOut)FskListGetNext(audioOuts->list, (void*)walker);
if (NULL == walker)
break;
walker->chunkRequestSize = AUDIO_DATA_BUFFER_SIZE;
if (bufferedSamplesTarget > 0 && bufferedSamplesTarget < 20) {
walker->bufferedSamplesTarget = bufferedSamplesTarget * walker->sampleRate * walker->numChannels * 2;
}
else
walker->bufferedSamplesTarget = walker->sampleRate * walker->numChannels * 2; // 1 second default
}
FskListMutexReleaseMutex(audioOuts);
return kFskErrNone;
}
}
void androidVolumeEvent(int what, char *path) {
UInt32 vid;
FskFSVolumeNotifier walker = NULL;
char *tmp = NULL;
FskAndroidFilesPrintfDebug("androidVolumeEvent - %d, %s\n", what, path);
if (NULL == gVolNotifiersMutex)
return;
FskMutexAcquire(gVolNotifiersMutex);
if (0 == FskStrCompareWithLength(path, "file://", 7))
path += 7;
if (path[FskStrLen(path)-1] != '/')
tmp = FskStrDoCat(path, "/");
else
tmp = FskStrDoCopy(path);
FskFSVolumeGetID(tmp, &vid);
FskAndroidFilesPrintfDebug("androidVolumeEvent - getvolumeid returned %d\n", vid);
if (vid == kFskUInt32Max) {
FskAndroidFilesPrintfDebug("couldn't find a mount for %s - try to scan again###\n", tmp);
scanProcMount();
FskFSVolumeGetID(tmp, &vid);
if (vid == 0) {
FskAndroidFilesPrintfDebug("#### still no volume id? %s\n", tmp);
}
}
while (gVolNotifiers) {
FskFSVolumeNotifier notifier;
walker = (FskFSVolumeNotifier)FskListGetNext(gVolNotifiers, walker);
if (NULL == walker)
break;
FskAndroidFilesPrintfDebug("androidVolumeEvent - notifying %x\n", walker);
notifier = (FskFSVolumeNotifier)(((char *)walker) - offsetof(FskFSVolumeNotifierRecord, next));
FskThreadPostCallback(notifier->callbackThread, callVolumeNotifier, notifier, (void*)what, (void*)vid, NULL);
}
FskMutexRelease(gVolNotifiersMutex);
FskMemPtrDispose(tmp);
}
FskErr androidAudioOutIsValid(FskAudioOut audioOut, Boolean *isValid) {
FskAudioOut walker = NULL;
if (!audioOuts) {
*isValid = false;
return kFskErrNone;
}
FskListMutexAcquireMutex(audioOuts);
*isValid = false;
while (true) {
walker = (FskAudioOut)FskListGetNext(audioOuts->list, (void*)walker);
if (NULL == walker)
break;
if (walker == audioOut)
*isValid = true;
}
FskListMutexReleaseMutex(audioOuts);
return kFskErrNone;
}
// Insert this timer callback into the owning thread's "timerCallbacks" queue.
void sInsertInTime(KplTimeCallback el)
{
KplTimeCallback cur, last = NULL;
Boolean reschedule = false;
KplTimeRecord now;
KplThread thread;
thread = (KplThread)el->owner;
KplTimeGetNow(&now);
if (1 == FskTimeCompare((FskTime)&el->trigger, (FskTime)&now))
el->trigger = now;
cur = (KplTimeCallback)FskListGetNext(thread->timerCallbacks, NULL);
el->next = NULL;
el->marked = false;
if (cur == NULL) {
FskListPrepend(&thread->timerCallbacks, el);
reschedule = true;
goto done;
}
while (cur) {
if (FskTimeCompare((FskTime)&el->trigger, (FskTime)&cur->trigger) > 0) {
if (last == NULL) {
reschedule = true;
}
FskListInsertAfter(&thread->timerCallbacks, el, last);
goto done;
}
last = cur;
cur = cur->next;
}
if (!cur && last) {
FskListAppend(&thread->timerCallbacks, el);
}
done:
if (reschedule)
rescheduleTimer(thread);
}
void KprHTTPClientIterate()
{
KprHTTPClient self = gKprHTTPClient;
KprHTTPConnection connection, candidate, available;
KprHTTPTarget target, next, other;
KprMessage message;
for (connection = FskListGetNext(self->connections, NULL); connection; connection = FskListGetNext(self->connections, connection)) {
target = connection->target;
if (target) {
message = connection->target->message;
if (!KprMessageContinue(message)) {
KprHTTPConnectionClose(connection);
KprHTTPClientResumeTarget(target);
}
}
}
target = FskListGetNext(self->targets, NULL);
while (target) {
next = FskListGetNext(self->targets, target);
message = target->message;
if (!KprMessageContinue(message)) {
FskListRemove(&self->targets, target);
KprHTTPClientResumeTarget(target);
}
target = next;
}
target = FskListGetNext(self->targets, NULL);
while (target) {
next = FskListGetNext(self->targets, target);
message = target->message;
candidate = NULL;
available = NULL;
for (connection = FskListGetNext(self->connections, NULL); connection; connection = FskListGetNext(self->connections, connection)) {
if (KprHTTPConnectionCandidate(connection, message)) {
candidate = connection;
break;
}
else if (KprHTTPConnectionAvailable(connection)) {
if (!available || (FskTimeCompare(&connection->time, &available->time) > 0)) // make the older connection the candidate for re-use
available = connection;
}
}
if (candidate) {
if (KprHTTPConnectionAvailable(candidate)) {
FskInstrumentedItemSendMessageDebug(candidate, kprInstrumentedHTTPConnectionCandidate, candidate->client);
}
else {
candidate = NULL;
}
}
else if (available) {
// before closing the available connection, try to find a message that can use it
for (other = FskListGetNext(self->targets, target); other; other = FskListGetNext(self->targets, other)) {
if (abs(other->message->priority) < abs(message->priority)) {
other = NULL;
break; // do not let a lower priority request get in ahead of a higher priority one
}
if (KprHTTPConnectionCandidate(available, other->message)) {
break;
}
}
if (other) {
FskInstrumentedItemSendMessageDebug(available, kprInstrumentedHTTPConnectionCandidate, available->client);
next = target;
target = other;
}
else
KprHTTPConnectionClose(available);
candidate = available;
}
else
break;
if (candidate) {
FskListRemove(&self->targets, target);
if (KprHTTPConnectionProcess(candidate, target)) {
// put back the message in the queue
KprHTTPClientAddTarget(target);
}
}
target = next;
}
}
