void KPR_shell_execute_async(KprShellExec exec)
{
#define BUFSIZE 4096
char buffer[BUFSIZE];
DWORD result = 0;
BOOL bSuccess = FALSE;
CloseHandle(exec->hWritePipe);
exec->hWritePipe = NULL;
for (;;) {
if (!ReadFile(exec->hReadPipe, buffer, BUFSIZE, &result, NULL) || (result == 0))
break;
buffer[result] = 0;
exec->usage++;
FskThreadPostCallback(KprShellGetThread(gShell), (FskThreadCallback)KPR_shell_execute_stderr, exec, FskStrDoCopy(buffer), NULL, NULL);
}
WaitForSingleObject(exec->pi.hProcess, INFINITE);
GetExitCodeProcess(exec->pi.hProcess, &result);
exec->status = (xsIntegerValue)result;
CloseHandle(exec->hReadPipe);
exec->hReadPipe = NULL;
CloseHandle(exec->pi.hProcess);
exec->pi.hProcess = NULL;
CloseHandle(exec->pi.hThread);
exec->pi.hThread = NULL;
FskThreadPostCallback(KprShellGetThread(gShell), (FskThreadCallback)KPR_shell_execute_callback, exec, NULL, NULL, NULL);
}
void KprHTTPClientResumeTarget(KprHTTPTarget target)
{
KprMessage message = target->message;
FskInstrumentedItemSendMessageDebug(target->message, kprInstrumentedMessageHTTPEnd, message)
KprHTTPTargetDispose(target);
FskThreadPostCallback(KprShellGetThread(gShell), (FskThreadCallback)KprMessageComplete, message, NULL, NULL, NULL);
}
FskErr KprSSDPClientSearch(KprSSDPClient self)
{
FskErr err = kFskErrNone;
FskThreadPostCallback(KprHTTPGetThread(), (FskThreadCallback)KprSSDPSearch, self, NULL, NULL, NULL);
//bail:
return err;
}
void flipThread(void *refcon)
{
KplScreen screen = refcon;
FskThread mainThread = FskThreadGetMain();
FskTimeRecord later;
SInt32 ms;
FskThreadInitializationComplete(FskThreadGetCurrent());
while (!gQuitting) {
//Save the last Flip time
FskTimeGetNow(&gKplScreen->lastFlipTime);
FskTimeCopy(&later, &gKplScreen->nextFlipTime);
FskTimeSub(&gKplScreen->lastFlipTime, &later);
ms = FskTimeInMS(&later);
if (ms > 0) {
FskDelay(ms);
MLOG("[%s] delay %d ms\n", threadName, ms);
}
// Kick off the next cycle
if (gKplScreen->drawingPumpEnabled) {
FskSemaphoreAcquire(screen->flipSemaphore);
gKplScreen->callbackPostedCount++;
FskThreadPostCallback(mainThread, drawingPumpCallback, (void*)gKplScreen->callbackPostedCount, NULL, NULL, NULL);
}
}
}
// ---------------------------------------------------------------------
void sNotifyInterfaceNotifiers(FskNetInterfaceRecord *iface, UInt32 status) {
FskNetInterfaceNotifier callback = NULL, next;
FskThread thread = FskThreadGetCurrent();
callback = (FskNetInterfaceNotifier)FskListMutexGetNext(interfaceChangeCBList, NULL);
while (callback) {
next = (FskNetInterfaceNotifier)FskListMutexGetNext(interfaceChangeCBList, callback);
#if 0 && SUPPORT_INSTRUMENTATION
if (FskInstrumentedItemHasListeners(callback)) {
FskNetInterfaceRecord *iface = (FskNetInterfaceRecord *)FskNetInterfaceFindByName(ifcName);
FskInterfaceInstrData data;
data.notf = callback;
data.ifc = iface;
data.status = status;
FskInstrumentedItemSendMessage(callback, kFskNetInstrMsgInterfaceNotify, &data);
}
#endif /* SUPPORT_INSTRUMENTATION */
if (callback->thread != thread) {
FskNetInterfaceRecord *interFace;
if (kFskErrNone == FskMemPtrNewFromData(sizeof(FskNetInterfaceRecord), iface, &interFace)) {
interFace->next = NULL;
interFace->name = FskStrDoCopy(iface->name);
// POST notify
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, " - posting callback to thread %s for interface %s", callback->thread->name, iface->name);
FskThreadPostCallback(callback->thread, doNetIfcCallback, (void*)callback->callback, (void*)interFace, (void*)status, (void*)callback->param);
}
}
else {
FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "callback->thread %s - call", callback->thread->name);
(callback->callback)(iface, status, callback->param);
}
callback = next;
}
}
void KprMessageCancel(KprMessage self)
{
KprService service = gServices;
FskInstrumentedItemSendMessageDebug(self, kprInstrumentedMessageCancel, self);
if (self->waiting) {
self->waiting = false;
if (self->request.target) {
if (self->request.dispose)
(*self->request.dispose)(self->request.target);
self->request.callback = NULL;
self->request.dispose = NULL;
self->request.target = NULL;
self->usage--; // request
}
while (service) {
if ((*service->accept)(service, self)) {
if (!service->thread)
service->thread = KprShellGetThread(gShell);
if (service == &gXKPRService)
self->usage++; // event queue
FskThreadPostCallback(service->thread, (FskThreadCallback)service->cancel, service, self, NULL, NULL);
break;
}
service = service->next;
}
}
}
FskErr KprMessageInvoke(KprMessage self, KprMessageCallbackProc callback, KprMessageDisposeProc dispose, void* target)
{
KprService service = gServices;
FskInstrumentedItemSendMessageDebug(self, kprInstrumentedMessageInvoke, self);
if (self->waiting)
return kFskErrOutOfSequence;
while (service) {
if ((*service->accept)(service, self)) {
self->waiting = true;
if (target) {
self->request.callback = callback;
self->request.dispose = dispose;
self->request.target = target;
self->usage++; // request
}
FskListAppend(&gShell->messages, self);
self->usage++; // message queue
if (!service->thread)
service->thread = KprShellGetThread(gShell);
if (service == &gXKPRService)
self->usage++; // event queue
FskThreadPostCallback(service->thread, (FskThreadCallback)service->invoke, service, self, NULL, NULL);
return kFskErrNone;
}
service = service->next;
}
return kFskErrUnimplemented;
}
FskErr KprSSDPClientStart(KprSSDPClient self)
{
FskErr err = kFskErrNone;
FskListAppend(&gKprSSDPClients, self);
FskThreadPostCallback(KprHTTPGetThread(), (FskThreadCallback)KprSSDPDiscover, self->type, self->services, KprSSDPClientCallback, self);
//bail:
return err;
}
FskErr KprSSDPClientStop(KprSSDPClient self)
{
FskErr err = kFskErrNone;
FskListRemove(&gKprSSDPClients, self);
FskThreadPostCallback(KprHTTPGetThread(), (FskThreadCallback)KprSSDPForget, self, NULL, NULL, NULL);
//bail:
return err;
}
FskErr KprSSDPClientRemove(KprSSDPClient self, const char* uuid)
{
FskErr err = kFskErrNone;
char* it = FskStrDoCopy(uuid);
bailIfNULL(it);
FskThreadPostCallback(KprHTTPGetThread(), (FskThreadCallback)KprSSDPRemoveDiscoveryByUUID, it, NULL, NULL, NULL);
bail:
return err;
}
void KprLibrarySessionRedirectCallback(KprMessage message, void* it)
{
FskHTTPServerRequest request = it;
KprLibrarySession session = FskHTTPServerRequestGetRefcon(request);
session->data.buffer = message->response.body;
session->data.size = message->response.size;
message->response.body = NULL;
message->response.size = 0;
FskThreadPostCallback(request->http->owner, (FskThreadCallback)FskHTTPServerRequestResume, request, NULL, NULL, NULL);
}
void KprServicesDiscover(KprContext context, char* id, char* services)
{
KprService service = gServices;
while (service) {
if (service->discover) {
if (!service->thread)
service->thread = KprShellGetThread(gShell);
if (services) {
if (FskStrStr(services, service->id))
FskThreadPostCallback(service->thread, (FskThreadCallback)service->discover, service, FskStrDoCopy(context->id), FskStrDoCopy(id), false);
else if (service->forget)
FskThreadPostCallback(service->thread, (FskThreadCallback)service->forget, service, FskStrDoCopy(context->id), FskStrDoCopy(id), NULL);
}
else
FskThreadPostCallback(service->thread, (FskThreadCallback)service->discover, service, FskStrDoCopy(context->id), FskStrDoCopy(id), (void*)true);
}
service = service->next;
}
}
jint JAVANAME(FskViewGL_unsetFskSurface)(JNIEnv* env, jobject viewObj) {
FskWindow fWin = FskWindowGetActive();
FskThread drawThread = fWin->thread;
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "[%p] FskViewGL_unsetFskSurface(%p, %p) calling ShutdownGLCallback()", (void*)pthread_self(), env, viewObj);
JAVANAME(FskView_unsetFskSurface)(env, viewObj);
FskThreadPostCallback(drawThread, ShutdownGLCallback, NULL, NULL, NULL, NULL);
return 1;
}
void KprServicesShare(KprContext context, Boolean shareIt, char* services)
{
KprService service = gServices;
while (service) {
if (service->share) {
if (!service->thread)
service->thread = KprShellGetThread(gShell);
FskThreadPostCallback(service->thread, (FskThreadCallback)service->share, service, FskStrDoCopy(context->id), services ? (FskStrStr(services, service->id) != NULL) : shareIt, services ? false : true);
}
service = service->next;
}
}
FskErr KprMessageNotify(KprMessage self)
{
FskErr err = kFskErrNone;
FskInstrumentedItemSendMessageDebug(self, kprInstrumentedMessageNotify, self);
if (!FskStrCompareWithLength(self->parts.scheme, "xkpr", self->parts.schemeLength)) {
self->usage++; // event queue
FskThreadPostCallback(KprShellGetThread(gShell), (FskThreadCallback)KprMessageNotifyCallback, gShell, self, NULL, NULL);
}
else
err = kFskErrUnimplemented;
return err;
}
void KprServicesForget(KprContext context, char* id)
{
KprService service = gServices;
while (service) {
if (service->forget) {
if (!service->thread)
service->thread = KprShellGetThread(gShell);
FskThreadPostCallback(service->thread, (FskThreadCallback)service->forget, service, FskStrDoCopy(context->id), FskStrDoCopy(id), NULL);
}
service = service->next;
}
}
jint JAVANAME(KinomaPlay_doPause)(JNIEnv* env, jclass clazz) {
FskErr err = kFskErrNone;
FskWindow fWin = FskWindowGetActive();
FskThread drawThread;
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "[%p] KinomaPlay_doPause(%p, %p, %p) calling ShutdownGLCallback()", (void*)pthread_self(), env, clazz, fWin);
BAIL_IF_NULL(fWin, err, kFskErrBadState);
drawThread = fWin->thread;
err = FskThreadPostCallback(drawThread, ShutdownGLCallback, NULL, NULL, NULL, NULL);
bail:
return !err;
}
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);
}
void KprMessageComplete(KprMessage self)
{
char* url;
FskThread thread = KprShellGetThread(gShell);
if (!thread) return; // @@ happens on exit
if (thread != FskThreadGetCurrent()) {
FskThreadPostCallback(thread, (FskThreadCallback)KprMessageComplete, self, NULL, NULL, NULL);
return;
}
FskInstrumentedItemSendMessageDebug(self, kprInstrumentedMessageComplete, self);
if (FskListRemove(&gShell->messages, self)) {
self->usage--; // message queue
self->waiting = false;
url = KprMessageGetResponseHeader(self, "location");
if (url && (!FskStrCompareWithLength(self->url, "xkpr", 4)) && ((!self->sniffing) || (!FskStrCompareWithLength(url, "xkpr", 4)))) {
FskMemPtrDispose(self->url);
self->url = FskStrDoCopy(url);
//bailIfNULL(self->url);
KprURLSplit(self->url, &self->parts);
FskAssociativeArrayDispose(self->response.headers);
self->response.headers = NULL;
FskMemPtrDispose(self->response.body);
self->response.body = NULL;
self->response.size = 0;
if (self->request.target)
self->usage--; // @@ request
if (kFskErrNone == KprMessageInvoke(self, self->request.callback, self->request.dispose, self->request.target))
return;
}
if (self->request.target) {
if (self->request.callback)
(*self->request.callback)(self, self->request.target);
if (self->request.dispose)
(*self->request.dispose)(self->request.target);
self->request.callback = NULL;
self->request.dispose = NULL;
self->request.target = NULL;
self->usage--; // request
}
if (!self->usage)
KprMessageDispose(self);
}
}
FskErr KplScreenSetContinuousDrawing(void *state, void *obj, UInt32 propertyID, FskMediaPropertyValue property)
{
Boolean on = property->value.b;
#if SUPPORT_FLIP_THREAD
if (on) {
if (!gKplScreen->drawingPumpEnabled) {
gKplScreen->drawingPumpEnabled = true;
FskTimeClear(&gKplScreen->lastUpdateTime);
FskTimeGetNow(&gKplScreen->lastFlipTime); // Just trying to get close, since we just turned on the pump and can't rely on the last flip time
FskTimeAddMS(&gKplScreen->lastFlipTime, FskTimeInMS(&gKplScreen->updateIntervalTime) >> 1);
FskInstrumentedTypePrintfNormal(&gKplScreenTypeInstrumentation, "START drawing pump **\n");
// Kick off the drawing pump
FskThreadPostCallback(FskThreadGetMain(), drawingPumpCallback, (void*)gKplScreen->callbackPostedCount, NULL, NULL, NULL);
}
}
void KprHTTPClientInvoke(KprService service UNUSED, KprMessage message)
{
FskErr err = kFskErrNone;
KprHTTPClient self = gKprHTTPClient;
if (KprMessageContinue(message)) {
KprHTTPTarget target = NULL;
KprHTTPCacheValue cached = NULL;
char* value;
FskInstrumentedItemSendMessageDebug(message, kprInstrumentedMessageHTTPBegin, message)
bailIfError(KprHTTPTargetNew(&target, message));
if (!message->method || !FskStrCompare(message->method, "GET"))
KprHTTPCacheFetch(self->cache, message->url, &cached);
if (cached) {
if (KprHTTPCacheValueIsFresh(cached)) {
if (KprHTTPClientReadCache(message, cached) == kFskErrNone) {
KprMessageTransform(message, gHTTPService.machine);
KprHTTPClientResumeTarget(target);
return;
}
}
else {
value = FskAssociativeArrayElementGetString(cached->headers, kprHTTPHeaderLastModified);
if (value)
(void)KprMessageSetRequestHeader(message, kprHTTPHeaderIfModifiedSince, value);
value = FskAssociativeArrayElementGetString(cached->headers, kprHTTPHeaderETag);
if (value)
(void)KprMessageSetRequestHeader(message, kprHTTPHeaderIfNoneMatch, value);
target->cached = cached;
}
}
KprHTTPClientCookiesGet(message->url, &value);
if (value) {
(void)KprMessageSetRequestHeader(message, kprHTTPHeaderCookie, value);
FskMemPtrDispose(value);
}
KprHTTPClientAddTarget(target);
return;
bail:
message->error = err;
}
FskThreadPostCallback(KprShellGetThread(gShell), (FskThreadCallback)KprMessageComplete, message, NULL, NULL, NULL);
}
FskErr KplScreenSetContinuousDrawing(void *state, void *obj, UInt32 propertyID, FskMediaPropertyValue property)
{
Boolean on = property->value.b;
if (on) {
if (!gKplScreen->drawingPumpEnabled) {
gKplScreen->drawingPumpEnabled = true;
MLOG("[%s] ** Pi START drawing pump **\n", threadName);
FskThreadPostCallback(FskThreadGetMain(), drawingPumpCallback, (void*)gKplScreen->callbackPostedCount, NULL, NULL, NULL);
}
}
else {
if (gKplScreen->drawingPumpEnabled) {
gKplScreen->drawingPumpEnabled = false;
MLOG("[%s] ** Pi STOP drawing pump **\n", threadName);
}
}
return kFskErrNone;
}
static void gpioPoller(FskTimeCallBack callback, const FskTime time, void *param)
{
FskGPIO walker;
FskThread thread = FskThreadGetCurrent();
for (walker = gGPIOPollers; NULL != walker; walker = walker->next) {
int value = FskGPIOPlatformRead(walker);
if (value == walker->pollerValue)
continue;
walker->pollerValue = value;
if (thread == walker->thread)
KprPinsPollerRun(walker->poller);
else
FskThreadPostCallback(walker->thread, gpioPollerThreadCallback, walker, NULL, NULL, NULL);
}
FskTimeCallbackScheduleFuture(gGPIOPoller, 0, 33, gpioPoller, NULL);
}
void flushNowCallback(FskTimeCallBack callback, const FskTime time, void *param) {
FskAudioOut audioOut = (FskAudioOut)param;
androidAudioExt *ext = (androidAudioExt*)audioOut->ext;
Boolean isValid = false;
FskAudioNativePrintfDebug("flushNowCallback");
androidAudioOutIsValid(audioOut, &isValid);
if (!isValid || audioOut->thread == NULL) {
FskAudioNativePrintfVerbose("flushNowCallback - isValid? (%s) - audioOut->thread (%x) - bail", isValid ? "yes" : "no", audioOut->thread);
return;
}
// removeFromQueue(audioOut, kUsed);
if (FskThreadGetCurrent() == audioOut->thread)
flushAndRefill(audioOut, NULL, NULL, NULL);
else
FskThreadPostCallback(audioOut->thread, flushAndRefill, audioOut, NULL, NULL, NULL);
if (audioOut->playing)
FskTimeCallbackScheduleFuture(ext->flushTimer, 0, kFlushAndRefillTime, flushNowCallback, audioOut);
}
jint JAVANAME(KinomaPlay_doResume)(JNIEnv* env, jclass clazz) {
FskErr err = kFskErrNone;
FskWindow fWin = FskWindowGetActive();
FskThread drawThread;
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation,"[%p] KinomaPlay_doResume(%p, %p, %p)", (void*)pthread_self(), env, clazz, fWin);
BAIL_IF_NULL(fWin, err, kFskErrBadState);
drawThread = fWin->thread;
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "KinomaPlay_doResume: drawThread is %p %s", drawThread, drawThread ? "" : ", bailing");
BAIL_IF_NULL(drawThread, err, kFskErrBadState);
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "KinomaPlay_doResume calling InitGLCallback");
FskMutexAcquire(jniRespMutex);
err = FskThreadPostCallback(drawThread, InitGLCallback, theNativeWindow, NULL, NULL, NULL);
if (!gQuitting) {
FskConditionWait(jniRespCond, jniRespMutex);
FskMutexRelease(jniRespMutex);
}
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "KinomaPlay_doResume: FskThreadPostCallback(InitGLCallback) returns %d", err);
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "[%p] KinomaPlay_doResume successful", (void*)pthread_self());
bail:
return !err;
}
void fxQueuePromiseJobs(txMachine* the)
{
FskThread thread = FskThreadGetCurrent();
FskThreadPostCallback(thread, (FskThreadCallback)fxPerformPromiseJobs, the, NULL, NULL, NULL);
}
void KPR_shell_execute(xsMachine* the)
{
xsStringValue application = NULL;
xsStringValue command = NULL;
xsStringValue directory = NULL;
xsStringValue environment = NULL;
xsStringValue string;
xsIntegerValue length;
KprShellExec exec = NULL;
STARTUPINFO si;
SECURITY_ATTRIBUTES sa;
xsVars(5);
xsTry {
application = getenv("COMSPEC");
if (!application)
xsThrowIfFskErr(kFskErrOperationFailed);
string = xsToString(xsArg(0));
length = FskStrLen(string) + 1;
xsThrowIfFskErr(FskMemPtrNew(3 + length, &command));
memcpy(command, "/c ", 3);
memcpy(command + 3, string, length);
if (xsFindString(xsArg(1), xsID_directory, &string)) {
length = FskStrLen(string) + 1;
xsThrowIfFskErr(FskMemPtrNew(length, &directory));
memcpy(directory, string, length);
}
if (xsFindResult(xsArg(1), xsID_environment)) {
xsIntegerValue total = 0, length;
xsVar(1) = xsEnumerate(xsResult);
for (;;) {
xsVar(2) = xsCall0(xsVar(1), xsID("next"));
xsVar(3) = xsGet(xsVar(2), xsID("done"));
if (xsTest(xsVar(3)))
break;
xsVar(3) = xsGet(xsVar(2), xsID("value"));
xsVar(4) = xsGetAt(xsResult, xsVar(3));
total += FskStrLen(xsToString(xsVar(3)));
total++;
total += FskStrLen(xsToString(xsVar(4)));
total++;
}
total++;
xsThrowIfFskErr(FskMemPtrNew(total, &environment));
total = 0;
xsVar(1) = xsEnumerate(xsResult);
for (;;) {
xsVar(2) = xsCall0(xsVar(1), xsID("next"));
xsVar(3) = xsGet(xsVar(2), xsID("done"));
if (xsTest(xsVar(3)))
break;
xsVar(3) = xsGet(xsVar(2), xsID("value"));
xsVar(4) = xsGetAt(xsResult, xsVar(3));
string = xsToString(xsVar(3));
length = FskStrLen(string);
memcpy(environment + total, string, length);
total += length;
environment[total++] = '=';
string = xsToString(xsVar(4));
length = FskStrLen(string);
memcpy(environment + total, string, length);
total += length;
environment[total++] = 0;
}
environment[total++] = 0;
}
xsThrowIfFskErr(FskMemPtrNewClear(sizeof(KprShellExecRecord), &exec));
xsVar(0) = xsNewHostObject(KPR_shell_execute_destructor);
exec->the = the;
exec->slot = xsVar(0);
xsSetHostData(xsVar(0), exec);
xsResult = xsNewHostFunction(KPR_shell_execute_cancel, 0);
xsNewHostProperty(xsVar(0), xsID_cancel, xsResult, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
if (xsFindResult(xsArg(1), xsID_callback)) {
xsNewHostProperty(xsVar(0), xsID_callback, xsResult, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
else {
xsNewHostProperty(xsVar(0), xsID_callback, xsNull, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
if (xsFindResult(xsArg(1), xsID_stderr)) {
xsNewHostProperty(xsVar(0), xsID_stderr, xsResult, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
else {
xsNewHostProperty(xsVar(0), xsID_stderr, xsNull, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
if (xsFindResult(xsArg(1), xsID_stdout)) {
xsNewHostProperty(xsVar(0), xsID_stdout, xsResult, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
else {
xsNewHostProperty(xsVar(0), xsID_stdout, xsNull, xsDefault, xsDontDelete | xsDontEnum | xsDontSet);
}
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
if (!CreatePipe(&(exec->hReadPipe), &(exec->hWritePipe), &sa, 0))
xsThrowIfFskErr(kFskErrOperationFailed);
if (!SetHandleInformation(exec->hReadPipe, HANDLE_FLAG_INHERIT, 0))
xsThrowIfFskErr(kFskErrOperationFailed);
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(STARTUPINFO);
si.hStdError = exec->hWritePipe;
si.hStdOutput = exec->hWritePipe;
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
si.dwFlags = STARTF_USESTDHANDLES;
if (!CreateProcess(application, command, NULL, NULL, TRUE, CREATE_NO_WINDOW, environment, directory, &si, &(exec->pi)))
xsThrowIfFskErr(kFskErrOperationFailed);
xsRemember(exec->slot);
exec->usage++;
FskThreadPostCallback(KprHTTPGetThread(), (FskThreadCallback)KPR_shell_execute_async, exec, NULL, NULL, NULL);
FskMemPtrDispose(environment);
FskMemPtrDispose(directory);
FskMemPtrDispose(command);
}
xsCatch {
if (exec) {
if (exec->pi.hProcess)
CloseHandle(exec->pi.hProcess);
if (exec->pi.hThread)
CloseHandle(exec->pi.hThread);
if (exec->hWritePipe)
CloseHandle(exec->hWritePipe);
if (exec->hReadPipe)
CloseHandle(exec->hReadPipe);
FskMemPtrDispose(exec);
}
FskMemPtrDispose(environment);
FskMemPtrDispose(directory);
FskMemPtrDispose(command);
xsThrow(xsException);
}
}
jint JAVANAME(FskViewGL_setFskSurface)(JNIEnv* env, jobject viewObj, jobject surfaceObj) {
FskWindow fWin = FskWindowGetActive();
FskErr err = kFskErrNone;
FskErr retErr;
FskThread drawThread;
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "[%p] FskViewGL_setFskSurface(%p, %p, %p)", (void*)pthread_self(), env, viewObj, surfaceObj);
ANativeWindow *nw = theNativeWindow;
theNativeWindow = ANativeWindow_fromSurface(env, surfaceObj);
fbGlobals->surface = theNativeWindow;
if (theNativeWindow && theNativeWindow == nw) {
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, " native window surface is same as before - don't setFskSurface twice\n");
return 0;
}
FskGLSetNativeWindow((void*)theNativeWindow);
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "FskViewGL_setFskSurface: active window is %p%s", fWin, fWin ? "" : ", bailing");
BAIL_IF_NULL(fWin, err, kFskErrBadState);
drawThread = fWin->thread;
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "FskViewGL_setFskSurface: drawThread is %p %s", drawThread, drawThread ? "" : ", bailing");
BAIL_IF_NULL(drawThread, err, kFskErrBadState);
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "FskViewGL_setFskSurface calling InitGLCallback");
/* MDK - we need to wait for the callback to complete it's action in the other thread before we continue. I'm doing this by means of the jniRespCond.
* However, at startup, we don't have the target thread to do it's work yet, so allow this through once at initialization.
*/
static int pass = 0;
if (pass != 0)
FskMutexAcquire(jniRespMutex);
FskInstrumentedTypePrintfVerbose(&gAndroidMainBlockTypeInstrumentation, " about to post callback and wait for response from InitGLCallback\n");
err = FskThreadPostCallback(drawThread, InitGLCallback, theNativeWindow, NULL, NULL, NULL);
if (pass++ != 0) {
if (!gQuitting) {
FskConditionWait(jniRespCond, jniRespMutex);
FskMutexRelease(jniRespMutex);
}
}
else
usleep(500);
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "FskViewGL_setFskSurface: FskThreadPostCallback(InitGLCallback) returns %d", err);
gScreenWidth = fbGlobals->frameBuffer->bounds.width;
gScreenHeight = fbGlobals->frameBuffer->bounds.height;
if (fWin) {
FskRectangleRecord b;
FskPortGetBounds(fWin->port, &b);
FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, " - gl invalidating port bounds %d %d %d %d\n", b.x, b.y, b.width, b.height);
FskPortInvalidateRectangle(fWin->port, &b);
}
bail:
return !err;
}
void KprWebSocketEndpointInvokeAfter(void *func, void *param1, void *param2, void *param3, void *param4)
{
FskThreadPostCallback(KprShellGetThread(gShell), (FskThreadCallback)func, param1, param2, param3, param4);
}
void KprMQTTInvokeAfter(void *func, void *param1, void *param2, void *param3, void *param4)
{
FskThreadPostCallback(KprShellGetThread(gShell), (FskThreadCallback)func, param1, param2, param3, param4);
}
