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;
}
xsBooleanValue fxFindFile(xsMachine* the, xsStringValue path)
{
FskFileInfo fileInfo;
if (kFskErrNone == FskFileGetFileInfo(path, &fileInfo))
return 1;
return 0;
}
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 on_drag_data_received(GtkWidget* widget, GdkDragContext* context, gint x, gint y, GtkSelectionData *data, guint info, guint time, gpointer user_data)
{
FskGtkWindow gtkWin = user_data;
gboolean dnd_success = FALSE;
FskDragDropFile dropFileList = NULL;
FskDragDropFile droppedFile = NULL;
char* path = NULL;
if (gdk_drag_context_get_suggested_action(context) == GDK_ACTION_COPY) {
char* string = (char*)gtk_selection_data_get_data(data);
char* end;
FskFileInfo itemInfo;
for (end = FskStrStr(string, "\r\n"); end; end = FskStrStr(string, "\r\n")) {
BAIL_IF_ERR(FskMemPtrNewClear(sizeof(FskDragDropFileRecord), (FskMemPtr*)&droppedFile));
FskListAppend((FskList *)&dropFileList, droppedFile);
*end = 0;
BAIL_IF_ERR(KprURLToPath(string, &path));
BAIL_IF_ERR(FskFileGetFileInfo(path, &itemInfo));
if (itemInfo.filetype == kFskDirectoryItemIsDirectory) {
int length = FskStrLen(path);
BAIL_IF_ERR(FskMemPtrNew(length + 2, &droppedFile->fullPathName));
FskMemCopy(droppedFile->fullPathName, path, length);
droppedFile->fullPathName[length] = '/';
droppedFile->fullPathName[length + 1] = 0;
FskMemPtrDispose(path);
}
else {
droppedFile->fullPathName = path;
}
path = NULL;
string = end + 2;
*end = '\r';
}
(*gDropTargetProc)(kFskDragDropTargetEnterWindow, x, y, dropFileList, gtkWin->owner);
(*gDropTargetProc)(kFskDragDropTargetDropInWindow, x, y, dropFileList, gtkWin->owner);
dnd_success = TRUE;
}
bail:
gtk_drag_finish(context, dnd_success, TRUE, time);
FskMemPtrDispose(path);
while (NULL != dropFileList) {
droppedFile = dropFileList;
FskListRemove((FskList *)&dropFileList, droppedFile);
FskMemPtrDispose(droppedFile->fullPathName);
FskMemPtrDispose(droppedFile);
}
}
FskErr KprDBExecuteFile(KprDB self, char* path)
{
FskErr err = kFskErrNone;
FskFileInfo info;
FskFile fref = NULL;
char *buffer = NULL;;
bailIfError(FskFileGetFileInfo(path, &info));
bailIfError(KprMemPtrNew(info.filesize + 1, &buffer));
bailIfError(FskFileOpen(path, kFskFilePermissionReadOnly, &fref));
bailIfError(FskFileRead(fref, info.filesize, buffer, NULL));
buffer[info.filesize] = 0;
sqlite3_exec(self->data, buffer, NULL, NULL, NULL);
bail:
KprMemPtrDispose(buffer);
FskFileClose(fref);
return err;
}
void KprFILEServiceInvoke(KprService service UNUSED, KprMessage message)
{
FskErr err = kFskErrNone;
char* path = NULL;
FskFileInfo info;
FskDirectoryIterator iterator = NULL;
char* pathName = NULL;
char* sniff = NULL;
FskFile fref = NULL;
char *name = NULL;
if (KprMessageContinue(message)) {
if (!message->method || FskStrCompare(message->method, "GET")) {
bailIfError(KprURLToPath(message->url, &path));
bailIfError(FskFileGetFileInfo(path, &info));
if (kFskDirectoryItemIsDirectory == info.filetype) {
unsigned char buffer[4096];
UInt32 itemType;
double date;
UInt32 size;
xsBeginHostSandboxCode(gFILEService.machine, NULL);
{
xsVars(3);
{
xsTry {
xsVar(0) = xsGet(xsGlobal, xsID("Files"));
xsResult = xsNewInstanceOf(xsArrayPrototype);
bailIfError(FskDirectoryIteratorNew(path, &iterator, 0));
while (kFskErrNone == FskDirectoryIteratorGetNext(iterator, &name, &itemType)) {
if (name[0] == '.') {
FskMemPtrDisposeAt(&name);
continue;
}
if (kFskDirectoryItemIsFile == itemType) {
pathName = FskStrDoCat(path, name);
bailIfError(FskFileGetFileInfo(pathName, &info));
bailIfError(FskFileOpen(pathName, kFskFilePermissionReadOnly, &fref));
bailIfError(FskFileRead(fref, sizeof(buffer), buffer, &size));
FskFileClose(fref);
fref = NULL;
if (kFskErrNone == FskMediaPlayerSniffForMIME(buffer, size, NULL, pathName, &sniff)) {
}
else if (kFskErrNone == FskImageDecompressSniffForMIME(buffer, size, NULL, pathName, &sniff)) {
}
FskMemPtrDispose(pathName);
pathName = NULL;
}
xsVar(1) = xsNewInstanceOf(xsObjectPrototype);
xsNewHostProperty(xsVar(1), xsID("name"), xsString(name), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(1), xsID("path"), xsString(name), xsDefault, xsDontScript);
FskStrCopy((char*)buffer, message->url);
FskStrCat((char*)buffer, name);
if (kFskDirectoryItemIsDirectory == itemType) {
xsVar(2) = xsGet(xsVar(0), xsID("directoryType"));
FskStrCat((char*)buffer, "/");
}
else if (kFskDirectoryItemIsFile == itemType) {
xsVar(2) = xsGet(xsVar(0), xsID("fileType"));
if (info.fileModificationDate > info.fileCreationDate)
date = info.fileModificationDate * 1000.0;
else
date = info.fileCreationDate * 1000.0;
xsNewHostProperty(xsVar(1), xsID("date"), xsNumber(date), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(1), xsID("size"), xsNumber(info.filesize), xsDefault, xsDontScript);
if (sniff) {
xsNewHostProperty(xsVar(1), xsID("mime"), xsString(sniff), xsDefault, xsDontScript);
FskMemPtrDispose(sniff);
sniff = NULL;
}
}
else
xsVar(2) = xsGet(xsVar(0), xsID("linkType"));
xsNewHostProperty(xsVar(1), xsID("type"), xsVar(2), xsDefault, xsDontScript);
xsNewHostProperty(xsVar(1), xsID("url"), xsString((char*)buffer), xsDefault, xsDontScript);
(void)xsCall1(xsResult, xsID("push"), xsVar(1));
FskMemPtrDisposeAt(&name);
}
xsResult = xsCall1(xsGet(xsGlobal, xsID("JSON")), xsID("stringify"), xsResult);
message->response.body = FskStrDoCopy(xsToString(xsResult));
message->response.size = FskStrLen(message->response.body);
KprMessageTransform(message, gFILEService.machine);
}
xsCatch {
}
}
}
xsEndHostSandboxCode();
}
else if (kFskDirectoryItemIsFile == info.filetype) {
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 FskECMAScriptLoadLibrary(const char *name)
{
FskErr err = kFskErrBadData;
FskLibraryLoadProc libLoad;
char *extension = NULL, *symbolName = NULL, *dot, *slash, *fullPath = NULL, *temp = NULL;
FskLibrary library = NULL;
char* root = NULL;
FskFileInfo itemInfo;
FskDebugStr("FskECMAScriptLoadLibrary: %s", name);
dot = FskStrRChr(name, '.');
slash = FskStrRChr(name, '/');
if ((NULL == dot) || (slash && (slash > dot))) {
#if TARGET_OS_WIN32
extension = ".dll";
#elif TARGET_OS_MAC || TARGET_OS_LINUX
extension = ".so";
#elif TARGET_OS_KPL
extension = (char*)KplECMAScriptGetExtension();
#endif
}
if (extension)
fullPath = FskStrDoCat(name, extension);
else
fullPath = FskStrDoCopy(name);
if (kFskErrNone != FskFileGetFileInfo(fullPath, &itemInfo)) {
#if TARGET_OS_ANDROID
char *libDir;
libDir = FskStrDoCat(gAndroidCallbacks->getStaticDataDirCB(), "../lib/lib");
temp = FskStrDoCat(libDir, fullPath);
FskMemPtrDispose(libDir);
#else
root = FskGetApplicationPath();
temp = FskStrDoCat(root, fullPath);
FskMemPtrDispose(root);
#endif
if (kFskErrNone != FskFileGetFileInfo(temp, &itemInfo)) {
FskDebugStr(" - no file: %s", temp);
goto bail;
}
FskMemPtrDispose(fullPath);
fullPath = temp;
temp = NULL;
}
err = FskLibraryLoad(&library, fullPath);
FskDebugStr(" - try: %s -> %d", fullPath, err);
if (err) goto bail;
symbolName = FskStrDoCat(name, "_fskLoad");
if ((kFskErrNone == FskLibraryGetSymbolAddress(library, symbolName, &libLoad)) ||
(kFskErrNone == FskLibraryGetSymbolAddress(library, "fskLoad", &libLoad))) {
err = (libLoad)(library);
FskDebugStr(" - symbolName: %x -> %d", libLoad, err);
if (err)
goto bail;
err = kFskErrNone;
}
bail:
if (err) {
FskLibraryUnload(library);
}
FskMemPtrDispose(symbolName);
FskMemPtrDispose(fullPath);
return err;
}
void fxIncludeScript(txParser* parser, txString string)
{
txBoolean done = 0;
char* base = NULL;
char name[PATH_MAX];
char* slash = NULL;
char* dot = NULL;
char* extension = NULL;
char* url = NULL;
char* path = NULL;
FskFileInfo fileInfo;
FskFileMapping map= NULL;
txFileMapStream fileMapStream;
txStringStream stringStream;
txMachine* the = parser->console;
fxBeginHost(the);
{
mxTry(the) {
xsThrowIfFskErr(KprPathToURL(parser->path->string, &base));
FskStrCopy(name, string);
slash = FskStrRChr(name, '/');
if (!slash)
slash = name;
dot = FskStrRChr(slash, '.');
if (dot)
extension = dot;
else
extension = name + FskStrLen(name);
if (!dot)
FskStrCopy(extension, ".js");
if (!FskStrCompare(extension, ".js")) {
xsThrowIfFskErr(KprURLMerge(base, name, &url));
xsThrowIfFskErr(KprURLToPath(url, &path));
if (kFskErrNone == FskFileGetFileInfo(path, &fileInfo)) {
xsThrowIfFskErr(FskFileMap(path, (unsigned char**)&(fileMapStream.buffer), &(fileMapStream.size), 0, &map));
fileMapStream.offset = 0;
fxIncludeTree(parser, &fileMapStream, fxFileMapGetter, parser->flags, path);
done = 1;
FskFileDisposeMap(map);
map = NULL;
}
FskMemPtrDisposeAt(&path);
FskMemPtrDisposeAt(&url);
}
if (!dot)
FskStrCopy(extension, ".xml");
if (!FskStrCompare(extension, ".xml")) {
xsThrowIfFskErr(KprURLMerge(base, name, &url));
xsThrowIfFskErr(KprURLToPath(url, &path));
if (kFskErrNone == FskFileGetFileInfo(path, &fileInfo)) {
xsThrowIfFskErr(FskFileMap(path, &fileMapStream.buffer, &fileMapStream.size, 0, &map));
fileMapStream.offset = 0;
mxPushInteger(0);
mxPushInteger(0);
mxPushInteger(0);
mxPushInteger(0);
mxPushInteger(3);
fxParse(the, &fileMapStream, fxFileMapGetter, path, 1, xsSourceFlag | xsDebugFlag);
fxCallID(the, fxID(the, "generate"));
fxToString(the, the->stack);
stringStream.slot = the->stack;
stringStream.size = c_strlen(stringStream.slot->value.string);
stringStream.offset = 0;
fxIncludeTree(parser, &stringStream, fxStringGetter, parser->flags, path);
done = 1;
FskFileDisposeMap(map);
map = NULL;
}
FskMemPtrDisposeAt(&path);
FskMemPtrDisposeAt(&url);
}
FskMemPtrDispose(base);
}
mxCatch(the) {
FskFileDisposeMap(map);
FskMemPtrDispose(path);
FskMemPtrDispose(url);
FskMemPtrDispose(base);
break;
}
}
fxEndHost(the);
if (!done)
fxReportParserError(parser, "include file not found: %s", string);
}
