void fxWriteBreakpoints(txMachine* the)
{
char *breakpoints;
FskFile fref = NULL;
txSlot *aBreakpoint = NULL;
FskInt64 size = 0;
FskECMAScriptGetDebug(NULL, &breakpoints, NULL);
if ((NULL == breakpoints) || (0 == *breakpoints)) goto bail;
FskFileCreate(breakpoints);
if (kFskErrNone != FskFileOpen(breakpoints, kFskFilePermissionReadWrite, &fref))
goto bail;
if (kFskErrNone != FskFileSetSize(fref, &size))
goto bail;
while (true) {
char aPath[1024], aLine[32];
aBreakpoint = fxGetNextBreakpoint(the, aBreakpoint, aPath, aLine);
if (NULL == aBreakpoint)
break;
FskFileWrite(fref, FskStrLen(aPath), (void *)aPath, NULL);
FskFileWrite(fref, 1, (void *)"\t", NULL);
FskFileWrite(fref, FskStrLen(aLine), (void *)aLine, NULL);
FskFileWrite(fref, 1, (void *)"\n", NULL);
}
bail:
FskFileClose(fref);
}
FskErr FskCopyFile(char *src, char *dst) {
char buf[4096];
UInt32 amt, amtWrt;
int doit=0;
FskFileInfo info, infoSrc;
FskFile srcFref = NULL, dstFref = NULL;
FskErr err = kFskErrNone;
if (kFskErrFileNotFound == FskFileGetFileInfo(dst, &info)) {
FskAndroidFilesPrintfDebug("dst: %s not found\n", dst);
doit = 1;
}
else if (kFskErrNone == FskFileGetFileInfo(src, &infoSrc)) {
if (infoSrc.filesize != info.filesize) {
FskAndroidFilesPrintfDebug("src size: %d, dstSize: %d\n", infoSrc.filesize, info.filesize);
doit = 1;
}
}
if (doit) {
FskAndroidFilesPrintfDebug("Need to copy it over.\n");
err = FskFileOpen(src, kFskFilePermissionReadOnly, &srcFref);
BAIL_IF_ERR(err);
err = FskFileCreate(dst);
BAIL_IF_ERR(err);
err = FskFileOpen(dst, kFskFilePermissionReadWrite, &dstFref);
BAIL_IF_ERR(err);
while (kFskErrNone == err) {
err = FskFileRead(srcFref, 4096, buf, &amt);
BAIL_IF_ERR(err);
if (0 >= amt)
break;
while (amt) {
err = FskFileWrite(dstFref, amt, buf, &amtWrt);
BAIL_IF_ERR(err);
amt -= amtWrt;
}
}
err = FskFileClose(dstFref);
BAIL_IF_ERR(err);
dstFref = NULL;
err = FskFileClose(srcFref);
BAIL_IF_ERR(err);
srcFref = NULL;
}
bail:
if(kFskErrEndOfFile == err){
err = kFskErrNone;
}
if(dstFref)
FskFileClose(dstFref);
if(srcFref)
FskFileClose(srcFref);
return err;
}
void unpackAndroid() {
char * src, *dst, buf[4096];
int doit=0;
UInt32 amt, amtWrt;
FskFileInfo info, infoSrc;
FskFile srcFref, dstFref;
FskErr err;
dst = FskStrDoCat(gAndroidCallbacks->getStaticDataDirCB(), "ca-bundle.crt");
src = FskStrDoCat(gAndroidCallbacks->getStaticAppDirCB(), "/res/raw/kinoma.jet/ca-bundle.crt");
if (kFskErrFileNotFound == FskFileGetFileInfo(dst, &info)) {
fprintf(stderr, "dst: %s not found\n", dst);
doit = 1;
}
else if (kFskErrNone == FskFileGetFileInfo(src, &infoSrc)) {
if (infoSrc.filesize != info.filesize) {
fprintf(stderr, "src size: %lld, dstSize: %lld\n", infoSrc.filesize, info.filesize);
doit = 1;
}
}
if (doit) {
fprintf(stderr, "Need to copy it over.\n");
err = FskFileOpen(src, kFskFilePermissionReadOnly, &srcFref);
if (err) fprintf(stderr, "open %s failed %d\n", src, err);
err = FskFileCreate(dst);
if (err) fprintf(stderr, "create %s failed %d\n", dst, err);
err = FskFileOpen(dst, kFskFilePermissionReadWrite, &dstFref);
if (err) fprintf(stderr, "open %s failed %d\n", dst, err);
while (kFskErrNone == err) {
err = FskFileRead(srcFref, 4096, buf, &amt);
if (err) fprintf(stderr, "read %s (%lu bytes) failed %d\n", src, amt, err);
if (0 >= amt)
break;
while (amt) {
err = FskFileWrite(dstFref, amt, buf, &amtWrt);
if (err) fprintf(stderr, "write %s (%lu bytes) failed %d\n", dst, amt, err);
amt -= amtWrt;
}
}
err = FskFileClose(dstFref);
if (err) fprintf(stderr, "close %s failed %d\n", src, err);
err = FskFileClose(srcFref);
if (err) fprintf(stderr, "close %s failed %d\n", src, err);
}
FskMemPtrDispose(src);
FskMemPtrDispose(dst);
}
void KPR_system_set_backGesture(xsMachine *the)
{
FskErr err = kFskErrNone;
char* path = NULL;
char* pathName = NULL;
FskFile file = NULL;
char* data = xsToString(xsArg(0));
xsIntegerValue size = FskStrLen(data);
#if MINITV
pathName = TOUCHD_CONF;
// system("/etc/init.d/touchd.sh stop");
#else
bailIfError(FskDirectoryGetSpecialPath(kFskDirectorySpecialTypeApplicationPreference, true, NULL, &path));
pathName = FskStrDoCat(path, "touchd.conf");
bailIfNULL(pathName);
#endif
err = FskFileOpen(pathName, kFskFilePermissionReadWrite, &file);
if (kFskErrFileNotFound == err) {
bailIfError(FskFileCreate(pathName));
err = FskFileOpen(pathName, kFskFilePermissionReadWrite, &file);
}
else {
FskInt64 zero = 0;
err = FskFileSetSize(file, &zero);
}
bailIfError(err);
bailIfError(FskFileWrite(file, size, data, NULL));
bail:
FskFileClose(file);
#if MINITV
int pipe = open(TOUCH_PIPE, O_WRONLY | O_NONBLOCK);
if (pipe >= 0) {
char data = 1;
write(pipe, &data, 1);
close(pipe);
}
// system("/etc/init.d/touchd.sh start");
#endif
if (path) {
FskMemPtrDispose(path);
FskMemPtrDispose(pathName);
}
xsThrowIfFskErr(err);
}
FskErr FskTextFreeTypeInstallFonts(char* fontsPath, char* defaultFont)
{
FskErr err = kFskErrNone;
FskTextEngine fte;
char *fromDirectory = NULL;
char* fromPath = NULL;
FskDirectoryIterator iterator = NULL;
char *name = NULL;
UInt32 type;
#if TARGET_OS_ANDROID
char *toDirectory = NULL;
char* toPath = NULL;
FskFileInfo itemInfo;
FskFileMapping map = NULL;
unsigned char *data;
FskInt64 dataSize;
FskFile file = NULL;
#endif
err = FskTextEngineNew(&fte, NULL);
if (err) goto bail;
fromDirectory = FskEnvironmentDoApply(FskStrDoCopy(fontsPath));
if (!fromDirectory) { err = kFskErrMemFull; goto bail; }
#if TARGET_OS_ANDROID
if (!FskStrCompareWithLength(fromDirectory, "/data/app/", 10)) {
err = FskDirectoryGetSpecialPath(kFskDirectorySpecialTypeApplicationPreference, false, NULL, &toDirectory);
if (err) goto bail;
}
#endif
err = FskDirectoryIteratorNew(fromDirectory, &iterator, 0);
if (err) goto bail;
while (kFskErrNone == FskDirectoryIteratorGetNext(iterator, &name, &type)) {
if (type == kFskDirectoryItemIsFile) {
fromPath = FskStrDoCat(fromDirectory, name);
if (!fromPath) { err = kFskErrMemFull; goto bail; }
FskDebugStr("from %s", fromPath);
#if TARGET_OS_ANDROID
if (toDirectory) {
toPath = FskStrDoCat(toDirectory, name);
FskDebugStr("to %s", toPath);
if (kFskErrNone != FskFileGetFileInfo(toPath, &itemInfo)) {
err = FskFileMap(fromPath, &data, &dataSize, 0, &map);
if (err) goto bail;
err = FskFileCreate(toPath);
if (err) goto bail;
err = FskFileOpen(toPath, kFskFilePermissionReadWrite, &file);
if (err) goto bail;
err = FskFileWrite(file, dataSize, data, NULL);
if (err) goto bail;
FskFileClose(file);
file = NULL;
FskFileDisposeMap(map);
map = NULL;
}
FskDebugStr("add %s", toPath);
FskTextAddFontFile(fte, toPath);
FskMemPtrDisposeAt(&toPath);
}
else
#endif
FskTextAddFontFile(fte, fromPath);
FskMemPtrDisposeAt(&fromPath);
}
FskMemPtrDisposeAt(&name);
}
#if TARGET_OS_ANDROID
if (gAndroidCallbacks->getModelInfoCB) {
char* osVersion;
gAndroidCallbacks->getModelInfoCB(NULL, &osVersion, NULL, NULL, NULL);
if ((FskStrStr(osVersion, "android.5") == osVersion) // for KPR applications
|| (FskStrStr(osVersion, "5.") == osVersion)) { // for tests
BAIL_IF_ERR(err = FskFTAddMapping("/system/etc/fonts.xml"));
}
if ((FskStrStr(osVersion, "android.4") == osVersion) // for KPR applications
|| (FskStrStr(osVersion, "4.") == osVersion)) { // for tests
BAIL_IF_ERR(err = FskFTAddMapping("/system/etc/system_fonts.xml"));
err = FskFTAddMapping("/vendor/etc/fallback_fonts.xml");
if (err != kFskErrFileNotFound) BAIL(err);
BAIL_IF_ERR(err = FskFTAddMapping("/system/etc/fallback_fonts.xml"));
}
else {
defaultFont = "Droid Sans";
BAIL_IF_ERR(err = FskFTAddMapping(NULL));
}
}
#endif
if (defaultFont)
FskTextDefaultFontSet(fte, defaultFont);
bail:
#if TARGET_OS_ANDROID
if (file)
FskFileClose(file);
if (map)
FskFileDisposeMap(map);
FskMemPtrDispose(toPath);
FskMemPtrDispose(toDirectory);
#endif
FskMemPtrDispose(name);
FskDirectoryIteratorDispose(iterator);
FskMemPtrDispose(fromPath);
FskMemPtrDispose(fromDirectory);
FskTextEngineDispose(fte);
return err;
}
FskErr mp3ReaderExtract(FskMediaReader reader, void *readerState, FskMediaReaderTrack *track, UInt32 *infoCount, FskMediaReaderSampleInfo *info, unsigned char **dataOut)
{
mp3Reader state = readerState;
FskErr err = kFskErrNone;
UInt32 spaceInOutput;
unsigned char *data;
FskMediaReaderSampleInfo lastInfo = NULL;
UInt32 infoCountFree;
#if SUPPORT_MP3_LOG_TO_FILE
UInt32 outputSize;
#endif
spaceInOutput = (state->mi.bitrate * 128) / 2; // about half a second
if (spaceInOutput < 4096)
spaceInOutput = 4096;
#if SUPPORT_MP3_LOG_TO_FILE
outputSize = spaceInOutput;
#endif
*track = &state->track;
*infoCount = 0;
*info = NULL;
infoCountFree = state->mi.frequency >> 11; // quick divide by 2048... allocate enough entries for about half a second of frames
err = FskMemPtrNew(infoCountFree * sizeof(FskMediaReaderSampleInfoRecord), (FskMemPtr*)(void*)info);
if (err) return err;
err = FskMemPtrNew(spaceInOutput + kFskDecompressorSlop, (FskMemPtr *)&data);
if (err) {
FskMemPtrDisposeAt((void **)info);
return err;
}
*dataOut = data;
while (0 != infoCountFree) {
if (state->hasEndTime && (state->atTime >= state->endTime)) {
if (0 == *infoCount )
err = kFskErrEndOfFile;
goto bail;
}
if ((state->readBufferEnd - state->readBufferPtr) < 6) {
err = mp3RefillReadBuffer(state, 6);
if (err) goto bail;
}
if ((0xff == state->readBufferPtr[0]) && (0xe0 == (state->readBufferPtr[1] & 0xe0))) {
DIDLMusicItemRecord mi;
mi.doExtendedParsing = 0;
if (true == (state->doHeaderParse)(state->readBufferPtr, &mi)) {
if (spaceInOutput < mi.frameLength)
goto bail;
if ((state->readBufferEnd - state->readBufferPtr) < (SInt32)mi.frameLength) {
err = mp3RefillReadBuffer(state, mi.frameLength);
if (err) goto bail;
}
// When starting from a new location, make extra sure we're really sitting on a valid frame,
// by validating the next frame.
if (state->resync) {
if (state->readBufferEnd - (state->readBufferPtr + mi.frameLength) > 6) {
DIDLMusicItemRecord mi2;
UInt8 *nextFramePtr = state->readBufferPtr + mi.frameLength;
if ((0xff != nextFramePtr[0]) || (0xe0 != (nextFramePtr[1] & 0xe0))) {
state->readBufferPtr += 1;
continue;
}
mi2.doExtendedParsing = 0;
if (false == (state->doHeaderParse)(nextFramePtr, &mi2)) {
state->readBufferPtr += 1;
continue;
}
}
state->resync = false;
}
if (kFskAudioFormatAACADTS == mi.codec) { // skip adts header to get to raw aac frame. @@ if frame Count != 1 this isn't going to work
mi.frameLength -= 7;
state->readBufferPtr += 7;
}
if ((NULL != lastInfo) && (lastInfo->sampleDuration = mi.samplesPerFrame) && (lastInfo->sampleSize == mi.frameLength))
lastInfo->samples += 1;
else {
lastInfo = &(*info)[*infoCount];
*infoCount += 1;
infoCountFree -= 1;
FskMemSet(lastInfo, 0, sizeof(FskMediaReaderSampleInfoRecord));
lastInfo->samples = 1;
lastInfo->sampleSize = mi.frameLength;
lastInfo->flags = kFskImageFrameTypeSync;
lastInfo->decodeTime = state->atTime;
lastInfo->sampleDuration = mi.samplesPerFrame;
lastInfo->compositionTime = -1;
}
FskMemMove(data, state->readBufferPtr, mi.frameLength);
data += mi.frameLength;
state->readBufferPtr += mi.frameLength;
spaceInOutput -= mi.frameLength;
state->atTime += mi.samplesPerFrame;
continue;
}
}
state->readBufferPtr += 1;
state->resync = true;
}
bail:
if (kFskErrNone != err) {
if ((kFskErrNeedMoreTime == err) || (kFskErrEndOfFile == err)) {
if (0 != *infoCount)
err = kFskErrNone;
}
if (kFskErrNone != err) {
FskMemPtrDisposeAt((void **)info);
FskMemPtrDisposeAt((void **)dataOut);
*infoCount = 0;
}
}
#if SUPPORT_MP3_LOG_TO_FILE
if (kFskErrNone == err) {
if (NULL == gFref) {
FskFileDelete("c:/dump.mp3");
FskFileCreate("c:/dump.mp3");
FskFileOpen("c:/dump.mp3", kFskFilePermissionReadWrite, &gFref);
}
FskFileWrite(gFref, outputSize - spaceInOutput, *dataOut, NULL);
}
#endif
return err;
}
void fxWriteProfileFile(txMachine* the, void* theBuffer, txInteger theSize)
{
if (the->profileFile)
FskFileWrite(the->profileFile, theSize, theBuffer, NULL);
}
void fxWriteAddressAutomatic(txMachine* the)
{
/* write debugAddress and debugAutomatic to a file... */
#if TARGET_OS_ANDROID
char *folder = NULL;
char *file = FskStrDoCat(folder, "/sdcard/debug.txt");
{
#else
char *folder;
if (kFskErrNone == FskDirectoryGetSpecialPath(kFskDirectorySpecialTypeApplicationPreference, true, NULL, &folder)) {
char *file = FskStrDoCat(folder, "debug.txt");
#endif
FskFile fref;
FskFileDelete(file);
FskFileCreate(file);
if (kFskErrNone == FskFileOpen(file, kFskFilePermissionReadWrite, &fref)) {
char *data = FskStrDoCat(debugAddress, debugAutomatic ? "\n1\n" : "\n0\n");
if (data) {
FskFileWrite(fref, FskStrLen(data), data, NULL);
FskFileClose(fref);
FskMemPtrDispose(data);
}
}
}
}
#endif /* !KPR_CONFIG */
void fxReadBreakpoints(txMachine* the)
{
char *breakpoints;
FskMemPtr file = NULL;
FskInt64 fileSize;
char *p;
FskECMAScriptGetDebug(NULL, &breakpoints, NULL);
if ((NULL == breakpoints) || (0 == *breakpoints)) goto bail;
if (kFskErrNone != FskFileLoad(breakpoints, &file, &fileSize))
goto bail;
p = (char *)file;
while (true) {
char *path = p;
char *line = FskStrChr(p, '\t');
char *cr;
if (NULL == line)
break;
cr = FskStrChr(line, '\n');
if (NULL == cr)
break;
*line++ = 0;
*cr = 0;
fxSetBreakpoint(the, path, line);
p = cr + 1;
}
bail:
FskMemPtrDispose(file);
}
char *FskUUIDGetForKey(const char *key)
{
char *uuidStr;
FskUUIDRecord uuid;
char *uuidCachePath = NULL, *prefFolder;
FskFile fref;
if (kFskErrNone == FskDirectoryGetSpecialPath(kFskDirectorySpecialTypeApplicationPreference, true, NULL, &prefFolder)) {
uuidCachePath = FskStrDoCat(prefFolder, "fskuuidcache.txt");
FskMemPtrDispose(prefFolder);
}
// load the cache
if (NULL == gUUIDCache) {
char *uuidCache;
FskInt64 cacheSize;
gUUIDCache = FskAssociativeArrayNew();
if ((NULL != uuidCachePath) && (kFskErrNone == FskFileLoad(uuidCachePath, (unsigned char **)(void *)&uuidCache, &cacheSize))) {
char *p = uuidCache;
while (true) {
char *uuid = p;
char *mykey = FskStrChr(p, '\t');
char *cr;
if (NULL == mykey)
break;
cr = FskStrChr(mykey, '\n');
if (NULL == cr)
break;
*mykey++ = 0;
*cr = 0;
FskAssociativeArrayElementSetString(gUUIDCache, mykey, uuid);
p = cr + 1;
}
FskMemPtrDispose(uuidCache);
}
}
// check the cache
uuidStr = FskAssociativeArrayElementGetString(gUUIDCache, key);
if (uuidStr) {
FskMemPtrDispose(uuidCachePath);
return uuidStr;
}
// not in cache
FskUUIDCreate(&uuid);
uuidStr = FskUUIDtoString_844412(&uuid);
FskAssociativeArrayElementSetString(gUUIDCache, key, uuidStr);
FskMemPtrDispose(uuidStr);
// flush cache
FskFileDelete(uuidCachePath);
FskFileCreate(uuidCachePath);
if (kFskErrNone == FskFileOpen(uuidCachePath, kFskFilePermissionReadWrite, &fref)) {
FskAssociativeArrayIterator iterate = FskAssociativeArrayIteratorNew(gUUIDCache);
char tab = '\t', cr = '\n';
while (iterate) {
FskFileWrite(fref, FskStrLen(iterate->value), iterate->value, NULL);
FskFileWrite(fref, 1, &tab, NULL);
FskFileWrite(fref, FskStrLen(iterate->name), iterate->name, NULL);
FskFileWrite(fref, 1, &cr, NULL);
iterate = FskAssociativeArrayIteratorNext(iterate);
}
FskFileClose(fref);
}
FskMemPtrDispose(uuidCachePath);
return FskAssociativeArrayElementGetString(gUUIDCache, key); // caller doesn't have to dispose
}