polycode-engine/src/core/PolyAndroidCore.cpp

/*
 Copyright (C) 2016 by Joachim Meyer
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */

#include "polycode/core/PolyAndroidCore.h"
#include "polycode/core/PolyOpenGLGraphicsInterface.h"
#include "polycode/core/PolyAAssetFileProvider.h"
#include "polycode/core/PolyBasicFileProvider.h"
#include "polycode/core/PolyPhysFSFileProvider.h"
#include "polycode/core/PolyLogger.h"
#include "polycode/core/PolyResourceManager.h"
#include "polycode/core/PolyOpenSLAudioInterface.h"
#include "polycode/view/android/PolycodeView.h"

#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

using namespace Polycode;

extern AndroidCore *core;

void AndroidCoreMutex::lock() {
    pthread_mutex_lock(&pMutex);
}

void AndroidCoreMutex::unlock() {
    pthread_mutex_unlock(&pMutex);
}


AndroidCore::AndroidCore(PolycodeView *view, int xRes, int yRes, bool fullScreen, bool vSync, int aaLevel, int anisotropyLevel, int frameRate, int monitorIndex, bool retinaSupport) 
	: Core(xRes, yRes, fullScreen, vSync, aaLevel, anisotropyLevel, frameRate, monitorIndex) {
	
	fileProviders.push_back(new BasicFileProvider());
	fileProviders.push_back(new PhysFSFileProvider());
	fileProviders.push_back(new AAssetFileProvider(view->native_activity->assetManager));
	
	eventMutex = createMutex();
	eglMutex = createMutex();
	
	renderer = new Renderer();
	renderer->setBackingResolutionScale(1.0, 1.0);
	graphicsInterface = new OpenGLGraphicsInterface();
	renderer->setGraphicsInterface(this, graphicsInterface);
	services->setRenderer(renderer);

	context = NULL;
	surface = NULL;
	recreateContext = true;
	
	//scale needs to be set now so that labels are scaled correctly	
	if(retinaSupport){
		float scale = 1.0;
		int dens = AConfiguration_getDensity(view->native_config);
		if(dens >=ACONFIGURATION_DENSITY_LOW && dens <= ACONFIGURATION_DENSITY_XXXHIGH){
			scale = dens / ACONFIGURATION_DENSITY_MEDIUM;
		}
		renderer->setBackingResolutionScale(scale, scale);
	}
	
	//DP are the Density Independent Pixels - this is afaik what should be the size this should work with enabled retinaSupport
	setVideoMode(AConfiguration_getScreenWidthDp(view->native_config), AConfiguration_getScreenHeightDp(view->native_config), fullScreen, vSync, aaLevel, anisotropyLevel, retinaSupport);
	
	defaultWorkingDirectory = view->native_activity->internalDataPath;
	userHomeDirectory = view->native_activity->externalDataPath;
	
	paused = true;
	
	initKeyMap();
	
	this->view = view;
	core = this;
	
	audioInterface = new OpenSLAudioInterface();
	services->getSoundManager()->setAudioInterface(audioInterface);
	extractResources();
}

AndroidCore::~AndroidCore() {

}

void AndroidCore::Render() {
	renderer->beginFrame();
	services->Render(Polycode::Rectangle(0, 0, getBackingXRes(), getBackingYRes()));
	renderer->endFrame();
}

void AndroidCore::checkEvents() {

	eventMutex->lock();
	
	AndroidEvent event;
	for (int i = 0; i < systemInputEvents.size(); i++) {
		event = systemInputEvents[i];
		switch (event.eventGroup) {
		case AndroidEvent::INPUT_EVENT:
			switch (event.eventCode) {
			case InputEvent::EVENT_MOUSEMOVE:
				input->setDeltaPosition(lastMouseX - event.mouseX, lastMouseY - event.mouseY);
				lastMouseX = event.mouseX;
				lastMouseY = event.mouseY;
				input->setMousePosition(event.mouseX, event.mouseY, getTicks());
				break;
			case InputEvent::EVENT_MOUSEDOWN:
				input->mousePosition.x = event.mouseX;
				input->mousePosition.y = event.mouseY;
				input->setMouseButtonState(event.mouseButton, true, getTicks());
				break;
			case InputEvent::EVENT_MOUSEWHEEL_UP:
				input->mouseWheelUp(getTicks());
				break;
			case InputEvent::EVENT_MOUSEWHEEL_DOWN:
				input->mouseWheelDown(getTicks());
				break;
			case InputEvent::EVENT_MOUSEUP:
				input->setMouseButtonState(event.mouseButton, false, getTicks());
				break;
			case InputEvent::EVENT_TEXTINPUT:
				input->textInput(event.text);
				break;
			case InputEvent::EVENT_KEYDOWN:
				if (!checkSpecialKeyEvents(event.keyCode))
					input->setKeyState(event.keyCode, true, getTicks());
				break;
			case InputEvent::EVENT_KEYUP:
				input->setKeyState(event.keyCode, false, getTicks());
				break;
			case InputEvent::EVENT_TOUCHES_BEGAN:
				input->touchesBegan(event.touch, event.touches, getTicks());
				break;
			case InputEvent::EVENT_TOUCHES_ENDED:
				input->touchesEnded(event.touch, event.touches, getTicks());
				break;
			case InputEvent::EVENT_TOUCHES_MOVED:
				input->touchesMoved(event.touch, event.touches, getTicks());
				break;
			}
			break;
		case AndroidEvent::SYSTEM_FOCUS_EVENT:
			switch (event.eventCode) {
			case Core::EVENT_LOST_FOCUS:
				loseFocus();
				break;
			case Core::EVENT_GAINED_FOCUS:
				gainFocus();
				break;
			}
			break;
		}
	}

	systemInputEvents.clear();
	eventMutex->unlock();

}

bool AndroidCore::systemUpdate() {
	if (!running) {
		return false;
	}
	
	doSleep();
	
	updateCore();
	checkEvents();
	ALooper_pollAll(0, NULL, NULL, NULL);
	
	return running;
}

void AndroidCore::setCursor(int cursorType) {

}

//adapted from https://groups.google.com/d/msg/android-ndk/Tk3g00wLKhk/TJQucoaE_asJ
void AndroidCore::openOnScreenKeyboard(bool open){
	// Attaches the current thread to the JVM. 
	jint lResult; 
	jint lFlags = 0; 

	JavaVM* javaVM = view->native_activity->vm;
	JNIEnv* jniEnv;
	bool attached = false;

	if(javaVM->GetEnv((void**)&jniEnv, JNI_VERSION_1_6) ==JNI_EDETACHED){
		JavaVMAttachArgs attachArgs;
		attachArgs.version = JNI_VERSION_1_6;
		attachArgs.name = "NativeThread";
		attachArgs.group = NULL;
		
		jint result = javaVM->AttachCurrentThread(&jniEnv, &attachArgs);
		if(result == JNI_ERR){
			return;
		}
		attached = true;
	} 

	// Retrieves Context.INPUT_METHOD_SERVICE. 
	jclass ClassContext = jniEnv->FindClass("android/content/Context"); 
	jfieldID FieldINPUT_METHOD_SERVICE = jniEnv->GetStaticFieldID(ClassContext, "INPUT_METHOD_SERVICE", "Ljava/lang/String;"); 
	jobject INPUT_METHOD_SERVICE = jniEnv->GetStaticObjectField(ClassContext, FieldINPUT_METHOD_SERVICE); 

	jclass ClassNativeActivity = jniEnv->FindClass("android/app/NativeActivity");
	jobject lNativeActivity = view->native_activity->clazz;
	
	// Runs getSystemService(Context.INPUT_METHOD_SERVICE). 
	jclass ClassInputMethodManager = jniEnv->FindClass("android/view/inputmethod/InputMethodManager");
	jmethodID MethodGetSystemService = jniEnv->GetMethodID(ClassNativeActivity, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;"); 
	jobject lInputMethodManager = jniEnv->CallObjectMethod(lNativeActivity, MethodGetSystemService, INPUT_METHOD_SERVICE); 

	// Runs getWindow().getDecorView().
	jmethodID MethodGetWindow = jniEnv->GetMethodID(ClassNativeActivity, "getWindow", "()Landroid/view/Window;"); 
	jobject lWindow = jniEnv->CallObjectMethod(lNativeActivity, MethodGetWindow); 
	jclass ClassWindow = jniEnv->FindClass("android/view/Window");
	jmethodID MethodGetDecorView = jniEnv->GetMethodID(ClassWindow, "getDecorView", "()Landroid/view/View;");
	jobject lDecorView = jniEnv->CallObjectMethod(lWindow, MethodGetDecorView);

		// Runs lWindow.getViewToken() 
	jclass ClassView = jniEnv->FindClass("android/view/View"); 
	jmethodID MethodGetWindowToken = jniEnv->GetMethodID(ClassView, "getWindowToken", "()Landroid/os/IBinder;"); 
	jobject lBinder = jniEnv->CallObjectMethod(lDecorView, MethodGetWindowToken); 

	if (open) {
		// Runs lInputMethodManager.showSoftInput(...). 
		jmethodID MethodShowSoftInput = jniEnv->GetMethodID(ClassInputMethodManager, "showSoftInput", "(Landroid/view/View;I)Z"); 
		jboolean lResult = jniEnv->CallBooleanMethod(lInputMethodManager, MethodShowSoftInput, lDecorView, lFlags);
	} else { 
		// lInputMethodManager.hideSoftInput(...). 
		jmethodID MethodHideSoftInput = jniEnv->GetMethodID(ClassInputMethodManager, "hideSoftInputFromWindow", "(Landroid/os/IBinder;I)Z"); 
		jboolean lRes = jniEnv->CallBooleanMethod(lInputMethodManager, MethodHideSoftInput, lBinder, lFlags); 
	} 

	// Finished with the JVM.
	if (attached)
	javaVM->DetachCurrentThread();
}

void launchThread(Threaded *target) {
	target->runThread();
	target->scheduledForRemoval = true;
}

void *ManagedThreadFunc(void *data) {
	Threaded *target = static_cast<Threaded*>(data);
	target->runThread();
	target->scheduledForRemoval = true;
	return NULL;
}


void AndroidCore::createThread(Threaded * target) {
	Core::createThread(target);
	pthread_t thread;
	pthread_create( &thread, NULL, ManagedThreadFunc, (void*)target);
}

CoreMutex *AndroidCore::createMutex() {
	AndroidCoreMutex *mutex = new AndroidCoreMutex();
	pthread_mutex_init(&mutex->pMutex, NULL);
	return mutex;
}

void AndroidCore::copyStringToClipboard(const String& str) {
	// Attaches the current thread to the JVM. 
	JavaVM* javaVM = view->native_activity->vm;
	JNIEnv* jniEnv;
	bool attached = false;

	if(javaVM->GetEnv((void**)&jniEnv, JNI_VERSION_1_6) ==JNI_EDETACHED){
		JavaVMAttachArgs attachArgs;
		attachArgs.version = JNI_VERSION_1_6;
		attachArgs.name = "NativeThread";
		attachArgs.group = NULL;
		
		jint result = javaVM->AttachCurrentThread(&jniEnv, &attachArgs);
		if(result == JNI_ERR){
			return;
		}
		attached = true;
	} 

	
	jclass looperClass = jniEnv->FindClass("android/os/Looper");
	jmethodID prepareMethodID = jniEnv->GetStaticMethodID(looperClass, "prepare", "()V");
	jniEnv->CallStaticVoidMethod(looperClass, prepareMethodID);
	
	// Retrieves Context.CLIPBOARD_SERVICE. 
	jclass ClassContext = jniEnv->FindClass("android/content/Context");
	jfieldID FieldCLIPBOARD_SERVICE = jniEnv->GetStaticFieldID(ClassContext, "CLIPBOARD_SERVICE", "Ljava/lang/String;");
	jobject CLIPBOARD_SERVICE = jniEnv->GetStaticObjectField(ClassContext, FieldCLIPBOARD_SERVICE);
// 	jstring CLIPBOARD_SERVICE = jniEnv->NewStringUTF("clipboard");

	jclass ClassNativeActivity = jniEnv->FindClass("android/app/NativeActivity");
	jobject lNativeActivity = view->native_activity->clazz;
	
	// Runs getSystemService(Context.CLIPBOARD_SERVICE).
	jclass ClassClipboardManager = jniEnv->FindClass("android/content/ClipboardManager");
	jmethodID MethodGetSystemService = jniEnv->GetMethodID(ClassNativeActivity, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
	jobject lCliboardManager = jniEnv->CallObjectMethod(lNativeActivity, MethodGetSystemService, CLIPBOARD_SERVICE);
	
	// Runs clipData.newPlainText()
	jclass ClassClipData = jniEnv->FindClass("android/content/ClipData");
	jmethodID MethodnewPlainText = jniEnv->GetStaticMethodID(ClassClipData, "newPlainText", "(Ljava/lang/CharSequence;Ljava/lang/CharSequence;)Landroid/content/ClipData;");
	jstring text = jniEnv->NewStringUTF(str.c_str());
	jstring lbl = jniEnv->NewStringUTF("PolycodeText");
	jobject lClipData = jniEnv->CallStaticObjectMethod(ClassClipData, MethodnewPlainText, lbl, text);
	
	jmethodID MethodSetPrimaryClip = jniEnv->GetMethodID(ClassClipboardManager, "setPrimaryClip", "(Landroid/content/ClipData;)V");
	jniEnv->CallVoidMethod(lCliboardManager, MethodSetPrimaryClip, lClipData);
	
	// Finished with the JVM.
	if (attached)
		javaVM->DetachCurrentThread();
}

String AndroidCore::getClipboardString() {
	// Attaches the current thread to the JVM. 
	JavaVM* javaVM = view->native_activity->vm;
	JNIEnv* jniEnv;
	bool attached = false;

	if(javaVM->GetEnv((void**)&jniEnv, JNI_VERSION_1_6) ==JNI_EDETACHED){
		JavaVMAttachArgs attachArgs;
		attachArgs.version = JNI_VERSION_1_6;
		attachArgs.name = "NativeThread";
		attachArgs.group = NULL;
		
		jint result = javaVM->AttachCurrentThread(&jniEnv, &attachArgs);
		if(result == JNI_ERR){
			return "";
		}
		attached = true;
	} 
	
	jclass looperClass = jniEnv->FindClass("android/os/Looper");
	jmethodID prepareMethodID = jniEnv->GetStaticMethodID(looperClass, "prepare", "()V");
	jniEnv->CallStaticVoidMethod(looperClass, prepareMethodID);

	// Retrieves Context.CLIPBOARD_SERVICE. 
	jclass ClassContext = jniEnv->FindClass("android/content/Context");
	jfieldID FieldCLIPBOARD_SERVICE = jniEnv->GetStaticFieldID(ClassContext, "CLIPBOARD_SERVICE", "Ljava/lang/String;");
	jobject CLIPBOARD_SERVICE = jniEnv->GetStaticObjectField(ClassContext, FieldCLIPBOARD_SERVICE);

	jclass ClassNativeActivity = jniEnv->FindClass("android/app/NativeActivity");
	jobject lNativeActivity = view->native_activity->clazz;
	
	// Runs getSystemService(Context.CLIPBOARD_SERVICE).
	jclass ClassClipboardManager = jniEnv->FindClass("android/content/ClipboardManager");
	jmethodID MethodGetSystemService = jniEnv->GetMethodID(ClassNativeActivity, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
	jobject lCliboardManager = jniEnv->CallObjectMethod(lNativeActivity, MethodGetSystemService, CLIPBOARD_SERVICE);

	// Runs clipboard.getPrimaryClip()
	jmethodID MethodGetPrimaryClip = jniEnv->GetMethodID(ClassClipboardManager, "getPrimaryClip", "()Landroid/content/ClipData;");
	jobject lClipData = jniEnv->CallObjectMethod(lCliboardManager, MethodGetPrimaryClip);
	
	//Runs clipdata.getItemAt(0)
	jclass ClassClipDataItem = jniEnv->FindClass("android/content/ClipData$Item");
	jclass ClassClipData = jniEnv->FindClass("android/content/ClipData");
	jmethodID MethodGetItemAt = jniEnv->GetMethodID(ClassClipData, "getItemAt", "(I)Landroid/content/ClipData$Item;");
	jobject lClipDataItem = jniEnv->CallObjectMethod(lClipData, MethodGetItemAt, 0);
	
	//Runs clipdescription.getText()
	jmethodID MethodGetText = jniEnv->GetMethodID(ClassClipDataItem, "getText", "()Ljava/lang/CharSequence;");
	jobject lCharSequence = jniEnv->CallObjectMethod(lClipDataItem, MethodGetText);
	
	//Runs charseuquence.toString()
	jclass ClassCharSequence = jniEnv->FindClass("java/lang/CharSequence");
	jmethodID MethodtoString = jniEnv->GetMethodID(ClassCharSequence, "toString", "()Ljava/lang/String;");
	jobject lText = jniEnv->CallObjectMethod(lCharSequence, MethodtoString);
	
	const char *nativeString = jniEnv->GetStringUTFChars((jstring)lText, (jboolean*)0);
	String returnStr = String(nativeString);
	jniEnv->ReleaseStringUTFChars((jstring)lText, nativeString);
	
	// Finished with the JVM.
	if (attached)
		javaVM->DetachCurrentThread();
	return returnStr;
}

void AndroidCore::extractResources(){
	std::vector<OSFileEntry> entries;
	CoreFileProvider *afileProvider;
	CoreFileProvider *bfileProvider;
	
	for (int i = 0; i < fileProviders.size(); i++){
		if(fileProviders[i]->type == "aasset"){
			afileProvider = fileProviders[i];
		} else if(fileProviders[i]->type == "folder"){
			bfileProvider = fileProviders[i];
		}
	}
	
	afileProvider->parseFolder("extract", true, entries);
	
	struct stat st = {0};
	if(stat(defaultWorkingDirectory.c_str(), &st)==-1)
		mkdir(defaultWorkingDirectory.c_str(), 0700);
	
	CoreFile* source;
	CoreFile* dest;
	char* buffer = (char*)malloc(1*sizeof(char));
	
	for(int i = 0; i < entries.size(); i++){
		source = afileProvider->openFile(entries[i].fullPath,"r");
		dest = bfileProvider->openFile(defaultWorkingDirectory+"/"+entries[i].name, "rb");
		
		if(dest){
			dest->seek(0, SEEK_END);
			if(source->tell() != dest->tell()){
				bfileProvider->closeFile(dest);
				dest = bfileProvider->openFile(defaultWorkingDirectory+"/"+entries[i].name, "wb");
				while(source->read(buffer, sizeof(char), 1) > 0){
					dest->write(buffer,sizeof(char), 1);
				}
			}
			bfileProvider->closeFile(dest);
		} else {
			dest = bfileProvider->openFile(defaultWorkingDirectory+"/"+entries[i].name, "wb");
			while(source->read(buffer, sizeof(char), 1) > 0){
				dest->write(buffer,sizeof(char), 1);
			}
			bfileProvider->closeFile(dest);
		}
		
		afileProvider->closeFile(source);
	}
	
	free(buffer);
}

void AndroidCore::addFileSource(const String &type, const String &source) {
	for(int i=0; i < fileProviders.size(); i++) {
		if(fileProviders[i]->type == type) {
			if(source.substr(0,1) == "/"){
				fileProviders[i]->addSource(source);
			}else{
				fileProviders[i]->addSource(defaultWorkingDirectory+"/"+source);
			}
			return;
		}
	}
}

void AndroidCore::createFolder(const String& folderPath) {

}

void AndroidCore::copyDiskItem(const String& itemPath, const String& destItemPath) {

}

void AndroidCore::moveDiskItem(const String& itemPath, const String& destItemPath) {

}

void AndroidCore::removeDiskItem(const String& itemPath) {

}

String AndroidCore::openFolderPicker() {
	return "";
}

std::vector<String> AndroidCore::openFilePicker(std::vector<CoreFileExtension> extensions, bool allowMultiple) {
	std::vector<String> ret;
	return ret;
}

String AndroidCore::saveFilePicker(std::vector<CoreFileExtension> extensions) {
	return "";
}

void AndroidCore::handleVideoModeChange(VideoModeChangeInfo *modeInfo) {
	int32_t success = 0;
	EGLBoolean result;
	EGLint num_config;

	this->xRes = modeInfo->xRes;
	this->yRes = modeInfo->yRes;
	this->fullScreen = modeInfo->fullScreen;
	this->aaLevel = modeInfo->aaLevel;
	this->vSync = modeInfo->vSync;
	this->anisotropyLevel = modeInfo->anisotropyLevel;
	
	float scale = 1.0;
	if(modeInfo->retinaSupport){
		int dens = AConfiguration_getDensity(view->native_config);
		if(dens >=ACONFIGURATION_DENSITY_LOW && dens <= ACONFIGURATION_DENSITY_XXXHIGH){
			scale = dens / ACONFIGURATION_DENSITY_MEDIUM;
		}
	}
	renderer->setBackingResolutionScale(scale, scale);
	
	if(!view->native_window){
		return;
	}
	
	if (recreateContext){
		eglMutex->lock();
		static const EGLint attribute_list[] =
		{
			EGL_RED_SIZE, 8,
			EGL_GREEN_SIZE, 8,
			EGL_BLUE_SIZE, 8,
			EGL_ALPHA_SIZE, 8,
			EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
			EGL_NONE
		};

		static const EGLint context_attributes[] =
		{
			EGL_CONTEXT_CLIENT_VERSION, 2,
			EGL_NONE
		};

		EGLConfig config;
		EGLint format;
		
		display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
		result = eglInitialize(display, NULL, NULL);
		
		result = eglChooseConfig(display, attribute_list, &config, 1, &num_config);
		assert(EGL_FALSE != result);
		
		if (eglQueryAPI() == EGL_NONE){
			result = eglBindAPI(EGL_OPENGL_ES_API);
			assert(EGL_FALSE != result);
		}
		
		if(!context){
			context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attributes);
			assert(context!=EGL_NO_CONTEXT);
		}
		
		// this works on my Fairphone but not in the Emulator.. and it did work in the Emulator for quite some while.. but now it says: "E/Surface﹕ getSlotFromBufferLocked: unknown buffer:"
		// everything is running without this as well...
// 		if(surface)
// 			eglDestroySurface(display, surface);
		
		surface = eglCreateWindowSurface( display, config, view->native_window, NULL );
		assert(surface != EGL_NO_SURFACE);

		// connect the context to the surface
		result = eglMakeCurrent(display, surface, surface, context);
		assert(EGL_FALSE != result);
		
		Logger::log("EGL Init finished");
		
		recreateContext = false;
		eglMutex->unlock();
	}
}

void AndroidCore::flushRenderContext() {
	glFlush();
	eglSwapBuffers(display, surface);
}

bool AndroidCore::isWindowInitialized(){
	eglMutex->lock();
// 	Logger::log("locked");
	if (eglGetCurrentContext() == EGL_NO_CONTEXT || recreateContext || !view->isInteractable()){
		eglMutex->unlock();
		return false;
	} else {
		eglMutex->unlock();
		return true;
	}
}

CoreMutex* AndroidCore::getEGLMutex(){
	return eglMutex;
}

void AndroidCore::openURL(String url) {

}

unsigned int AndroidCore::getTicks() {
	struct timespec now;
	clock_gettime(CLOCK_MONOTONIC, &now);
	return now.tv_sec * 1000 + now.tv_nsec/1000000;
}

String AndroidCore::executeExternalCommand(String command, String args, String inDirectory) {
	return "";
}

bool AndroidCore::systemParseFolder(const Polycode::String& pathString, bool showHidden, std::vector<OSFileEntry> &targetVector) {
	
    DIR           *d;
    struct dirent *dir;
    
    d = opendir(pathString.c_str());
    if(d) {
        while ((dir = readdir(d)) != NULL) {
            if(dir->d_name[0] != '.' || (dir->d_name[0] == '.'  && showHidden)) {
                if(dir->d_type == DT_DIR) {
                    targetVector.push_back(OSFileEntry(pathString, dir->d_name, OSFileEntry::TYPE_FOLDER));
                } else {
                    targetVector.push_back(OSFileEntry(pathString, dir->d_name, OSFileEntry::TYPE_FILE));
                }
            }
        }
        closedir(d);
    }
    return true;
}

void AndroidCore::handleSystemEvent(AndroidEvent systemEvent) {
	eventMutex->lock();
	systemInputEvents.push_back(systemEvent);
	eventMutex->unlock();
}

void Core::getScreenInfo(int *width, int *height, int *hz) {

}

void AndroidCore::setDeviceSize(Number x, Number y) {
	deviceWidth = x;
	deviceHeight = y;
}

Number AndroidCore::getBackingXRes() {
	return deviceWidth;
}

Number AndroidCore::getBackingYRes() {
	return deviceHeight;
}

void AndroidCore::_setAcceleration(const Vector3 &acceleration) {
    CoreMotionEvent *event = new CoreMotionEvent();
    event->amount = acceleration;
    dispatchEvent(event, Core::EVENT_ACCELEROMETER_MOTION);
}

void AndroidCore::_setGyroRotation(const Vector3 &rotation) {
    CoreMotionEvent *event = new CoreMotionEvent();
    event->amount = rotation;
    dispatchEvent(event, Core::EVENT_GYRO_ROTATION);
}

void AndroidCore::initKeyMap() {
	
	for (int i=0; i<1024; ++i )
		keyMap[i] = KEY_UNKNOWN;

	keyMap[AKEYCODE_BACK] = KEY_ESCAPE;
	keyMap[AKEYCODE_TAB] = KEY_TAB;
	keyMap[AKEYCODE_CLEAR] = KEY_CLEAR;
	keyMap[AKEYCODE_ENTER] = KEY_RETURN;
	keyMap[AKEYCODE_BREAK] = KEY_PAUSE;
	keyMap[AKEYCODE_ESCAPE] = KEY_ESCAPE;
	keyMap[AKEYCODE_SPACE] = KEY_SPACE;
	keyMap[AKEYCODE_APOSTROPHE] = KEY_QUOTE;
	keyMap[AKEYCODE_COMMA] = KEY_COMMA;
	keyMap[AKEYCODE_MINUS] = KEY_MINUS;
	keyMap[AKEYCODE_PERIOD] = KEY_PERIOD;
	keyMap[AKEYCODE_SLASH] = KEY_SLASH;
	keyMap[AKEYCODE_0] = KEY_0;
	keyMap[AKEYCODE_1] = KEY_1;
	keyMap[AKEYCODE_2] = KEY_2;
	keyMap[AKEYCODE_3] = KEY_3;
	keyMap[AKEYCODE_4] = KEY_4;
	keyMap[AKEYCODE_5] = KEY_5;
	keyMap[AKEYCODE_6] = KEY_6;
	keyMap[AKEYCODE_7] = KEY_7;
	keyMap[AKEYCODE_8] = KEY_8;
	keyMap[AKEYCODE_9] = KEY_9;
	keyMap[AKEYCODE_SEMICOLON] = KEY_SEMICOLON;
	keyMap[AKEYCODE_EQUALS] = KEY_EQUALS;
	keyMap[AKEYCODE_LEFT_BRACKET] = KEY_LEFTBRACKET;
	keyMap[AKEYCODE_BACKSLASH] = KEY_BACKSLASH;
// 	keyMap[AKEYCODE_OEM_102] = KEY_LESS;
	keyMap[AKEYCODE_RIGHT_BRACKET] = KEY_RIGHTBRACKET;
	keyMap[AKEYCODE_GRAVE] = KEY_BACKQUOTE;
	//keyMap[AKEYCODE_BACKTICK] = KEY_BACKQUOTE;
	keyMap[AKEYCODE_A] = KEY_a;
	keyMap[AKEYCODE_B] = KEY_b;
	keyMap[AKEYCODE_C] = KEY_c;
	keyMap[AKEYCODE_D] = KEY_d;
	keyMap[AKEYCODE_E] = KEY_e;
	keyMap[AKEYCODE_F] = KEY_f;
	keyMap[AKEYCODE_G] = KEY_g;
	keyMap[AKEYCODE_H] = KEY_h;
	keyMap[AKEYCODE_I] = KEY_i;
	keyMap[AKEYCODE_J] = KEY_j;
	keyMap[AKEYCODE_K] = KEY_k;
	keyMap[AKEYCODE_L] = KEY_l;
	keyMap[AKEYCODE_M] = KEY_m;
	keyMap[AKEYCODE_N] = KEY_n;
	keyMap[AKEYCODE_O] = KEY_o;
	keyMap[AKEYCODE_P] = KEY_p;
	keyMap[AKEYCODE_Q] = KEY_q;
	keyMap[AKEYCODE_R] = KEY_r;
	keyMap[AKEYCODE_S] = KEY_s;
	keyMap[AKEYCODE_T] = KEY_t;
	keyMap[AKEYCODE_U] = KEY_u;
	keyMap[AKEYCODE_V] = KEY_v;
	keyMap[AKEYCODE_W] = KEY_w;
	keyMap[AKEYCODE_X] = KEY_x;
	keyMap[AKEYCODE_Y] = KEY_y;
	keyMap[AKEYCODE_Z] = KEY_z;
	keyMap[AKEYCODE_DEL] = KEY_DELETE;

	keyMap[AKEYCODE_NUMPAD_0] = KEY_KP0;
	keyMap[AKEYCODE_NUMPAD_1] = KEY_KP1;
	keyMap[AKEYCODE_NUMPAD_2] = KEY_KP2;
	keyMap[AKEYCODE_NUMPAD_3] = KEY_KP3;
	keyMap[AKEYCODE_NUMPAD_4] = KEY_KP4;
	keyMap[AKEYCODE_NUMPAD_5] = KEY_KP5;
	keyMap[AKEYCODE_NUMPAD_6] = KEY_KP6;
	keyMap[AKEYCODE_NUMPAD_7] = KEY_KP7;
	keyMap[AKEYCODE_NUMPAD_8] = KEY_KP8;
	keyMap[AKEYCODE_NUMPAD_9] = KEY_KP9;
	keyMap[AKEYCODE_NUMPAD_DOT] = KEY_KP_PERIOD;
	keyMap[AKEYCODE_NUMPAD_DIVIDE] = KEY_KP_DIVIDE;
	keyMap[AKEYCODE_NUMPAD_MULTIPLY] = KEY_KP_MULTIPLY;
	keyMap[AKEYCODE_NUMPAD_SUBTRACT] = KEY_KP_MINUS;
	keyMap[AKEYCODE_NUMPAD_ADD] = KEY_KP_PLUS;

	keyMap[AKEYCODE_DPAD_UP] = KEY_UP;
	keyMap[AKEYCODE_DPAD_DOWN] = KEY_DOWN;
	keyMap[AKEYCODE_DPAD_RIGHT] = KEY_RIGHT;
	keyMap[AKEYCODE_DPAD_LEFT] = KEY_LEFT;
	keyMap[AKEYCODE_INSERT] = KEY_INSERT;
	keyMap[AKEYCODE_MOVE_HOME] = KEY_HOME;
	keyMap[AKEYCODE_MOVE_END] = KEY_END;
	keyMap[AKEYCODE_PAGE_UP] = KEY_PAGEUP;
	keyMap[AKEYCODE_PAGE_DOWN] = KEY_PAGEDOWN;

	keyMap[AKEYCODE_F1] = KEY_F1;
	keyMap[AKEYCODE_F2] = KEY_F2;
	keyMap[AKEYCODE_F3] = KEY_F3;
	keyMap[AKEYCODE_F4] = KEY_F4;
	keyMap[AKEYCODE_F5] = KEY_F5;
	keyMap[AKEYCODE_F6] = KEY_F6;
	keyMap[AKEYCODE_F7] = KEY_F7;
	keyMap[AKEYCODE_F8] = KEY_F8;
	keyMap[AKEYCODE_F9] = KEY_F9;
	keyMap[AKEYCODE_F10] = KEY_F10;
	keyMap[AKEYCODE_F11] = KEY_F11;
	keyMap[AKEYCODE_F12] = KEY_F12;

	keyMap[AKEYCODE_NUM_LOCK] = KEY_NUMLOCK;
	keyMap[AKEYCODE_CAPS_LOCK] = KEY_CAPSLOCK;
	keyMap[AKEYCODE_SCROLL_LOCK] = KEY_SCROLLOCK;
	keyMap[AKEYCODE_SHIFT_RIGHT] = KEY_RSHIFT;
	keyMap[AKEYCODE_SHIFT_LEFT] = KEY_LSHIFT;
	keyMap[AKEYCODE_CTRL_RIGHT] = KEY_RCTRL;
	keyMap[AKEYCODE_CTRL_LEFT] = KEY_LCTRL;
	keyMap[AKEYCODE_ALT_RIGHT] = KEY_RALT;
	keyMap[AKEYCODE_ALT_LEFT] = KEY_LALT;
	keyMap[AKEYCODE_META_RIGHT] = KEY_RSUPER;
	keyMap[AKEYCODE_META_LEFT] = KEY_LSUPER;

	keyMap[259] = KEY_HELP;
 	keyMap[AKEYCODE_SYSRQ] = KEY_PRINT;
	keyMap[AKEYCODE_BREAK] = KEY_BREAK;
	keyMap[AKEYCODE_MENU] = KEY_MENU;

}

PolyKEY AndroidCore::mapKey(int keyCode){
	return keyMap[(unsigned int) keyCode];
}

OpenSLAudioInterface* AndroidCore::getAudioInterface(){
	return audioInterface;
}