More Android stub-outs and bug fixes. Fix broken SDL fiber sync.

AerofoilAndroid/app/jni/.gitignore

@@ -1 +1,13 @@
+AerofoilSDL
+Common
+FreeType
+GpApp
+GpCommon
+GpFontHandler_FreeType2
+GpShell
+MacRomanConversion
+PortabilityLayer
+rapidjson
 SDL2
+stb
+zlib

AerofoilAndroid/app/jni/Application.mk

@@ -2,7 +2,7 @@
 # Uncomment this if you're using STL in your project
 # You can find more information here:
 # https://developer.android.com/ndk/guides/cpp-support
-# APP_STL := c++_shared
+APP_STL := c++_shared
 
 APP_ABI := armeabi-v7a arm64-v8a x86 x86_64
 

AerofoilAndroid/app/jni/main/Android.mk

@@ -6,13 +6,25 @@ LOCAL_MODULE := main
 
 SDL_PATH := ../SDL
 
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/$(SDL_PATH)/include
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/$(SDL_PATH)/include	\
+	$(LOCAL_PATH)/../GpShell	\
+	$(LOCAL_PATH)/../GpCommon	\
+	$(LOCAL_PATH)/../AerofoilSDL	\
+	$(LOCAL_PATH)/../Common	\
+	$(LOCAL_PATH)/../PortabilityLayer
+
+LOCAL_CFLAGS := -DGP_DEBUG_CONFIG=0
 
 # Add your application source files here...
-LOCAL_SRC_FILES := YourSourceHere.c
+LOCAL_SRC_FILES := \
+	GpMain_SDL_Android.cpp	\
+	GpSystemServices_Android.cpp	\
+	GpFileSystem_Android.cpp
 
 LOCAL_SHARED_LIBRARIES := SDL2
 
+LOCAL_STATIC_LIBRARIES := GpShell GpFontHandler_FreeType2 AerofoilSDL GpApp
+
 LOCAL_LDLIBS := -lGLESv1_CM -lGLESv2 -llog
 
 include $(BUILD_SHARED_LIBRARY)

AerofoilAndroid/app/jni/main/GpAndroid.h

@@ -0,0 +1,5 @@
+#pragma once
+
+struct GpAndroidGlobals
+{
+};

AerofoilAndroid/app/jni/main/GpFileSystem_Android.cpp

@@ -0,0 +1,84 @@
+#include "GpFileSystem_Android.h"
+
+GpFileSystem_Android::GpFileSystem_Android()
+{
+}
+
+bool GpFileSystem_Android::FileExists(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path)
+{
+	return false;
+}
+
+bool GpFileSystem_Android::FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool *exists)
+{
+	return false;
+}
+
+GpIOStream *GpFileSystem_Android::OpenFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool writeAccess, GpFileCreationDisposition_t createDisposition)
+{
+	return nullptr;
+}
+
+bool GpFileSystem_Android::DeleteFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &existed)
+{
+	existed = false;
+	return false;
+}
+
+PortabilityLayer::HostDirectoryCursor *GpFileSystem_Android::ScanDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory)
+{
+	return nullptr;
+}
+
+bool GpFileSystem_Android::ValidateFilePath(const char *path, size_t length) const
+{
+	for (size_t i = 0; i < length; i++)
+	{
+		const char c = path[i];
+		if (c >= '0' && c <= '9')
+			continue;
+
+		if (c == '_' || c == '.' || c == '\'')
+			continue;
+
+		if (c == ' ' && i != 0 && i != length - 1)
+			continue;
+
+		if (c >= 'a' && c <= 'z')
+			continue;
+
+		if (c >= 'A' && c <= 'Z')
+			continue;
+
+		return false;
+	}
+
+	return true;
+}
+
+bool GpFileSystem_Android::ValidateFilePathUnicodeChar(uint32_t c) const
+{
+	if (c >= '0' && c <= '9')
+		return true;
+
+	if (c == '_' || c == '\'')
+		return true;
+
+	if (c == ' ')
+		return true;
+
+	if (c >= 'a' && c <= 'z')
+		return true;
+
+	if (c >= 'A' && c <= 'Z')
+		return true;
+
+	return false;
+}
+
+GpFileSystem_Android *GpFileSystem_Android::GetInstance()
+{
+	return &ms_instance;
+}
+
+GpFileSystem_Android GpFileSystem_Android::ms_instance;

AerofoilAndroid/app/jni/main/GpFileSystem_Android.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "HostFileSystem.h"
+
+#include "GpCoreDefs.h"
+
+class GpFileSystem_Android final : public PortabilityLayer::HostFileSystem
+{
+public:
+	GpFileSystem_Android();
+
+	bool FileExists(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path) override;
+	bool FileLocked(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool *exists) override;
+	GpIOStream *OpenFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool writeAccess, GpFileCreationDisposition_t createDisposition) override;
+	bool DeleteFile(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, bool &existed) override;
+	PortabilityLayer::HostDirectoryCursor *ScanDirectory(PortabilityLayer::VirtualDirectory_t virtualDirectory) override;
+
+	bool ValidateFilePath(const char *path, size_t sz) const override;
+	bool ValidateFilePathUnicodeChar(uint32_t ch) const override;
+
+	static GpFileSystem_Android *GetInstance();
+
+private:
+	bool ResolvePath(PortabilityLayer::VirtualDirectory_t virtualDirectory, const char *path, wchar_t *outPath);
+
+	static GpFileSystem_Android ms_instance;
+};

AerofoilAndroid/app/jni/main/GpMain_SDL_Android.cpp

@@ -4,7 +4,6 @@
 #include "GpAudioDriverFactory.h"
 #include "GpDisplayDriverFactory.h"
 #include "GpGlobalConfig.h"
-#include "GpFiber_Win32.h"
 #include "GpFiber_SDL.h"
 #include "GpFileSystem_Android.h"
 #include "GpFontHandlerFactory.h"
@@ -19,8 +18,6 @@
 
 #include "GpAndroid.h"
 
-#include "resource.h"
-
 GpAndroidGlobals g_gpAndroidGlobals;
 
 extern "C" IGpFontHandler *GpDriver_CreateFontHandler_FreeType2(const GpFontHandlerProperties &properties);
@@ -29,17 +26,19 @@ IGpDisplayDriver *GpDriver_CreateDisplayDriver_SDL_GL2(const GpDisplayDriverProp
 IGpAudioDriver *GpDriver_CreateAudioDriver_SDL(const GpAudioDriverProperties &properties);
 
 
-int main(int argc, const char **argv)
+int main(int argc, char* argv[])
 {
 	if (SDL_Init(SDL_INIT_VIDEO) < 0)
 		return -1;
 
+	SDL_GL_LoadLibrary("libGLESv2.so");
+
 	GpAppInterface_Get()->PL_HostFileSystem_SetInstance(GpFileSystem_Android::GetInstance());
 	GpAppInterface_Get()->PL_HostSystemServices_SetInstance(GpSystemServices_Android::GetInstance());
 
 	g_gpGlobalConfig.m_displayDriverType = EGpDisplayDriverType_SDL_GL2;
 
-	g_gpGlobalConfig.m_audioDriverType = EGpAudioDriverType_SDL2;
+	g_gpGlobalConfig.m_audioDriverType = EGpAudioDriverType_None;
 
 	g_gpGlobalConfig.m_fontHandlerType = EGpFontHandlerType_FreeType2;
 
@@ -54,13 +53,7 @@ int main(int argc, const char **argv)
 	GpAudioDriverFactory::RegisterAudioDriverFactory(EGpAudioDriverType_SDL2, GpDriver_CreateAudioDriver_SDL);
 	GpFontHandlerFactory::RegisterFontHandlerFactory(EGpFontHandlerType_FreeType2, GpDriver_CreateFontHandler_FreeType2);
 
-	if (logger)
-		logger->Printf(IGpLogDriver::Category_Information, "SDL environment configured, starting up");
-
 	int returnCode = GpMain::Run();
 
-	if (logger)
-		logger->Printf(IGpLogDriver::Category_Information, "SDL environment exited with code %i, cleaning up", returnCode);
-
 	return returnCode;
 }

AerofoilAndroid/app/jni/main/GpSystemServices_Android.cpp

@@ -0,0 +1,174 @@
+#include "GpSystemServices_Android.h"
+#include "HostMutex.h"
+#include "HostThreadEvent.h"
+
+#include <time.h>
+#include <mutex>
+#include <condition_variable>
+
+template<class TMutex>
+class GpMutex_Cpp11 final : public PortabilityLayer::HostMutex
+{
+public:
+	GpMutex_Cpp11();
+	~GpMutex_Cpp11();
+
+	void Destroy() override;
+
+	void Lock() override;
+	void Unlock() override;
+
+private:
+	TMutex m_mutex;
+};
+
+template<class TMutex>
+GpMutex_Cpp11<TMutex>::GpMutex_Cpp11()
+{
+}
+
+template<class TMutex>
+GpMutex_Cpp11<TMutex>::~GpMutex_Cpp11()
+{
+}
+
+template<class TMutex>
+void GpMutex_Cpp11<TMutex>::Destroy()
+{
+	this->~GpMutex_Cpp11();
+	free(this);
+}
+
+template<class TMutex>
+void GpMutex_Cpp11<TMutex>::Lock()
+{
+	m_mutex.lock();
+}
+
+template<class TMutex>
+void GpMutex_Cpp11<TMutex>::Unlock()
+{
+	m_mutex.unlock();
+}
+
+typedef GpMutex_Cpp11<std::mutex> GpMutex_Cpp11_Vanilla;
+typedef GpMutex_Cpp11<std::recursive_mutex> GpMutex_Cpp11_Recursive;
+
+
+class GpThreadEvent_Cpp11 final : public PortabilityLayer::HostThreadEvent
+{
+public:
+	GpThreadEvent_Cpp11();
+	~GpThreadEvent_Cpp11();
+
+	void Wait() override;
+	bool WaitTimed(uint32_t msec) override;
+	void Signal() override;
+	void Destroy() override;
+
+private:
+	std::mutex m_mutex;
+	std::condition_variable m_cvar;
+	bool m_flag;
+};
+
+GpThreadEvent_Cpp11::GpThreadEvent_Cpp11()
+	: m_flag(false)
+{
+}
+
+GpThreadEvent_Cpp11::~GpThreadEvent_Cpp11()
+{
+}
+
+void GpThreadEvent_Cpp11::Wait()
+{
+	std::unique_lock<std::mutex> lock(m_mutex);
+	m_cvar.wait(lock,[&]()->bool{ return m_flag; });
+}
+
+bool GpThreadEvent_Cpp11::WaitTimed(uint32_t msec)
+{
+	std::unique_lock<std::mutex> lock(m_mutex);
+	if (!m_cvar.wait_for(lock, std::chrono::milliseconds(msec), [&]()->bool{ return m_flag; }))
+		return false;
+	return true;
+}
+
+void GpThreadEvent_Cpp11::Signal()
+{
+	m_mutex.lock();
+	m_flag = true;
+	m_mutex.unlock();
+	m_cvar.notify_all();
+}
+
+void GpThreadEvent_Cpp11::Destroy()
+{
+	this->~GpThreadEvent_Cpp11();
+	free(this);
+}
+
+GpSystemServices_Android::GpSystemServices_Android()
+{
+}
+
+int64_t GpSystemServices_Android::GetTime() const
+{
+	time_t t = time(nullptr);
+	return static_cast<int64_t>(t) - 2082844800;
+}
+
+void GpSystemServices_Android::GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const
+{
+	time_t t = time(nullptr);
+	tm *tmObject = localtime(&t);
+	year = static_cast<unsigned int>(tmObject->tm_year);
+	month = static_cast<unsigned int>(tmObject->tm_mon);
+	hour = static_cast<unsigned int>(tmObject->tm_hour);
+	minute = static_cast<unsigned int>(tmObject->tm_min);
+	second = static_cast<unsigned int>(tmObject->tm_sec);
+}
+
+PortabilityLayer::HostMutex *GpSystemServices_Android::CreateMutex()
+{
+	GpMutex_Cpp11_Vanilla *mutex = static_cast<GpMutex_Cpp11_Vanilla*>(malloc(sizeof(GpMutex_Cpp11_Vanilla)));
+	if (!mutex)
+		return nullptr;
+
+	return new (mutex) GpMutex_Cpp11_Vanilla();
+}
+
+PortabilityLayer::HostMutex *GpSystemServices_Android::CreateRecursiveMutex()
+{
+	GpMutex_Cpp11_Recursive *mutex = static_cast<GpMutex_Cpp11_Recursive*>(malloc(sizeof(GpMutex_Cpp11_Recursive)));
+	if (!mutex)
+		return nullptr;
+
+	return new (mutex) GpMutex_Cpp11_Recursive();
+}
+
+PortabilityLayer::HostThreadEvent *GpSystemServices_Android::CreateThreadEvent(bool autoReset, bool startSignaled)
+{
+	GpThreadEvent_Cpp11 *evt = static_cast<GpThreadEvent_Cpp11*>(malloc(sizeof(GpThreadEvent_Cpp11)));
+	if (!evt)
+		return nullptr;
+
+	return new (evt) GpThreadEvent_Cpp11();
+}
+
+uint64_t GpSystemServices_Android::GetFreeMemoryCosmetic() const
+{
+	return 0;
+}
+
+void GpSystemServices_Android::Beep() const
+{
+}
+
+GpSystemServices_Android *GpSystemServices_Android::GetInstance()
+{
+	return &ms_instance;
+}
+
+GpSystemServices_Android GpSystemServices_Android::ms_instance;

AerofoilAndroid/app/jni/main/GpSystemServices_Android.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "HostSystemServices.h"
+#include "GpCoreDefs.h"
+
+class GpSystemServices_Android final : public PortabilityLayer::HostSystemServices
+{
+public:
+	GpSystemServices_Android();
+
+	int64_t GetTime() const override;
+	void GetLocalDateTime(unsigned int &year, unsigned int &month, unsigned int &day, unsigned int &hour, unsigned int &minute, unsigned int &second) const override;
+	PortabilityLayer::HostMutex *CreateMutex() override;
+	PortabilityLayer::HostMutex *CreateRecursiveMutex() override;
+	PortabilityLayer::HostThreadEvent *CreateThreadEvent(bool autoReset, bool startSignaled) override;
+	uint64_t GetFreeMemoryCosmetic() const override;
+	void Beep() const override;
+
+	static GpSystemServices_Android *GetInstance();
+
+private:
+	static GpSystemServices_Android ms_instance;
+};

AerofoilAndroid/app/src/main/.gitignore

@@ -0,0 +1 @@
+assets