AndrewShkrob/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Merge pull request #696 from rokuz/drape-2.0

Browse source 
[DO NOT MERGE] Drape 2.0
This commit is contained in:
Viktor Govako 2015-11-30 18:37:00 +03:00
commit ba0fea3aaf
1626 changed files with 96271 additions and 104493 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.gitignore vendored
View file

@ -58,6 +58,7 @@ iphone/*/build/*
xcode/**/xcuserdata
xcode/**/xcshareddata
tools/emacsmode/build
**/DerivedData/*
# GeneratedFiles
version/version.hpp
@ -76,7 +77,7 @@ bada/Maps/*.zip
# data
data/intermediate_data
data/*.mwm
data/**/*.mwm
!data/World.mwm
!data/WorldCoasts.mwm
# temporary files for downloader

2
3party/fribidi/config.h
View file

@ -1,4 +1,4 @@
#include "../../std/target_os.hpp"
#include "std/target_os.hpp"
#if defined(OMIM_OS_MAC)
#include "config_mac.h"

2
3party/jansson/jansson_handle.hpp
View file

@ -1,6 +1,6 @@
#pragma once
#include "../../std/algorithm.hpp"
#include "std/algorithm.hpp"
struct json_struct_t;

2
3party/jansson/myjansson.hpp
View file

@ -2,7 +2,7 @@
#include "jansson_handle.hpp"
#include "../../base/exception.hpp"
#include "base/exception.hpp"
#include <jansson.h>

9
3party/sdf_image/sdf_image.cpp
View file

@ -1,16 +1,13 @@
/*
Copyright (C) 2009 by Stefan Gustavson
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
@ -20,7 +17,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include "drape/sdf_image.h"
#include "sdf_image.h"
#include "base/math.hpp"
#include "base/scope_guard.hpp"
@ -28,7 +25,7 @@ THE SOFTWARE.
#include "std/limits.hpp"
#include "std/bind.hpp"
namespace dp
namespace sdf_image
{
namespace
@ -508,4 +505,4 @@ bool SdfImage::Transform(int baseIndex, int offset, int dx, int dy, vector<short
return false;
}
} // namespace dp
} // namespace sdf_image

10
3party/sdf_image/sdf_image.h
View file

@ -28,12 +28,12 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include "../base/buffer_vector.hpp"
#include "base/buffer_vector.hpp"
#include "../std/vector.hpp"
#include "../std/function.hpp"
#include "std/vector.hpp"
#include "std/function.hpp"
namespace dp
namespace sdf_image
{
class SdfImage
@ -77,4 +77,4 @@ private:
buffer_vector<float, 512> m_data;
};
} // namespace dp
} // namespace sdf_image

5
android/UnitTests/jni/mock.cpp
View file

@ -189,11 +189,6 @@ namespace android_tests
bool HasAvailableSpaceForWriting(uint64_t size) const{ return true; }
static void RunOnGuiThreadImpl(TFunctor const & fn, bool blocking = false)
{
ASSERT(false, ());
}
static Platform & Instance()
{
static Platform platform;

1
android/assets/colors.txt Symbolic link
View file

@ -0,0 +1 @@
../../data/colors.txt

1
android/assets/patterns.txt Symbolic link
View file

@ -0,0 +1 @@
../../data/patterns.txt

1
android/assets/resources-default Symbolic link
View file

@ -0,0 +1 @@
../../data/resources-default

2
android/build.gradle
View file

@ -256,7 +256,7 @@ android {
// We don't compress these extensions in assets/ because our random FileReader can't read zip-compressed files from apk
aaptOptions {
noCompress 'txt', 'bin', 'skn', 'html', 'png', 'json', 'mwm', 'ttf'
noCompress 'txt', 'bin', 'html', 'png', 'json', 'mwm', 'ttf', 'sdf', 'ui'
ignoreAssetsPattern "!.svn:!.git:!.DS_Store:!*.scc:.*:<dir>_*:!CVS:!thumbs.db:!picasa.ini:!*~"
}

29
android/jni/Android.mk
View file

@ -25,7 +25,7 @@ define add_prebuild_static_lib
include $(PREBUILT_STATIC_LIBRARY)
endef
prebuild_static_libs := osrm protobuf tomcrypt jansson minizip fribidi freetype expat base coding geometry anim platform graphics indexer storage search routing gui render map stats_client succinct opening_hours
prebuild_static_libs := osrm protobuf tomcrypt jansson minizip fribidi freetype expat base coding geometry platform indexer storage search routing drape drape_frontend map stats_client succinct opening_hours
$(foreach item,$(prebuild_static_libs),$(eval $(call add_prebuild_static_lib,$(item))))
@ -40,7 +40,7 @@ LOCAL_CPP_FEATURES += exceptions rtti
LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../
LOCAL_MODULE := mapswithme
LOCAL_STATIC_LIBRARIES := map render gui routing search storage indexer graphics platform anim geometry coding base expat freetype fribidi minizip jansson tomcrypt protobuf osrm stats_client succinct opening_hours
LOCAL_STATIC_LIBRARIES := map drape_frontend routing search storage indexer drape platform geometry coding base expat freetype fribidi minizip jansson tomcrypt protobuf osrm stats_client succinct opening_hours
LOCAL_CFLAGS := -ffunction-sections -fdata-sections -Wno-extern-c-compat
ifneq ($(NDK_DEBUG),1)
@ -60,21 +60,18 @@ LOCAL_HEADER_FILES := \
../../private.h \
com/mapswithme/core/jni_helper.hpp \
com/mapswithme/core/logging.hpp \
com/mapswithme/core/render_context.hpp \
com/mapswithme/maps/Framework.hpp \
com/mapswithme/maps/MapStorage.hpp \
com/mapswithme/platform/Platform.hpp \
com/mapswithme/platform/MethodRef.hpp \
com/mapswithme/platform/http_thread_android.hpp \
nv_thread/nv_thread.hpp \
nv_event/nv_event_queue.hpp \
nv_event/nv_event.hpp \
nv_event/nv_keycode_mapping.hpp \
nv_event/scoped_profiler.hpp
com/mapswithme/opengl/android_gl_utils.hpp \
com/mapswithme/opengl/androidoglcontext.hpp \
com/mapswithme/opengl/androidoglcontextfactory.hpp \
LOCAL_SRC_FILES := \
com/mapswithme/core/jni_helper.cpp \
com/mapswithme/core/logging.cpp \
com/mapswithme/core/render_context.cpp \
com/mapswithme/country/country_helper.cpp \
com/mapswithme/country/CountryTree.cpp \
com/mapswithme/country/ActiveCountryTree.cpp \
@ -83,10 +80,8 @@ LOCAL_SRC_FILES := \
com/mapswithme/maps/bookmarks/data/BookmarkManager.cpp \
com/mapswithme/maps/bookmarks/data/BookmarkCategory.cpp \
com/mapswithme/maps/sound/tts.cpp \
com/mapswithme/maps/VideoTimer.cpp \
com/mapswithme/maps/MapFragment.cpp \
com/mapswithme/maps/MwmApplication.cpp \
com/mapswithme/maps/Lifecycle.cpp \
com/mapswithme/maps/LocationState.cpp \
com/mapswithme/maps/MapStorage.cpp \
com/mapswithme/maps/DownloadResourcesActivity.cpp \
@ -97,15 +92,15 @@ LOCAL_SRC_FILES := \
com/mapswithme/platform/Platform.cpp \
com/mapswithme/platform/HttpThread.cpp \
com/mapswithme/platform/Language.cpp \
com/mapswithme/platform/MethodRef.cpp \
com/mapswithme/platform/PThreadImpl.cpp \
com/mapswithme/util/StringUtils.cpp \
com/mapswithme/util/Config.cpp \
nv_thread/nv_thread.cpp \
nv_event/nv_event_queue.cpp \
nv_event/nv_event.cpp \
nv_time/nv_time.cpp \
com/mapswithme/util/Config.cpp \
com/mapswithme/opengl/android_gl_utils.cpp \
com/mapswithme/opengl/androidoglcontext.cpp \
com/mapswithme/opengl/androidoglcontextfactory.cpp \
LOCAL_LDLIBS := -llog -lGLESv2 -latomic -lz
LOCAL_LDLIBS := -llog -landroid -lEGL -lGLESv2 -latomic -lz
LOCAL_LDLIBS += -Wl,--gc-sections

3
android/jni/Application.mk
View file

@ -15,7 +15,8 @@ endif
LOCAL_PATH := $(call my-dir)
APP_CFLAGS += -I$(LOCAL_PATH)/../../3party/boost \
-I$(LOCAL_PATH)/../../3party/protobuf/src
-I$(LOCAL_PATH)/../../3party/protobuf/src \
-I$(LOCAL_PATH)/../../3party/glm
APP_GNUSTL_FORCE_CPP_FEATURES := exceptions rtti

2
android/jni/com/mapswithme/core/jni_helper.cpp
View file

@ -30,8 +30,6 @@ extern "C"
g_jvm = jvm;
jni::InitSystemLog();
jni::InitAssertLog();
// @TODO remove line below after refactoring
InitNVEvent(jvm);
JNIEnv * env = jni::GetEnv();
// TODO

6
android/jni/com/mapswithme/country/ActiveCountryTree.cpp
View file

@ -103,8 +103,10 @@ extern "C"
JNIEXPORT void JNICALL
Java_com_mapswithme_country_ActiveCountryTree_showOnMap(JNIEnv * env, jclass clazz, jint group, jint position)
{
GetMapLayout().ShowMap(ToGroup(group), position);
g_framework->DontLoadState();
g_framework->PostDrapeTask([group, position]()
{
GetMapLayout().ShowMap(ToGroup(group), position);
});
}
JNIEXPORT void JNICALL

6
android/jni/com/mapswithme/country/CountryTree.cpp
View file

@ -92,8 +92,10 @@ extern "C"
JNIEXPORT void JNICALL
Java_com_mapswithme_country_CountryTree_showLeafOnMap(JNIEnv * env, jclass clazz, jint position)
{
GetTree().ShowLeafOnMap(position);
g_framework->DontLoadState();
g_framework->PostDrapeTask([position]()
{
GetTree().ShowLeafOnMap(position);
});
}
JNIEXPORT jlong JNICALL

6
android/jni/com/mapswithme/maps/DownloadResourcesActivity.cpp
View file

@ -55,9 +55,9 @@ extern "C"
{
switch (pl.GetWritableStorageStatus(fileSize))
{
case Platform::STORAGE_DISCONNECTED: return ERR_STORAGE_DISCONNECTED;
case Platform::NOT_ENOUGH_SPACE: return ERR_NOT_ENOUGH_FREE_SPACE;
default: return fileSize;
case Platform::STORAGE_DISCONNECTED: return ERR_STORAGE_DISCONNECTED;
case Platform::NOT_ENOUGH_SPACE: return ERR_NOT_ENOUGH_FREE_SPACE;
default: return fileSize;
}
}

1324
android/jni/com/mapswithme/maps/Framework.cpp
View file

File diff suppressed because it is too large Load diff

119
android/jni/com/mapswithme/maps/Framework.hpp
View file

@ -6,23 +6,25 @@
#include "search/result.hpp"
#include "drape_frontend/gui/skin.hpp"
#include "drape/pointers.hpp"
#include "drape/oglcontextfactory.hpp"
#include "platform/country_defines.hpp"
#include "platform/location.hpp"
#include "geometry/avg_vector.hpp"
#include "base/deferred_task.hpp"
#include "base/timer.hpp"
#include "indexer/map_style.hpp"
#include "std/map.hpp"
#include "std/mutex.hpp"
#include "std/shared_ptr.hpp"
#include "std/unique_ptr.hpp"
#include "../../../nv_event/nv_event.hpp"
class CountryStatusDisplay;
#include "std/cstdint.hpp"
namespace android
{
@ -30,11 +32,10 @@ namespace android
public storage::ActiveMapsLayout::ActiveMapsListener
{
private:
drape_ptr<dp::ThreadSafeFactory> m_contextFactory;
::Framework m_work;
VideoTimer * m_videoTimer;
typedef shared_ptr<jobject> TJobject;
TJobject m_javaCountryListener;
typedef map<int, TJobject> TListenerMap;
TListenerMap m_javaActiveMapListeners;
@ -42,86 +43,80 @@ namespace android
int m_activeMapsConnectionID;
void CallRepaint();
double m_x1;
double m_y1;
double m_x2;
double m_y2;
int m_mask;
bool m_doLoadState;
/// @name Single click processing parameters.
//@{
my::Timer m_doubleClickTimer;
bool m_isCleanSingleClick;
double m_lastX1;
double m_lastY1;
//@}
math::LowPassVector<float, 3> m_sensors[2];
double m_lastCompass;
unique_ptr<DeferredTask> m_deferredTask;
bool m_wasLongClick;
int m_densityDpi;
int m_screenWidth;
int m_screenHeight;
void StartTouchTask(double x, double y, unsigned ms);
void KillTouchTask();
void OnProcessTouchTask(double x, double y, unsigned ms);
string m_searchQuery;
void SetBestDensity(int densityDpi, RenderPolicy::Params & params);
map<gui::EWidget, gui::Position> m_guiPositions;
bool InitRenderPolicyImpl(int densityDpi, int screenWidth, int screenHeight);
void MyPositionModeChanged(location::EMyPositionMode mode);
location::TMyPositionModeChanged m_myPositionModeSignal;
location::EMyPositionMode m_currentMode;
bool m_isCurrentModeInitialized;
public:
Framework();
~Framework();
storage::Storage & Storage();
CountryStatusDisplay * GetCountryStatusDisplay();
void DontLoadState() { m_doLoadState = false; }
void ShowCountry(storage::TIndex const & idx, bool zoomToDownloadButton);
storage::TStatus GetCountryStatus(storage::TIndex const & idx) const;
void OnLocationError(int/* == location::TLocationStatus*/ newStatus);
void OnLocationUpdated(location::GpsInfo const & info);
void OnCompassUpdated(location::CompassInfo const & info, bool force);
void OnCompassUpdated(location::CompassInfo const & info, bool forceRedraw);
void UpdateCompassSensor(int ind, float * arr);
void Invalidate();
bool InitRenderPolicy(int densityDpi, int screenWidth, int screenHeight);
void DeleteRenderPolicy();
bool CreateDrapeEngine(JNIEnv * env, jobject jSurface, int densityDpi);
void DeleteDrapeEngine();
bool IsDrapeEngineCreated();
void DetachSurface();
void AttachSurface(JNIEnv * env, jobject jSurface);
void SetMapStyle(MapStyle mapStyle);
MapStyle GetMapStyle() const;
void SetupMeasurementSystem();
void SetRouter(routing::RouterType type) { m_work.SetRouter(type); }
routing::RouterType GetRouter() const { return m_work.GetRouter(); }
routing::RouterType GetLastUsedRouter() const { return m_work.GetLastUsedRouter(); }
void Resize(int w, int h);
void DrawFrame();
struct Finger
{
Finger(int64_t id, float x, float y)
: m_id(id)
, m_x(x)
, m_y(y)
{
}
void Move(int mode, double x, double y);
void Zoom(int mode, double x1, double y1, double x2, double y2);
void Touch(int action, int mask, double x1, double y1, double x2, double y2);
int64_t m_id;
float m_x, m_y;
};
void Touch(int action, Finger const & f1, Finger const & f2, uint8_t maskedPointer);
/// Show rect from another activity. Ensure that no LoadState will be called,
/// when main map activity will become active.
void ShowSearchResult(search::Result const & r);
void ShowAllSearchResults(search::Results const & results);
bool Search(search::SearchParams const & params);
string GetLastSearchQuery() { return m_searchQuery; }
void ClearLastSearchQuery() { m_searchQuery.clear(); }
void LoadState();
void SaveState();
void SetupMeasurementSystem();
void AddLocalMaps();
void RemoveLocalMaps();
@ -133,14 +128,13 @@ namespace android
void AddString(string const & name, string const & value);
void Scale(double k);
void Scale(::Framework::EScaleMode mode);
BookmarkAndCategory AddBookmark(size_t category, m2::PointD const & pt, BookmarkData & bm);
void ReplaceBookmark(BookmarkAndCategory const & ind, BookmarkData & bm);
size_t ChangeBookmarkCategory(BookmarkAndCategory const & ind, size_t newCat);
::Framework * NativeFramework();
PinClickManager & GetPinClickManager() { return m_work.GetBalloonManager(); }
bool IsDownloadingActive();
@ -158,9 +152,21 @@ namespace android
int AddActiveMapsListener(shared_ptr<jobject> obj);
void RemoveActiveMapsListener(int slotID);
void SetMyPositionModeListener(location::TMyPositionModeChanged const & fn);
location::EMyPositionMode GetMyPositionMode() const;
void SetMyPositionMode(location::EMyPositionMode mode);
void SetupWidget(gui::EWidget widget, float x, float y, dp::Anchor anchor);
void ApplyWidgets();
void CleanWidgets();
// Fills mapobject's metadata from UserMark
void InjectMetadata(JNIEnv * env, jclass clazz, jobject const mapObject, UserMark const * userMark);
using TDrapeTask = function<void()>;
// Posts a task which must be executed when Drape Engine is alive.
void PostDrapeTask(TDrapeTask && task);
public:
virtual void ItemStatusChanged(int childPosition);
virtual void ItemProgressChanged(int childPosition, storage::LocalAndRemoteSizeT const & sizes);
@ -174,6 +180,13 @@ namespace android
MapOptions const & newOpt);
virtual void DownloadingProgressUpdate(storage::ActiveMapsLayout::TGroup const & group, int position,
storage::LocalAndRemoteSizeT const & progress);
private:
vector<TDrapeTask> m_drapeTasksQueue;
mutex m_drapeQueueMutex;
// This method must be executed under mutex m_drapeQueueMutex.
void ExecuteDrapeTasks();
};
}

290
android/jni/com/mapswithme/maps/Lifecycle.cpp
View file

@ -1,290 +0,0 @@
#include <jni.h>
#include <android/log.h>
#include "../../../nv_event/nv_event.hpp"
#include "base/logging.hpp"
#include "graphics/opengl/opengl.hpp"
#include "Framework.hpp"
#include "../platform/Platform.hpp"
#define MODULE "MapsWithMe"
#define NVDEBUG(args...) __android_log_print(ANDROID_LOG_DEBUG, MODULE, ## args)
static int32_t s_winWidth = 1;
static int32_t s_winHeight = 1;
static int32_t s_densityDpi = 1;
static bool s_glesLoaded = false;
bool SetupGLESResources()
{
if (s_glesLoaded)
return true;
if (!g_framework->InitRenderPolicy(s_densityDpi, s_winWidth, s_winHeight))
{
NVEventReportUnsupported();
return false;
}
else
NVEventOnRenderingInitialized();
s_glesLoaded = true;
return true;
}
bool ShutdownGLESResources()
{
if (!s_glesLoaded)
return true;
// We cannot use GLES calls to release the resources if the context is
// not bound. In that case, we simply shut down EGL, which has code to
// explicitly delete the context
if (!NVEventStatusEGLIsBound())
{
NVDEBUG("ShutdownGLESResources: GLES not bound, shutting down EGL to release");
graphics::gl::g_hasContext = false;
g_framework->DeleteRenderPolicy();
graphics::gl::g_hasContext = true;
NVDEBUG("Cleaning up EGL");
if (NVEventCleanupEGL())
{
s_glesLoaded = false;
return true;
}
else
{
return false;
}
}
NVDEBUG("ShutdownGLESResources event: GLES bound, manually deleting GLES resources");
g_framework->DeleteRenderPolicy();
s_glesLoaded = false;
return true;
}
bool renderFrame(bool allocateIfNeeded)
{
if (!NVEventReadyToRenderEGL(allocateIfNeeded))
return false;
// We've gotten this far, so EGL is ready for us. Have we loaded our assets?
// Note that we cannot use APP_STATUS_GLES_LOADED to imply that EGL is
// ready to render. We can have a valid context with all GLES resources loaded
// into it but no surface and thus the context not bound. These are semi-
// independent states.
if (!s_glesLoaded)
{
if (!allocateIfNeeded)
return false;
if (!SetupGLESResources())
return false;
}
g_framework->DrawFrame();
return true;
}
namespace
{
const int32_t TIMEOUT_FOREGROUND_IN_FOCUS = 1; // msec
const int32_t TIMEOUT_FOREGROUND_NOT_IN_FOCUS = 100; // msec
int32_t GetEventQueueTimeout(bool isAppInBackground)
{
if (isAppInBackground)
return NV_EVENT_WAIT_FOREVER;
else
return (NVEventStatusIsFocused() ? TIMEOUT_FOREGROUND_IN_FOCUS : TIMEOUT_FOREGROUND_NOT_IN_FOCUS);
}
} // namespace
// Add any initialization that requires the app Java classes
// to be accessible (such as nv_shader_init, NvAPKInit, etc,
// as listed in the docs)
int32_t NVEventAppInit(int32_t argc, char** argv)
{
return 0;
}
int32_t NVEventAppMain(int32_t argc, char** argv)
{
s_glesLoaded = false;
bool isAppInBackground = true;
NVDEBUG("Application entering main loop");
while (NVEventStatusIsRunning())
{
const NVEvent* ev = NULL;
while (NVEventStatusIsRunning() &&
(ev = NVEventGetNextEvent(GetEventQueueTimeout(isAppInBackground))))
{
switch (ev->m_type)
{
case NV_EVENT_KEY:
NVDEBUG( "Key event: 0x%02x %s",
ev->m_data.m_key.m_code,
(ev->m_data.m_key.m_action == NV_KEYACTION_DOWN) ? "down" : "up");
if ((ev->m_data.m_key.m_code == NV_KEYCODE_BACK))
{
renderFrame(false);
NVEventDoneWithEvent(true);
}
else
{
NVEventDoneWithEvent(false);
}
ev = NULL;
break;
case NV_EVENT_CHAR:
NVDEBUG("Char event: 0x%02x", ev->m_data.m_char.m_unichar);
ev = NULL;
NVEventDoneWithEvent(false);
break;
case NV_EVENT_LONG_CLICK:
break;
case NV_EVENT_TOUCH:
{
switch (ev->m_data.m_touch.m_action)
{
case NV_TOUCHACTION_DOWN:
g_framework->Move(0, ev->m_data.m_touch.m_x, ev->m_data.m_touch.m_y);
break;
case NV_TOUCHACTION_MOVE:
g_framework->Move(1, ev->m_data.m_touch.m_x, ev->m_data.m_touch.m_y);
break;
case NV_TOUCHACTION_UP:
g_framework->Move(2, ev->m_data.m_touch.m_x, ev->m_data.m_touch.m_y);
break;
}
}
break;
case NV_EVENT_MULTITOUCH:
{
int maskOnly = (ev->m_data.m_multi.m_action & NV_MULTITOUCH_POINTER_MASK) >> (NV_MULTITOUCH_POINTER_SHIFT);
int action = ev->m_data.m_multi.m_action & NV_MULTITOUCH_ACTION_MASK;
g_framework->Touch(action, maskOnly, ev->m_data.m_multi.m_x1, ev->m_data.m_multi.m_y1,
ev->m_data.m_multi.m_x2, ev->m_data.m_multi.m_y2);
}
break;
case NV_EVENT_SURFACE_CREATED:
case NV_EVENT_SURFACE_SIZE:
s_winWidth = ev->m_data.m_size.m_w;
s_winHeight = ev->m_data.m_size.m_h;
s_densityDpi = ev->m_data.m_size.m_density;
g_framework->Resize(s_winWidth, s_winHeight);
g_framework->NativeFramework()->Invalidate(true);
NVDEBUG( "Surface create/resize event: %d x %d", s_winWidth, s_winHeight);
break;
case NV_EVENT_SURFACE_DESTROYED:
NVDEBUG("Surface destroyed event");
NVEventDestroySurfaceEGL();
break;
case NV_EVENT_FOCUS_LOST:
NVDEBUG("Focus lost event");
renderFrame(false);
break;
case NV_EVENT_PAUSE:
NVDEBUG("Pause event");
renderFrame(false);
break;
case NV_EVENT_STOP:
NVDEBUG("Stop event");
// As per Google's recommendation, we release GLES resources here
ShutdownGLESResources();
isAppInBackground = true;
break;
case NV_EVENT_QUIT:
NVDEBUG("Quit event");
break;
case NV_EVENT_START:
case NV_EVENT_RESTART:
NVDEBUG("Start/restart event: %s", NVEventGetEventStr(ev->m_type));
isAppInBackground = false;
break;
case NV_EVENT_ACCEL:
case NV_EVENT_RESUME:
case NV_EVENT_FOCUS_GAINED:
NVDEBUG("%s event: no specific app action", NVEventGetEventStr(ev->m_type));
break;
case NV_EVENT_MWM:
{
typedef function<void ()> FnT;
FnT * pFn = reinterpret_cast<FnT *>(ev->m_data.m_mwm.m_pFn);
(*pFn)();
delete pFn;
break;
}
default:
NVDEBUG("UNKNOWN event");
break;
};
// if we do not NULL out the event, then we return that
// we handled it by default
if (ev)
NVEventDoneWithEvent(true);
}
// Do not bother to initialize _any_ of EGL, much less go ahead
// and render to the screen unless we have all we need to go
// ahead and do our thing. In many cases,
// devices will bring us part-way up and then take us down.
// So, before we bother to init EGL (much less the rendering
// surface, check that:
// - we are focused
// - we have a rendering surface
// - the surface size is not 0x0
// - we are resumed, not paused
if (NVEventStatusIsInteractable())
{
// This will try to set up EGL if it isn't set up
// When we first set up EGL completely, we also load our GLES resources
// If these are already set up or we succeed at setting them all up now, then
// we go ahead and render.
renderFrame(true);
}
}
NVDEBUG("cleanup!!!");
NVEventCleanupEGL();
return 0;
}

32
android/jni/com/mapswithme/maps/LocationState.cpp
View file

@ -4,53 +4,43 @@
#include "../platform/Platform.hpp"
location::State * GetLocationState()
{
return g_framework->NativeFramework()->GetLocationState().get();
}
extern "C"
{
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_LocationState_switchToNextMode(JNIEnv * env, jobject thiz)
{
android::Platform::RunOnGuiThreadImpl(bind(&location::State::SwitchToNextMode, GetLocationState()), false);
g_framework->NativeFramework()->SwitchMyPositionNextMode();
}
JNIEXPORT jint JNICALL
Java_com_mapswithme_maps_LocationState_getLocationStateMode(JNIEnv * env, jobject thiz)
{
return GetLocationState()->GetMode();
return g_framework->GetMyPositionMode();
}
void LocationStateModeChanged(location::State::Mode mode, shared_ptr<jobject> const & obj)
void LocationStateModeChanged(location::EMyPositionMode mode, shared_ptr<jobject> const & obj)
{
g_framework->SetMyPositionMode(mode);
JNIEnv * env = jni::GetEnv();
env->CallVoidMethod(*obj.get(), jni::GetJavaMethodID(env, *obj.get(), "onLocationStateModeChangedCallback", "(I)V"), static_cast<jint>(mode));
}
JNIEXPORT jint JNICALL
Java_com_mapswithme_maps_LocationState_addLocationStateModeListener(JNIEnv * env, jobject thiz, jobject obj)
{
return GetLocationState()->AddStateModeListener(bind(&LocationStateModeChanged, _1, jni::make_global_ref(obj)));
env->CallVoidMethod(*obj.get(), jni::GetJavaMethodID(env, *obj.get(), "onMyPositionModeChangedCallback", "(I)V"), static_cast<jint>(mode));
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_LocationState_removeLocationStateModeListener(JNIEnv * env, jobject thiz, jint slotID)
Java_com_mapswithme_maps_LocationState_setMyPositionModeListener(JNIEnv * env, jobject thiz, jobject obj)
{
GetLocationState()->RemoveStateModeListener(slotID);
g_framework->SetMyPositionModeListener(bind(&LocationStateModeChanged, _1, jni::make_global_ref(obj)));
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_LocationState_turnOff(JNIEnv * env, jobject thiz)
Java_com_mapswithme_maps_LocationState_removeMyPositionModeListener(JNIEnv * env, jobject thiz, jint slotID)
{
GetLocationState()->TurnOff();
g_framework->SetMyPositionModeListener(location::TMyPositionModeChanged());
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_LocationState_invalidatePosition(JNIEnv * env, jobject thiz)
{
android::Platform::RunOnGuiThreadImpl(bind(&location::State::InvalidatePosition, GetLocationState()), false);
g_framework->NativeFramework()->InvalidateMyPosition();
}
}

140
android/jni/com/mapswithme/maps/MapFragment.cpp
View file

@ -7,10 +7,6 @@
#include "../platform/Platform.hpp"
#include "../../../nv_event/nv_event.hpp"
#include "map/country_status_display.hpp"
#include "storage/index.hpp"
#include "base/logging.hpp"
@ -63,40 +59,33 @@ extern "C"
#pragma clang optimize off
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeCompassUpdated(JNIEnv * env, jobject thiz,
jdouble magneticNorth, jdouble trueNorth, jboolean force)
Java_com_mapswithme_maps_MapFragment_nativeCompassUpdated(JNIEnv * env, jclass clazz, jdouble magneticNorth, jdouble trueNorth, jboolean forceRedraw)
{
location::CompassInfo info;
info.m_bearing = (trueNorth >= 0.0) ? trueNorth : magneticNorth;
g_framework->OnCompassUpdated(info, force);
g_framework->OnCompassUpdated(info, forceRedraw);
}
#pragma clang pop_options
JNIEXPORT jfloatArray JNICALL
Java_com_mapswithme_maps_location_LocationHelper_nativeUpdateCompassSensor(
JNIEnv * env, jobject thiz, jint ind, jfloatArray arr)
Java_com_mapswithme_maps_location_LocationHelper_nativeUpdateCompassSensor(JNIEnv * env, jclass clazz, jint ind, jfloatArray arr)
{
int const count = 3;
int const kCoordsCount = 3;
// get Java array
jfloat buffer[3];
env->GetFloatArrayRegion(arr, 0, count, buffer);
// Extract coords
jfloat coords[kCoordsCount];
env->GetFloatArrayRegion(arr, 0, kCoordsCount, coords);
g_framework->UpdateCompassSensor(ind, coords);
// get the result
g_framework->UpdateCompassSensor(ind, buffer);
// pass result back to Java
jfloatArray ret = (jfloatArray)env->NewFloatArray(count);
env->SetFloatArrayRegion(ret, 0, count, buffer);
// Put coords back to java result array
jfloatArray ret = (jfloatArray)env->NewFloatArray(kCoordsCount);
env->SetFloatArrayRegion(ret, 0, kCoordsCount, coords);
return ret;
}
void CallOnDownloadCountryClicked(shared_ptr<jobject> const & obj,
storage::TIndex const & idx,
int options,
jmethodID methodID)
static void CallOnDownloadCountryClicked(shared_ptr<jobject> const & obj, storage::TIndex const & idx, int options, jmethodID methodID)
{
JNIEnv * env = jni::GetEnv();
env->CallVoidMethod(*obj.get(), methodID, idx.m_group, idx.m_country, idx.m_region, options);
@ -105,19 +94,13 @@ extern "C"
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeConnectDownloadButton(JNIEnv * env, jobject thiz)
{
CountryStatusDisplay * display = g_framework->GetCountryStatusDisplay();
jmethodID methodID = jni::GetJavaMethodID(env, thiz, "OnDownloadCountryClicked", "(IIII)V");
display->SetDownloadCountryListener(bind(&CallOnDownloadCountryClicked,
jni::make_global_ref(thiz),
_1,
_2,
methodID));
jmethodID methodID = jni::GetJavaMethodID(env, thiz, "onDownloadCountryClicked", "(IIII)V");
g_framework->NativeFramework()->SetDownloadCountryListener(bind(&CallOnDownloadCountryClicked,
jni::make_global_ref(thiz), _1, _2, methodID));
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeDownloadCountry(JNIEnv * env, jobject thiz, jobject idx, jint options)
Java_com_mapswithme_maps_MapFragment_nativeDownloadCountry(JNIEnv * env, jclass clazz, jobject idx, jint options)
{
storage::TIndex index = storage::ToNative(idx);
storage::ActiveMapsLayout & layout = storage_utils::GetMapLayout();
@ -128,14 +111,99 @@ extern "C"
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeScale(JNIEnv * env, jobject thiz, jdouble k)
Java_com_mapswithme_maps_MapFragment_nativeStorageConnected(JNIEnv * env, jclass clazz)
{
g_framework->Scale(static_cast<double>(k));
android::Platform::Instance().OnExternalStorageStatusChanged(true);
g_framework->AddLocalMaps();
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeStorageDisconnected(JNIEnv * env, jclass clazz)
{
android::Platform::Instance().OnExternalStorageStatusChanged(false);
g_framework->RemoveLocalMaps();
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeScalePlus(JNIEnv * env, jclass clazz)
{
g_framework->Scale(::Framework::SCALE_MAG);
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeScaleMinus(JNIEnv * env, jclass clazz)
{
g_framework->Scale(::Framework::SCALE_MIN);
}
JNIEXPORT jboolean JNICALL
Java_com_mapswithme_maps_MapFragment_showMapForUrl(JNIEnv * env, jobject thiz, jstring url)
Java_com_mapswithme_maps_MapFragment_nativeShowMapForUrl(JNIEnv * env, jclass clazz, jstring url)
{
return g_framework->ShowMapForURL(jni::ToNativeString(env, url));
}
JNIEXPORT jboolean JNICALL
Java_com_mapswithme_maps_MapFragment_nativeCreateEngine(JNIEnv * env, jclass clazz, jobject surface, jint density)
{
return static_cast<jboolean>(g_framework->CreateDrapeEngine(env, surface, static_cast<int>(density)));
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeDestroyEngine(JNIEnv * env, jclass clazz)
{
g_framework->DeleteDrapeEngine();
}
JNIEXPORT jboolean JNICALL
Java_com_mapswithme_maps_MapFragment_nativeIsEngineCreated(JNIEnv * env, jclass clazz)
{
return static_cast<jboolean>(g_framework->IsDrapeEngineCreated());
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeAttachSurface(JNIEnv * env, jclass clazz, jobject surface)
{
g_framework->AttachSurface(env, surface);
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeDetachSurface(JNIEnv * env, jclass clazz)
{
g_framework->DetachSurface();
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeSurfaceChanged(JNIEnv * env, jclass clazz, jint w, jint h)
{
g_framework->Resize(static_cast<int>(w), static_cast<int>(h));
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeOnTouch(JNIEnv * env, jclass clazz, jint action,
jint id1, jfloat x1, jfloat y1,
jint id2, jfloat x2, jfloat y2,
jint maskedPointer)
{
g_framework->Touch(static_cast<int>(action),
android::Framework::Finger(id1, x1, y1),
android::Framework::Finger(id2, x2, y2), maskedPointer);
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeSetupWidget(JNIEnv * env, jclass clazz, jint widget, jfloat x, jfloat y, jint anchor)
{
g_framework->SetupWidget(static_cast<gui::EWidget>(widget), static_cast<float>(x), static_cast<float>(y), static_cast<dp::Anchor>(anchor));
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeApplyWidgets(JNIEnv * env, jclass clazz)
{
g_framework->ApplyWidgets();
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MapFragment_nativeCleanWidgets(JNIEnv * env, jclass clazz)
{
g_framework->CleanWidgets();
}
} // extern "C"

11
android/jni/com/mapswithme/maps/MwmApplication.cpp
View file

@ -4,10 +4,6 @@
#include "../platform/Platform.hpp"
#include "map/information_display.hpp"
#include "map/location_state.hpp"
extern "C"
{
JNIEXPORT void JNICALL
@ -16,6 +12,7 @@ extern "C"
jstring apkPath, jstring storagePath, jstring tmpPath, jstring obbGooglePath,
jstring flavorName, jstring buildType, jboolean isYota, jboolean isTablet)
{
android::Platform::Instance().InitAppMethodRefs(thiz);
android::Platform::Instance().Initialize(
env, apkPath, storagePath, tmpPath, obbGooglePath, flavorName, buildType, isYota, isTablet);
}
@ -27,10 +24,10 @@ extern "C"
g_framework = new android::Framework();
}
JNIEXPORT jboolean JNICALL
Java_com_mapswithme_maps_MwmApplication_nativeIsBenchmarking(JNIEnv * env, jobject thiz)
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_MwmApplication_runNativeFunctor(JNIEnv * env, jobject thiz, jlong functorPointer)
{
return static_cast<jboolean>(g_framework->NativeFramework()->IsBenchmarking());
android::Platform::Instance().CallNativeFunctor(functorPointer);
}
JNIEXPORT jboolean JNICALL

11
android/jni/com/mapswithme/maps/SearchEngine.cpp
View file

@ -201,10 +201,8 @@ extern "C"
Java_com_mapswithme_maps_search_SearchEngine_nativeShowResult(JNIEnv * env, jclass clazz, jint index)
{
lock_guard<mutex> guard(g_resultsMutex);
g_framework->DontLoadState();
Result const & result = g_results.GetResult(index);
android::Platform::RunOnGuiThreadImpl([result]()
g_framework->PostDrapeTask([result]()
{
g_framework->NativeFramework()->ShowSearchResult(result);
});
@ -214,9 +212,8 @@ extern "C"
Java_com_mapswithme_maps_search_SearchEngine_nativeShowAllResults(JNIEnv * env, jclass clazz)
{
lock_guard<mutex> guard(g_resultsMutex);
g_framework->DontLoadState();
android::Platform::RunOnGuiThreadImpl([results=g_results]()
auto results = g_results;
g_framework->PostDrapeTask([results]()
{
g_framework->NativeFramework()->ShowAllSearchResults(results);
});
@ -225,7 +222,7 @@ extern "C"
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_search_SearchEngine_nativeCancelInteractiveSearch(JNIEnv * env, jclass clazz)
{
android::Platform::RunOnGuiThreadImpl([]()
GetPlatform().RunOnGuiThread([]()
{
g_framework->NativeFramework()->CancelInteractiveSearch();
});

5
android/jni/com/mapswithme/maps/bookmarks/data/Bookmark.cpp
View file

@ -11,8 +11,7 @@ namespace
{
BookmarkCategory const * pCat = frm()->GetBmCategory(c);
ASSERT(pCat, ("Category not found", c));
Bookmark const * pBmk = pCat->GetBookmark(b);
ASSERT(pBmk, ("Bookmark not found", c, b));
Bookmark const * pBmk = static_cast<Bookmark const *>(pCat->GetUserMark(b));
return pBmk;
}
}
@ -68,7 +67,7 @@ extern "C"
Java_com_mapswithme_maps_bookmarks_data_Bookmark_getXY(
JNIEnv * env, jobject thiz, jint cat, jlong bmk)
{
return jni::GetNewParcelablePointD(env, getBookmark(cat, bmk)->GetOrg());
return jni::GetNewParcelablePointD(env, getBookmark(cat, bmk)->GetPivot());
}
JNIEXPORT jdouble JNICALL

21
android/jni/com/mapswithme/maps/bookmarks/data/BookmarkCategory.cpp
View file

@ -31,7 +31,10 @@ extern "C"
JNIEnv * env, jobject thiz, jint id, jboolean b)
{
BookmarkCategory * pCat = getBmCategory(id);
pCat->SetVisible(b);
{
BookmarkCategory::Guard guard(*pCat);
guard.m_controller.SetIsVisible(b);
}
pCat->SaveToKMLFile();
}
@ -56,14 +59,14 @@ extern "C"
JNIEnv * env, jobject thiz, jint id)
{
BookmarkCategory * category = getBmCategory(id);
return category->GetBookmarksCount() + category->GetTracksCount();
return category->GetUserMarkCount() + category->GetTracksCount();
}
JNIEXPORT jint JNICALL
Java_com_mapswithme_maps_bookmarks_data_BookmarkCategory_getBookmarksCount(
JNIEnv * env, jobject thiz, jint id)
{
return getBmCategory(id)->GetBookmarksCount();
return getBmCategory(id)->GetUserMarkCount();
}
JNIEXPORT jint JNICALL
@ -81,7 +84,7 @@ extern "C"
jmethodID static const cId = env->GetMethodID(bookmarkClazz, "<init>", "(IILjava/lang/String;)V");
BookmarkCategory * category = getBmCategory(id);
Bookmark const * nBookmark = category->GetBookmark(index);
Bookmark const * nBookmark = static_cast<Bookmark const *>(category->GetUserMark(index));
ASSERT(nBookmark, ("Bookmark must not be null with index:)", index));
@ -111,12 +114,12 @@ extern "C"
string formattedLenght;
MeasurementUtils::FormatDistance(nTrack->GetLengthMeters(), formattedLenght);
graphics::Color nColor = nTrack->GetMainColor();
dp::Color nColor = nTrack->GetColor(0);
jint androidColor = shift(nColor.a, 24) +
shift(nColor.r, 16) +
shift(nColor.g, 8) +
nColor.b;
jint androidColor = shift(nColor.GetAlfa(), 24) +
shift(nColor.GetRed(), 16) +
shift(nColor.GetGreen(), 8) +
nColor.GetBlue();
return env->NewObject(trackClazz, cId,
index, id, jni::ToJavaString(env, nTrack->GetName()),

10
android/jni/com/mapswithme/maps/bookmarks/data/BookmarkManager.cpp
View file

@ -17,8 +17,11 @@ extern "C"
JNIEnv * env, jobject thiz, jint c, jint b)
{
BookmarkAndCategory bnc = BookmarkAndCategory(c,b);
frm()->ShowBookmark(bnc);
frm()->SaveState();
g_framework->PostDrapeTask([bnc]()
{
frm()->ShowBookmark(bnc);
frm()->SaveState();
});
}
JNIEXPORT void JNICALL
@ -54,7 +57,8 @@ extern "C"
BookmarkCategory * pCat = frm()->GetBmCategory(cat);
if (pCat)
{
pCat->DeleteBookmark(bmk);
BookmarkCategory::Guard guard(*pCat);
guard.m_controller.DeleteUserMark(bmk);
pCat->SaveToKMLFile();
}
}

74
android/jni/com/mapswithme/opengl/android_gl_utils.cpp Normal file
View file

@ -0,0 +1,74 @@
#include "android_gl_utils.hpp"
#include "../../../../../base/logging.hpp"
#include "../../../../../base/string_utils.hpp"
namespace android
{
ConfigComparator::ConfigComparator(EGLDisplay display)
: m_display(display)
{
}
int ConfigComparator::operator()(EGLConfig const & l, EGLConfig const & r) const
{
return configWeight(l) - configWeight(r);
}
int ConfigComparator::configWeight(EGLConfig const & config) const
{
int val = -1;
eglGetConfigAttrib(m_display, config, EGL_CONFIG_CAVEAT, &val);
switch (val)
{
case EGL_NONE:
return 0;
case EGL_SLOW_CONFIG:
return 1;
case EGL_NON_CONFORMANT_CONFIG:
return 2;
default:
return 0;
}
}
namespace
{
string GetEglError(EGLint error)
{
switch (error)
{
case EGL_NOT_INITIALIZED : return "EGL_NOT_INITIALIZED";
case EGL_BAD_ACCESS : return "EGL_BAD_ACCESS";
case EGL_BAD_ALLOC : return "EGL_BAD_ALLOC";
case EGL_BAD_ATTRIBUTE : return "EGL_BAD_ATTRIBUTE";
case EGL_BAD_CONFIG : return "EGL_BAD_CONFIG";
case EGL_BAD_CONTEXT : return "EGL_BAD_CONTEXT";
case EGL_BAD_CURRENT_SURFACE : return "EGL_BAD_CURRENT_SURFACE";
case EGL_BAD_DISPLAY : return "EGL_BAD_DISPLAY";
case EGL_BAD_MATCH : return "EGL_BAD_MATCH";
case EGL_BAD_NATIVE_PIXMAP : return "EGL_BAD_NATIVE_PIXMAP";
case EGL_BAD_NATIVE_WINDOW : return "EGL_BAD_NATIVE_WINDOW";
case EGL_BAD_PARAMETER : return "EGL_BAD_PARAMETER";
case EGL_BAD_SURFACE : return "EGL_BAD_SURFACE";
case EGL_CONTEXT_LOST : return "EGL_CONTEXT_LOST";
default: return strings::to_string(error);
}
}
} // namespace
void CheckEGL(my::SrcPoint const & src)
{
EGLint error = eglGetError();
while (error != EGL_SUCCESS)
{
LOG(LERROR, ("SrcPoint : ", src, ". EGL error : ", GetEglError(error)));
error = eglGetError();
}
}
} // namespace android

29
android/jni/com/mapswithme/opengl/android_gl_utils.hpp Normal file
View file

@ -0,0 +1,29 @@
#pragma once
#include "../../../../../base/src_point.hpp"
#include <EGL/egl.h>
#include <GLES2/gl2.h>
namespace android
{
class ConfigComparator
{
public:
ConfigComparator(EGLDisplay display);
int operator()(EGLConfig const & l, EGLConfig const & r) const;
int configWeight(EGLConfig const & config) const;
private:
EGLDisplay m_display;
};
void CheckEGL(my::SrcPoint const & src);
#define CHECK_EGL(x) do { (x); CheckEGL(SRC());} while(false);
#define CHECK_EGL_CALL() do { CheckEGL(SRC());} while (false);
} // namespace android

45
android/jni/opengl/androidoglcontext.cpp → android/jni/com/mapswithme/opengl/androidoglcontext.cpp
View file

@ -1,8 +1,10 @@
#include "androidoglcontext.hpp"
#include "android_gl_utils.hpp"
#include "base/assert.hpp"
#include "base/logging.hpp"
namespace android
{
static EGLint * getContextAttributesList()
{
@ -23,14 +25,14 @@ AndroidOGLContext::AndroidOGLContext(EGLDisplay display, EGLSurface surface, EGL
EGLContext sharedContext = (contextToShareWith == NULL) ? EGL_NO_CONTEXT : contextToShareWith->m_nativeContext;
m_nativeContext = eglCreateContext(m_display, config, sharedContext, getContextAttributesList());
CHECK(m_nativeContext != EGL_NO_CONTEXT, ());
}
AndroidOGLContext::~AndroidOGLContext()
{
// Native context must exist
eglDestroyContext(m_display, m_nativeContext);
if (eglDestroyContext(m_display, m_nativeContext) == EGL_FALSE)
CHECK_EGL_CALL();
}
void AndroidOGLContext::setDefaultFramebuffer()
@ -40,12 +42,41 @@ void AndroidOGLContext::setDefaultFramebuffer()
void AndroidOGLContext::makeCurrent()
{
if (eglMakeCurrent(m_display, m_surface, m_surface, m_nativeContext) != EGL_TRUE)
LOG(LINFO, ("Failed to set current context:", eglGetError()));
ASSERT(m_surface != EGL_NO_SURFACE, ());
if (eglMakeCurrent(m_display, m_surface, m_surface, m_nativeContext) == EGL_FALSE)
CHECK_EGL_CALL();
}
void AndroidOGLContext::clearCurrent()
{
if (eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT) == EGL_FALSE)
CHECK_EGL_CALL();
}
void AndroidOGLContext::setRenderingEnabled(bool enabled)
{
if (enabled)
makeCurrent();
else
clearCurrent();
}
void AndroidOGLContext::present()
{
if(eglSwapBuffers(m_display, m_surface) != EGL_TRUE)
LOG(LINFO, ("Failed to swap buffers:", eglGetError()));
ASSERT(m_surface != EGL_NO_SURFACE, ());
if (eglSwapBuffers(m_display, m_surface) == EGL_FALSE)
CHECK_EGL_CALL();
}
void AndroidOGLContext::setSurface(EGLSurface surface)
{
m_surface = surface;
ASSERT(m_surface != EGL_NO_SURFACE, ());
}
void AndroidOGLContext::resetSurface()
{
m_surface = EGL_NO_SURFACE;
}
} // namespace android

18
android/jni/opengl/androidoglcontext.hpp → android/jni/com/mapswithme/opengl/androidoglcontext.hpp
View file

@ -4,18 +4,25 @@
#include <GLES2/gl2.h>
#include <EGL/egl.h>
#include <android/native_window.h>
namespace android
{
class AndroidOGLContext : public OGLContext
class AndroidOGLContext : public dp::OGLContext
{
public:
AndroidOGLContext(EGLDisplay display, EGLSurface surface, EGLConfig config, AndroidOGLContext * contextToShareWith);
~AndroidOGLContext();
virtual void makeCurrent();
virtual void present();
virtual void setDefaultFramebuffer();
void makeCurrent() override;
void present() override;
void setDefaultFramebuffer() override;
void setRenderingEnabled(bool enabled) override;
void setSurface(EGLSurface surface);
void resetSurface();
void clearCurrent();
private:
// {@ Owned by Context
@ -28,3 +35,4 @@ private:
// @}
};
} // namespace android

293
android/jni/com/mapswithme/opengl/androidoglcontextfactory.cpp Normal file
View file

@ -0,0 +1,293 @@
#include "androidoglcontextfactory.hpp"
#include "android_gl_utils.hpp"
#include "base/assert.hpp"
#include "base/logging.hpp"
#include "std/algorithm.hpp"
#include <EGL/egl.h>
#include <android/native_window_jni.h>
#include <android/native_window.h>
namespace android
{
static EGLint * getConfigAttributesListRGB8()
{
static EGLint attr_list[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_STENCIL_SIZE, 0,
EGL_DEPTH_SIZE, 16,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
EGL_NONE
};
return attr_list;
}
static EGLint * getConfigAttributesListR5G6B5()
{
static EGLint attr_list[] = {
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_STENCIL_SIZE, 0,
EGL_DEPTH_SIZE, 16,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
EGL_NONE
};
return attr_list;
}
AndroidOGLContextFactory::AndroidOGLContextFactory(JNIEnv * env, jobject jsurface)
: m_drawContext(NULL)
, m_uploadContext(NULL)
, m_windowSurface(EGL_NO_SURFACE)
, m_pixelbufferSurface(EGL_NO_SURFACE)
, m_config(NULL)
, m_nativeWindow(NULL)
, m_display(EGL_NO_DISPLAY)
, m_surfaceWidth(0)
, m_surfaceHeight(0)
, m_windowSurfaceValid(false)
{
m_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (m_display == EGL_NO_DISPLAY)
{
CHECK_EGL_CALL();
return;
}
EGLint version[2] = {0};
if (!eglInitialize(m_display, &version[0], &version[1]))
{
CHECK_EGL_CALL();
return;
}
SetSurface(env, jsurface);
if (!createPixelbufferSurface())
{
CHECK_EGL(eglTerminate(m_display));
return;
}
}
AndroidOGLContextFactory::~AndroidOGLContextFactory()
{
if (m_drawContext != nullptr)
{
delete m_drawContext;
m_drawContext = nullptr;
}
if (m_uploadContext != nullptr)
{
delete m_uploadContext;
m_uploadContext = nullptr;
}
ResetSurface();
if (m_pixelbufferSurface != EGL_NO_SURFACE)
{
eglDestroySurface(m_display, m_pixelbufferSurface);
CHECK_EGL_CALL();
m_pixelbufferSurface = EGL_NO_SURFACE;
}
if (m_display != EGL_NO_DISPLAY)
{
eglTerminate(m_display);
CHECK_EGL_CALL();
}
}
void AndroidOGLContextFactory::SetSurface(JNIEnv * env, jobject jsurface)
{
if (!jsurface)
return;
m_nativeWindow = ANativeWindow_fromSurface(env, jsurface);
if (!m_nativeWindow)
{
LOG(LINFO, ("Can't get native window from Java surface"));
return;
}
if (!createWindowSurface())
{
CHECK_EGL(eglTerminate(m_display));
return;
}
if (!QuerySurfaceSize())
return;
if (m_drawContext != nullptr)
m_drawContext->setSurface(m_windowSurface);
m_windowSurfaceValid = true;
}
void AndroidOGLContextFactory::ResetSurface()
{
if (m_drawContext != nullptr)
m_drawContext->resetSurface();
if (IsValid())
{
eglDestroySurface(m_display, m_windowSurface);
CHECK_EGL_CALL();
m_windowSurface = EGL_NO_SURFACE;
ANativeWindow_release(m_nativeWindow);
m_nativeWindow = NULL;
m_windowSurfaceValid = false;
}
}
bool AndroidOGLContextFactory::IsValid() const
{
return m_windowSurfaceValid && m_pixelbufferSurface != EGL_NO_SURFACE;
}
int AndroidOGLContextFactory::GetWidth() const
{
ASSERT(IsValid(), ());
return m_surfaceWidth;
}
int AndroidOGLContextFactory::GetHeight() const
{
ASSERT(IsValid(), ());
return m_surfaceHeight;
}
void AndroidOGLContextFactory::UpdateSurfaceSize()
{
ASSERT(IsValid(), ());
QuerySurfaceSize();
}
bool AndroidOGLContextFactory::QuerySurfaceSize()
{
EGLint queryResult;
if (eglQuerySurface(m_display, m_windowSurface, EGL_WIDTH, &queryResult) == EGL_FALSE)
{
CHECK_EGL_CALL();
return false;
}
m_surfaceWidth = static_cast<int>(queryResult);
if (eglQuerySurface(m_display, m_windowSurface, EGL_HEIGHT, &queryResult) == EGL_FALSE)
{
CHECK_EGL_CALL();
return false;
}
m_surfaceHeight = static_cast<int>(queryResult);
return true;
}
dp::OGLContext * AndroidOGLContextFactory::getDrawContext()
{
ASSERT(IsValid(), ());
ASSERT(m_windowSurface != EGL_NO_SURFACE, ());
if (m_drawContext == nullptr)
m_drawContext = new AndroidOGLContext(m_display, m_windowSurface, m_config, m_uploadContext);
return m_drawContext;
}
dp::OGLContext * AndroidOGLContextFactory::getResourcesUploadContext()
{
ASSERT(IsValid(), ());
ASSERT(m_pixelbufferSurface != EGL_NO_SURFACE, ());
if (m_uploadContext == nullptr)
m_uploadContext = new AndroidOGLContext(m_display, m_pixelbufferSurface, m_config, m_drawContext);
return m_uploadContext;
}
bool AndroidOGLContextFactory::isDrawContextCreated() const
{
return m_drawContext != nullptr;
}
bool AndroidOGLContextFactory::isUploadContextCreated() const
{
return m_uploadContext != nullptr;
}
bool AndroidOGLContextFactory::createWindowSurface()
{
int const kMaxConfigCount = 40;
EGLConfig configs[kMaxConfigCount];
int count = 0;
if (eglChooseConfig(m_display, getConfigAttributesListRGB8(), configs, kMaxConfigCount, &count) != EGL_TRUE)
{
VERIFY(eglChooseConfig(m_display, getConfigAttributesListR5G6B5(), configs, kMaxConfigCount, &count) == EGL_TRUE, ());
LOG(LDEBUG, ("Backbuffer format: R5G6B5"));
}
else
{
LOG(LDEBUG, ("Backbuffer format: RGB8"));
}
ASSERT(count > 0, ("Didn't find any configs."));
sort(&configs[0], &configs[count], ConfigComparator(m_display));
for (int i = 0; i < count; ++i)
{
EGLConfig currentConfig = configs[i];
EGLint format;
eglGetConfigAttrib(m_display, currentConfig, EGL_NATIVE_VISUAL_ID, &format);
ANativeWindow_setBuffersGeometry(m_nativeWindow, 0, 0, format);
EGLint surfaceAttributes[] = { EGL_RENDER_BUFFER, EGL_BACK_BUFFER, EGL_NONE };
m_windowSurface = eglCreateWindowSurface(m_display, currentConfig, m_nativeWindow, surfaceAttributes);
if (m_windowSurface == EGL_NO_SURFACE)
continue;
else
m_config = currentConfig;
break;
}
if (m_windowSurface == EGL_NO_SURFACE)
{
CHECK_EGL_CALL();
return false;
}
return true;
}
bool AndroidOGLContextFactory::createPixelbufferSurface()
{
//ASSERT(m_config != NULL, ());
const GLuint size = 1; // yes, 1 is the correct size, we dont really draw on it
static EGLint surfaceConfig[] = {
EGL_WIDTH, size,
EGL_HEIGHT, size,
EGL_NONE
};
m_pixelbufferSurface = eglCreatePbufferSurface(m_display, m_config, surfaceConfig);
if (m_pixelbufferSurface == EGL_NO_SURFACE)
{
CHECK_EGL_CALL();
return false;
}
return true;
}
} // namespace android

53
android/jni/com/mapswithme/opengl/androidoglcontextfactory.hpp Normal file
View file

@ -0,0 +1,53 @@
#pragma once
#include "../core/jni_helper.hpp"
#include "androidoglcontext.hpp"
#include "drape/oglcontextfactory.hpp"
namespace android
{
class AndroidOGLContextFactory : public dp::OGLContextFactory
{
public:
AndroidOGLContextFactory(JNIEnv * env, jobject jsurface);
~AndroidOGLContextFactory();
bool IsValid() const;
virtual dp::OGLContext * getDrawContext();
virtual dp::OGLContext * getResourcesUploadContext();
virtual bool isDrawContextCreated() const;
virtual bool isUploadContextCreated() const;
void SetSurface(JNIEnv * env, jobject jsurface);
void ResetSurface();
int GetWidth() const;
int GetHeight() const;
void UpdateSurfaceSize();
private:
bool QuerySurfaceSize();
private:
bool createWindowSurface();
bool createPixelbufferSurface();
AndroidOGLContext * m_drawContext;
AndroidOGLContext * m_uploadContext;
EGLSurface m_windowSurface;
EGLSurface m_pixelbufferSurface;
EGLConfig m_config;
ANativeWindow * m_nativeWindow;
EGLDisplay m_display;
int m_surfaceWidth;
int m_surfaceHeight;
bool m_windowSurfaceValid;
};
} // namespace android

1
android/jni/com/mapswithme/platform/Language.cpp
View file

@ -8,7 +8,6 @@
#include "std/string.hpp"
string ReplaceDeprecatedLanguageCode(string const & lang)
{
// in* -> id

38
android/jni/com/mapswithme/platform/MethodRef.cpp Normal file
View file

@ -0,0 +1,38 @@
#include "MethodRef.hpp"
#include <base/assert.hpp>
#include <base/logging.hpp>
MethodRef::MethodRef(char const * name, char const * signature)
: m_name(name)
, m_signature(signature)
, m_methodID(nullptr)
, m_object(nullptr)
{
LOG(LDEBUG, ("Name = ", name));
}
MethodRef::~MethodRef()
{
if (m_object != nullptr)
jni::GetEnv()->DeleteGlobalRef(m_object);
}
void MethodRef::Init(jobject obj)
{
JNIEnv * env = jni::GetEnv();
m_object = env->NewGlobalRef(obj);
jclass const k = env->GetObjectClass(m_object);
m_methodID = env->GetMethodID(k, m_name, m_signature);
ASSERT(m_object != nullptr, ());
ASSERT(m_methodID != nullptr, ());
}
void MethodRef::CallVoid(jlong arg)
{
JNIEnv * jniEnv = jni::GetEnv();
ASSERT(jniEnv != nullptr, ());
ASSERT(m_object != nullptr, ());
ASSERT(m_methodID != nullptr, ());
jniEnv->CallVoidMethod(m_object, m_methodID, arg);
}

19
android/jni/com/mapswithme/platform/MethodRef.hpp Normal file
View file

@ -0,0 +1,19 @@
#pragma once
#include "../core/jni_helper.hpp"
class MethodRef
{
public:
MethodRef(char const * name, char const * signature);
~MethodRef();
void Init(jobject obj);
void CallVoid(jlong arg);
private:
char const * m_name;
char const * m_signature;
jmethodID m_methodID;
jobject m_object;
};

29
android/jni/com/mapswithme/platform/Platform.cpp
View file

@ -2,8 +2,6 @@
#include "../core/jni_helper.hpp"
#include "../../../nv_event/nv_event.hpp"
#include "platform/settings.hpp"
#include "base/logging.hpp"
@ -72,7 +70,7 @@ string Platform::GetMemoryInfo() const
void Platform::RunOnGuiThread(TFunctor const & fn)
{
android::Platform::RunOnGuiThreadImpl(fn);
android::Platform::Instance().RunOnGuiThread(fn);
}
Platform::EConnectionType Platform::ConnectionStatus()
@ -92,6 +90,11 @@ Platform::EConnectionType Platform::ConnectionStatus()
namespace android
{
Platform::Platform()
: m_runOnUI("runNativeFunctorOnUiThread", "(J)V")
{
}
void Platform::Initialize(JNIEnv * env,
jstring apkPath, jstring storagePath,
jstring tmpPath, jstring obbGooglePath,
@ -142,6 +145,22 @@ namespace android
(void) ConnectionStatus();
}
void Platform::InitAppMethodRefs(jobject appObject)
{
m_runOnUI.Init(appObject);
}
void Platform::CallNativeFunctor(jlong functionPointer)
{
TFunctor * fn = reinterpret_cast<TFunctor *>(functionPointer);
(*fn)();
delete fn;
}
void Platform::OnExternalStorageStatusChanged(bool isAvailable)
{
}
string Platform::GetStoragePathPrefix() const
{
size_t const count = m_writableDir.size();
@ -170,9 +189,9 @@ namespace android
return platform;
}
void Platform::RunOnGuiThreadImpl(TFunctor const & fn, bool blocking)
void Platform::RunOnGuiThread(TFunctor const & fn)
{
postMWMEvent(new TFunctor(fn), blocking);
m_runOnUI.CallVoid(reinterpret_cast<jlong>(new TFunctor(fn)));
}
}

15
android/jni/com/mapswithme/platform/Platform.hpp
View file

@ -2,29 +2,38 @@
#include <jni.h>
#include "platform/platform.hpp"
#include "MethodRef.hpp"
#include "platform/platform.hpp"
namespace android
{
class Platform : public ::Platform
{
public:
Platform();
void Initialize(JNIEnv * env,
jstring apkPath, jstring storagePath,
jstring tmpPath, jstring obbGooglePath,
jstring flavorName, jstring buildType,
bool isYota, bool isTablet);
void InitAppMethodRefs(jobject appObject);
void CallNativeFunctor(jlong functionPointer);
void OnExternalStorageStatusChanged(bool isAvailable);
/// get storage path without ending "/MapsWithMe/"
string GetStoragePathPrefix() const;
/// assign storage path (should contain ending "/MapsWithMe/")
void SetStoragePath(string const & path);
bool HasAvailableSpaceForWriting(uint64_t size) const;
static void RunOnGuiThreadImpl(TFunctor const & fn, bool blocking = false);
void RunOnGuiThread(TFunctor const & fn);
static Platform & Instance();
private:
MethodRef m_runOnUI;
};
}

77
android/jni/nv_debug/nv_debug.hpp
View file

@ -1,77 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_debug.h
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA® Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#ifndef __INCLUDED_NV_DEBUG_H
#define __INCLUDED_NV_DEBUG_H
#define CT_ASSERT(tag,cond) \
enum { COMPILE_TIME_ASSERT__ ## tag = 1/(cond) }
#define dimof( x ) ( sizeof(x) / sizeof(x[0]) )
#include <android/log.h>
#define DBG_DETAILED 0
#if 0
// the detailed prefix can be customised by setting DBG_DETAILED_PREFIX. See
// below as a reference.
// NOTE: fmt is the desired format string and must be in the prefix.
//#ifndef DBG_DETAILED_PREFIX
// #define DBG_DETAILED_PREFIX "%s, %s, line %d: " fmt, __FILE__, __FUNCTION__, __LINE__,
//#endif
//#define DEBUG_D_(fmt, args...)
//#define DEBUG_D(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, MODULE, (DBG_DETAILED_PREFIX) ## args)
#else
#ifdef STRINGIFY
#pragma push_macro("STRINGIFY")
#undef STRINGIFY
#define STRINGIFYPUSHED_____
#endif
#define STRINGIFY(x) #x
// debug macro, includes file name function name and line number
#define TO(x) typeof(x)
#define DEBUG_D_(file, line, fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, MODULE, file ", %s, line(" STRINGIFY(line) "): " fmt, __FUNCTION__, ## args)
#define DEBUG_D(fmt, args...) DEBUG_D_( __FILE__ , __LINE__ , fmt, ## args)
#ifdef STRINGIFYPUSHED_____
#undef STRINGIFYPUSHED_____
#pragma pop_macro("STRINGIFY")
#endif
#endif
// basic debug macro
#define NVDEBUG_(fmt, args...) (__android_log_print(ANDROID_LOG_DEBUG, MODULE, fmt, ## args))
// Debug macro that can be switched to spew a file name,
// function and line number using DEBUG_DETAILED
#if DBG_DETAILED == 1
#define NVDEBUG(fmt, args...) NVDEBUG_D(fmt, ## args)
#else
#define NVDEBUG(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, MODULE, fmt, ## args)
#endif
#endif

925
android/jni/nv_event/nv_event.cpp
View file

@ -1,925 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_event\nv_event.cpp
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA<49> Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#define MODULE "NVEvent"
#define DBG_DETAILED 0
#include "nv_event.hpp"
#include <stdlib.h>
#include <jni.h>
#include <pthread.h>
#include <android/log.h>
#include <GLES2/gl2.h>
//#include <EGL/egl.h>
#include "../nv_time/nv_time.hpp"
#include "../nv_thread/nv_thread.hpp"
#include "../nv_debug/nv_debug.hpp"
#include "scoped_profiler.hpp"
#include "nv_keycode_mapping.hpp"
#include "nv_event_queue.hpp"
#define CT_ASSERT(tag,cond) \
enum { COMPILE_TIME_ASSERT__ ## tag = 1/(cond) }
enum
{
// Android lifecycle status flags. Not app-specific
// Set between onCreate and onDestroy
NVEVENT_STATUS_RUNNING = 0x00000001,
// Set between onResume and onPause
NVEVENT_STATUS_ACTIVE = 0x00000002,
// Set between onWindowFocusChanged(true) and (false)
NVEVENT_STATUS_FOCUSED = 0x00000004,
// Set when the app's SurfaceHolder points to a
// valid, nonzero-sized surface
NVEVENT_STATUS_HAS_REAL_SURFACE = 0x00000008,
// Mask of all app lifecycle status flags, useful for checking when is it
// a reasonable time to be setting up EGL and rendering
NVEVENT_STATUS_INTERACTABLE = 0x0000000f,
// NvEvent EGL status flags. Not app-specific
// Set between calls to NVEventInitEGL and NVEventCleanupEGL
NVEVENT_STATUS_EGL_INITIALIZED = 0x00000010,
// Set when the EGL surface is allocated
NVEVENT_STATUS_EGL_HAS_SURFACE = 0x00000020,
// Set when a surface and context are available and bound
NVEVENT_STATUS_EGL_BOUND = 0x00000040,
};
static unsigned int s_appStatus = 0;
static void ZeroAppFlags()
{
s_appStatus = 0;
}
static void SetAppFlag(unsigned int status)
{
s_appStatus |= status;
}
static void ClearAppFlag(unsigned int status)
{
s_appStatus &= ~status;
}
static bool QueryAppFlag(unsigned int status)
{
return (s_appStatus & status) ? true : false;
}
static bool QueryAppFlagsEqualMasked(unsigned int status, unsigned int mask)
{
return ((s_appStatus & mask) == status) ? true : false;
}
static NVKeyCodeMapping s_keyMapping;
static NVEventQueue s_eventQueue;
static jobject s_globalThiz;
static jfieldID s_lengthId;
static jfieldID s_dataId;
static jfieldID s_widthId;
static jfieldID s_heightId;
static jfieldID s_texDataId;
static pthread_t s_mainThread;
static bool s_appThreadExited = false;
static bool s_javaPostedQuit = false;
static int NVEVENT_ACTION_DOWN = 0;
static int NVEVENT_ACTION_UP = 0;
static int NVEVENT_ACTION_CANCEL = 0;
static int NVEVENT_ACTION_POINTER_INDEX_MASK = 0;
static int NVEVENT_ACTION_POINTER_INDEX_SHIFT = 0;
static int NVEVENT_ACTION_KEY_UP = 0;
class MethodRef
{
public:
MethodRef(const char* name,
const char* signature) :
m_name(name),
m_signature(signature),
m_index(NULL)
{}
bool QueryID(JNIEnv *env, jclass k)
{
m_index = env->GetMethodID(k, m_name, m_signature);
return true;
}
bool CallBoolean()
{
JNIEnv* jniEnv = NVThreadGetCurrentJNIEnv();
if (!jniEnv || !s_globalThiz)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Error: No valid JNI env in %s", m_name);
return false;
}
if (!m_index)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Error: No valid function pointer in %s", m_name);
return false;
}
// __android_log_print(ANDROID_LOG_DEBUG, MODULE, "Calling JNI up to %s", m_name);
return jniEnv->CallBooleanMethod(s_globalThiz, m_index);
}
bool CallInt()
{
JNIEnv* jniEnv = NVThreadGetCurrentJNIEnv();
if (!jniEnv || !s_globalThiz)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Error: No valid JNI env in %s", m_name);
return 0;
}
if (!m_index)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Error: No valid function pointer in %s", m_name);
return false;
}
return (int)jniEnv->CallIntMethod(s_globalThiz, m_index);
}
void CallVoid()
{
JNIEnv * jniEnv = NVThreadGetCurrentJNIEnv();
if (!jniEnv || !s_globalThiz)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Error: No valid JNI env in %s", m_name);
return;
}
if (!m_index)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Error: No valid function pointer in %s", m_name);
return;
}
jniEnv->CallVoidMethod(s_globalThiz, m_index);
}
const char* m_name;
const char* m_signature;
jmethodID m_index;
};
static MethodRef s_InitEGL("InitEGL", "()Z");
static MethodRef s_CleanupEGL("CleanupEGL", "()Z");
static MethodRef s_CreateSurfaceEGL("CreateSurfaceEGL", "()Z");
static MethodRef s_DestroySurfaceEGL("DestroySurfaceEGL", "()Z");
static MethodRef s_SwapBuffersEGL("SwapBuffersEGL", "()Z");
static MethodRef s_BindSurfaceAndContextEGL("BindSurfaceAndContextEGL", "()Z");
static MethodRef s_UnbindSurfaceAndContextEGL("UnbindSurfaceAndContextEGL", "()Z");
static MethodRef s_GetErrorEGL("GetErrorEGL", "()I");
static MethodRef s_finish("finish", "()V");
static MethodRef s_ReportUnsupported("ReportUnsupported", "()V");
static MethodRef s_OnRenderingInitialized("OnRenderingInitialized", "()V");
// True between onCreate and onDestroy
bool NVEventStatusIsRunning()
{
// TBD - need to lock a mutex?
return QueryAppFlag(NVEVENT_STATUS_RUNNING);
}
// True between onResume and onPause
bool NVEventStatusIsActive()
{
// TBD - need to lock a mutex?
return QueryAppFlag(NVEVENT_STATUS_ACTIVE);
}
// True between onWindowFocusChanged(true) and (false)
bool NVEventStatusIsFocused()
{
// TBD - need to lock a mutex?
return QueryAppFlag(NVEVENT_STATUS_FOCUSED);
}
// True when the app's SurfaceHolder points to a
// valid, nonzero-sized window
bool NVEventStatusHasRealSurface()
{
// TBD - need to lock a mutex?
return QueryAppFlag(NVEVENT_STATUS_HAS_REAL_SURFACE);
}
// True when all of IsRunning, IsActive, IsFocused, HasRealSurface are true
// useful for checking when is it a reasonable time to be setting up EGL and rendering
bool NVEventStatusIsInteractable()
{
// TBD - need to lock a mutex?
return QueryAppFlagsEqualMasked(NVEVENT_STATUS_INTERACTABLE, NVEVENT_STATUS_INTERACTABLE);
}
// True between calls to NVEventInitEGL and NVEventCleanupEGL
bool NVEventStatusEGLInitialized()
{
// TBD - need to lock a mutex?
return QueryAppFlag(NVEVENT_STATUS_EGL_INITIALIZED);
}
// True when the EGL surface is allocated
bool NVEventStatusEGLHasSurface()
{
// TBD - need to lock a mutex?
return QueryAppFlag(NVEVENT_STATUS_EGL_HAS_SURFACE);
}
// True when a surface and context are available and bound
bool NVEventStatusEGLIsBound()
{
// TBD - need to lock a mutex?
return QueryAppFlag(NVEVENT_STATUS_EGL_BOUND);
}
static void NVEventInitInputFields(JNIEnv *env)
{
jclass Motion_class = env->FindClass("android/view/MotionEvent");
jfieldID ACTION_DOWN_id = env->GetStaticFieldID(Motion_class, "ACTION_DOWN", "I");
jfieldID ACTION_UP_id = env->GetStaticFieldID(Motion_class, "ACTION_UP", "I");
jfieldID ACTION_CANCEL_id = env->GetStaticFieldID(Motion_class, "ACTION_CANCEL", "I");
jfieldID ACTION_POINTER_INDEX_SHIFT_id = env->GetStaticFieldID(Motion_class, "ACTION_POINTER_ID_SHIFT", "I");
jfieldID ACTION_POINTER_INDEX_MASK_id = env->GetStaticFieldID(Motion_class, "ACTION_POINTER_ID_MASK", "I");
NVEVENT_ACTION_DOWN = env->GetStaticIntField(Motion_class, ACTION_DOWN_id);
NVEVENT_ACTION_UP = env->GetStaticIntField(Motion_class, ACTION_UP_id);
NVEVENT_ACTION_CANCEL = env->GetStaticIntField(Motion_class, ACTION_CANCEL_id);
NVEVENT_ACTION_POINTER_INDEX_MASK = env->GetStaticIntField(Motion_class, ACTION_POINTER_INDEX_MASK_id);
NVEVENT_ACTION_POINTER_INDEX_SHIFT = env->GetStaticIntField(Motion_class, ACTION_POINTER_INDEX_SHIFT_id);
jclass KeyCode_class = env->FindClass("android/view/KeyEvent");
jfieldID ACTION_KEY_UP_id = env->GetStaticFieldID(KeyCode_class, "ACTION_UP", "I");
NVEVENT_ACTION_KEY_UP = env->GetStaticIntField(KeyCode_class, ACTION_KEY_UP_id);
}
static void* NVEventMainLoopThreadFunc(void*)
{
NVEventAppMain(0, NULL);
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "NvEvent native app Main returned");
// signal the condition variable to unblock
// java from waiting on pause or quit
s_eventQueue.UnblockProducer();
s_appThreadExited = true;
// IF that app main returned because we posted a QUIT, then Java knows what to
// do regarding lifecycle. But, if the app returned from main of its own accord,
// we need to call finish.
if (!s_javaPostedQuit)
{
JNIEnv* env = NVThreadGetCurrentJNIEnv();
env->CallVoidMethod(s_globalThiz, s_finish.m_index);
}
return NULL;
}
NVEventPlatformAppHandle NVEventGetPlatformAppHandle()
{
return s_globalThiz;
}
///////////////////////////////////////////////////////////////////////////////
// Native event-handling functions
const char* NVEventGetEventStr(NVEventType eventType)
{
switch(eventType)
{
case NV_EVENT_KEY: return "NV_EVENT_KEY";
case NV_EVENT_CHAR: return "NV_EVENT_CHAR";
case NV_EVENT_TOUCH: return "NV_EVENT_TOUCH";
case NV_EVENT_MULTITOUCH: return "NV_EVENT_MULTITOUCH";
case NV_EVENT_ACCEL: return "NV_EVENT_ACCEL";
case NV_EVENT_START: return "NV_EVENT_START";
case NV_EVENT_RESTART: return "NV_EVENT_RESTART";
case NV_EVENT_RESUME: return "NV_EVENT_RESUME";
case NV_EVENT_FOCUS_GAINED: return "NV_EVENT_FOCUS_GAINED";
case NV_EVENT_SURFACE_CREATED: return "NV_EVENT_SURFACE_CREATED";
case NV_EVENT_SURFACE_SIZE: return "NV_EVENT_SURFACE_SIZE";
case NV_EVENT_SURFACE_DESTROYED: return "NV_EVENT_SURFACE_DESTROYED";
case NV_EVENT_FOCUS_LOST: return "NV_EVENT_FOCUS_LOST";
case NV_EVENT_PAUSE: return "NV_EVENT_PAUSE";
case NV_EVENT_STOP: return "NV_EVENT_STOP";
case NV_EVENT_QUIT: return "NV_EVENT_QUIT";
case NV_EVENT_USER: return "NV_EVENT_USER";
case NV_EVENT_LONG_CLICK: return "NV_EVENT_LONG_CLICK";
case NV_EVENT_MWM: return "NV_EVENT_MWM";
}
// update this if you end up having to edit something.
CT_ASSERT(NEED_TO_ADD_STRING_HERE, NV_EVENT_NUM_EVENTS == 19);
return "unknown event type!";
}
const NVEvent* NVEventGetNextEvent(int waitMSecs)
{
return s_eventQueue.RemoveOldest(waitMSecs);
}
void NVEventDoneWithEvent(bool handled)
{
return s_eventQueue.DoneWithEvent(handled);
}
static void NVEventInsert(NVEvent* ev)
{
if(!s_appThreadExited)
s_eventQueue.Insert(ev);
}
static bool NVEventInsertBlocking(NVEvent* ev)
{
if(!s_appThreadExited)
return s_eventQueue.InsertBlocking(ev);
return false;
}
///////////////////////////////////////////////////////////////////////////////
// Native to Java EGL call-up functions
bool NVEventInitEGL()
{
if(s_InitEGL.CallBoolean())
{
SetAppFlag(NVEVENT_STATUS_EGL_INITIALIZED);
return true;
}
else
return false;
}
bool NVEventCleanupEGL()
{
ClearAppFlag(NVEVENT_STATUS_EGL_BOUND);
ClearAppFlag(NVEVENT_STATUS_EGL_HAS_SURFACE);
ClearAppFlag(NVEVENT_STATUS_EGL_INITIALIZED);
return s_CleanupEGL.CallBoolean();
}
bool NVEventCreateSurfaceEGL()
{
if (s_CreateSurfaceEGL.CallBoolean())
{
SetAppFlag(NVEVENT_STATUS_EGL_HAS_SURFACE);
return true;
}
else
return false;
}
bool NVEventDestroySurfaceEGL()
{
if (!QueryAppFlag(NVEVENT_STATUS_EGL_HAS_SURFACE))
return true;
if (QueryAppFlag(NVEVENT_STATUS_EGL_BOUND))
NVEventUnbindSurfaceAndContextEGL();
ClearAppFlag(NVEVENT_STATUS_EGL_HAS_SURFACE);
return s_DestroySurfaceEGL.CallBoolean();
}
bool NVEventBindSurfaceAndContextEGL()
{
if (s_BindSurfaceAndContextEGL.CallBoolean())
{
SetAppFlag(NVEVENT_STATUS_EGL_BOUND);
return true;
}
else
return false;
}
bool NVEventUnbindSurfaceAndContextEGL()
{
ClearAppFlag(NVEVENT_STATUS_EGL_BOUND);
return s_UnbindSurfaceAndContextEGL.CallBoolean();
}
bool NVEventSwapBuffersEGL()
{
if (!s_SwapBuffersEGL.CallBoolean())
return false;
RESET_PROFILING();
return true;
}
int NVEventGetErrorEGL()
{
return s_GetErrorEGL.CallInt();
}
bool NVEventReadyToRenderEGL(bool allocateIfNeeded)
{
// If we have a bound context and surface, then EGL is ready
if (!NVEventStatusEGLIsBound())
{
if (!allocateIfNeeded)
return false;
// If we have not bound the context and surface, do we even _have_ a surface?
if (!NVEventStatusEGLHasSurface())
{
// No surface, so we need to check if EGL is set up at all
if (!NVEventStatusEGLInitialized())
{
if (!NVEventInitEGL())
return false;
}
// Create the rendering surface now that we have a context
if (!NVEventCreateSurfaceEGL())
return false;
}
// We have a surface and context, so bind them
if (NVEventBindSurfaceAndContextEGL())
return false;
}
return true;
}
bool NVEventRepaint()
{
NVEvent ev;
ev.m_type = NV_EVENT_USER;
ev.m_data.m_user.m_u0 = 1;
NVEventInsert(&ev);
return true;
}
void NVEventReportUnsupported()
{
/// to prevent from rendering
ClearAppFlag(NVEVENT_STATUS_FOCUSED);
s_ReportUnsupported.CallVoid();
}
void NVEventOnRenderingInitialized()
{
s_OnRenderingInitialized.CallVoid();
}
///////////////////////////////////////////////////////////////////////////////
// Input event-related Java to Native callback functions
static jboolean NVEventMultiTouchEvent(JNIEnv* env, jobject thiz, jint action,
jboolean hasFirst, jboolean hasSecond, jint mx1, jint my1, jint mx2, jint my2)
{
{
NVEvent ev;
int actionOnly = action & (~NVEVENT_ACTION_POINTER_INDEX_MASK);
int maskOnly = 0;
if (hasFirst)
maskOnly |= 0x1;
if (hasSecond)
maskOnly |= 0x2;
ev.m_type = NV_EVENT_MULTITOUCH;
if (actionOnly == NVEVENT_ACTION_UP)
{
ev.m_data.m_multi.m_action = NV_MULTITOUCH_UP;
}
else if (actionOnly == NVEVENT_ACTION_DOWN)
{
ev.m_data.m_multi.m_action = NV_MULTITOUCH_DOWN;
}
else if (actionOnly == NVEVENT_ACTION_CANCEL)
{
ev.m_data.m_multi.m_action = NV_MULTITOUCH_CANCEL;
}
else
{
ev.m_data.m_multi.m_action = NV_MULTITOUCH_MOVE;
}
ev.m_data.m_multi.m_action =
(NVMultiTouchEventType)(ev.m_data.m_multi.m_action | (maskOnly << NV_MULTITOUCH_POINTER_SHIFT));
ev.m_data.m_multi.m_x1 = mx1;
ev.m_data.m_multi.m_y1 = my1;
ev.m_data.m_multi.m_x2 = mx2;
ev.m_data.m_multi.m_y2 = my2;
NVEventInsert(&ev);
}
return JNI_TRUE;
}
static jboolean NVEventKeyEvent(JNIEnv* env, jobject thiz, jint action, jint keycode, jint unichar)
{
// TBD - remove these or make them resettable for safety...
static int lastKeyAction = 0;
static int lastKeyCode = 0;
bool ret = false;
NVKeyCode code = NV_KEYCODE_NULL;
if (s_keyMapping.MapKey((int)keycode, code))
{
if ((code != NV_KEYCODE_NULL) &&
((code != lastKeyCode) || (action != lastKeyAction)))
{
NVEvent ev;
ev.m_type = NV_EVENT_KEY;
ev.m_data.m_key.m_action = (NVEVENT_ACTION_UP == action)
? NV_KEYACTION_UP : NV_KEYACTION_DOWN;
ev.m_data.m_key.m_code = code;
ret = NVEventInsertBlocking(&ev);
}
lastKeyAction = action;
lastKeyCode = code;
}
if (unichar && (NVEVENT_ACTION_UP != action))
{
NVEvent ev;
ev.m_type = NV_EVENT_CHAR;
ev.m_data.m_char.m_unichar = unichar;
NVEventInsert(&ev);
}
return ret;
}
static jboolean NVEventAccelerometerEvent(JNIEnv* env, jobject thiz, jfloat values0, jfloat values1, jfloat values2)
{
NVEvent ev;
ev.m_type = NV_EVENT_ACCEL;
ev.m_data.m_accel.m_x = values0;
ev.m_data.m_accel.m_y = values1;
ev.m_data.m_accel.m_z = values2;
NVEventInsert(&ev);
return JNI_TRUE;
}
///////////////////////////////////////////////////////////////////////////////
// Java to Native app lifecycle callback functions
static jboolean onDestroyNative(JNIEnv* env, jobject thiz);
static jboolean onCreateNative(JNIEnv* env, jobject thiz)
{
if (s_globalThiz)
onDestroyNative(env, thiz);
ZeroAppFlags();
if (!s_globalThiz)
{
s_globalThiz = env->NewGlobalRef(thiz);
if (!s_globalThiz)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Error: Thiz NewGlobalRef failed!");
}
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Thiz NewGlobalRef: 0x%p", s_globalThiz);
}
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Init KeyCode Map");
s_keyMapping.Init(env, thiz);
NVEventInitInputFields(env);
s_eventQueue.Init();
s_javaPostedQuit = false;
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Calling NVEventAppInit");
if (NVEventAppInit(0, NULL))
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "NVEventAppInit error");
return JNI_FALSE;
}
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "spawning thread");
s_appThreadExited = false;
SetAppFlag(NVEVENT_STATUS_RUNNING);
/* Launch thread with main loop */
NVThreadSpawnJNIThread(&s_mainThread, NULL, NVEventMainLoopThreadFunc, NULL);
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "thread spawned");
return JNI_TRUE;
}
static jboolean onStartNative(JNIEnv* env, jobject thiz)
{
NVEvent ev;
ev.m_type = NV_EVENT_START;
return NVEventInsertBlocking(&ev);
}
static jboolean onRestartNative(JNIEnv* env, jobject thiz)
{
NVEvent ev;
ev.m_type = NV_EVENT_RESTART;
return NVEventInsertBlocking(&ev);
}
static jboolean onResumeNative(JNIEnv* env, jobject thiz)
{
NVEvent ev;
ev.m_type = NV_EVENT_RESUME;
SetAppFlag(NVEVENT_STATUS_ACTIVE);
return NVEventInsertBlocking(&ev);
}
static jboolean onSurfaceCreatedNative(JNIEnv* env, jobject thiz, int w, int h, int density)
{
NVEvent ev;
ev.m_type = NV_EVENT_SURFACE_CREATED;
ev.m_data.m_size.m_w = w;
ev.m_data.m_size.m_h = h;
ev.m_data.m_size.m_density = density;
if ((w > 0) && (h > 0))
SetAppFlag(NVEVENT_STATUS_HAS_REAL_SURFACE);
else
ClearAppFlag(NVEVENT_STATUS_HAS_REAL_SURFACE);
return NVEventInsertBlocking(&ev);
}
static jboolean onFocusChangedNative(JNIEnv* env, jobject thiz, jboolean focused)
{
NVEvent ev;
ev.m_type = (focused == JNI_TRUE) ? NV_EVENT_FOCUS_GAINED : NV_EVENT_FOCUS_LOST;
if (focused)
SetAppFlag(NVEVENT_STATUS_FOCUSED);
else
ClearAppFlag(NVEVENT_STATUS_FOCUSED);
return NVEventInsertBlocking(&ev);
}
static jboolean onSurfaceChangedNative(JNIEnv* env, jobject thiz, int w, int h, int density)
{
NVEvent ev;
ev.m_type = NV_EVENT_SURFACE_SIZE;
ev.m_data.m_size.m_w = w;
ev.m_data.m_size.m_h = h;
ev.m_data.m_size.m_density = density;
if (w * h)
SetAppFlag(NVEVENT_STATUS_HAS_REAL_SURFACE);
else
ClearAppFlag(NVEVENT_STATUS_HAS_REAL_SURFACE);
return NVEventInsertBlocking(&ev);
}
static jboolean onSurfaceDestroyedNative(JNIEnv* env, jobject thiz)
{
NVEvent ev;
ev.m_type = NV_EVENT_SURFACE_DESTROYED;
ClearAppFlag(NVEVENT_STATUS_HAS_REAL_SURFACE);
return NVEventInsertBlocking(&ev);
}
static jboolean onPauseNative(JNIEnv* env, jobject thiz)
{
// TODO: we could selectively flush here to
// improve responsiveness to the pause
s_eventQueue.Flush();
NVEvent ev;
ev.m_type = NV_EVENT_PAUSE;
ClearAppFlag(NVEVENT_STATUS_ACTIVE);
return NVEventInsertBlocking(&ev);
}
static jboolean onStopNative(JNIEnv* env, jobject thiz)
{
NVEvent ev;
ev.m_type = NV_EVENT_STOP;
return NVEventInsertBlocking(&ev);
}
static jboolean onDestroyNative(JNIEnv* env, jobject thiz)
{
if (!env || !s_globalThiz)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Error: DestroyingRegisteredObjectInstance no TLS data!");
}
if (!s_appThreadExited)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Posting quit event");
// flush ALL events
s_eventQueue.Flush();
NVEvent ev;
ev.m_type = NV_EVENT_QUIT;
ClearAppFlag(NVEVENT_STATUS_RUNNING);
// We're posting quit, so we need to mark that; when the main loop
// thread exits, we check this flag to ensure that we only call "finish"
// if the app returned of its own accord, not if we posted it
s_javaPostedQuit = true;
NVEventInsert(&ev);
// ensure that the native side
// isn't blocked waiting for an event -- since we've flushed
// all the events save quit, we must artificially unblock native
s_eventQueue.UnblockConsumer();
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Waiting for main loop exit");
pthread_join(s_mainThread, NULL);
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Main loop exited");
}
env->DeleteGlobalRef(s_globalThiz);
s_globalThiz = NULL;
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "Released global thiz!");
s_eventQueue.Shutdown();
return JNI_TRUE;
}
static jboolean postUserEvent(JNIEnv* env, jobject thiz,
jint u0, jint u1, jint u2, jint u3,
jboolean blocking)
{
NVEvent ev;
ev.m_type = NV_EVENT_USER;
ev.m_data.m_user.m_u0 = u0;
ev.m_data.m_user.m_u1 = u1;
ev.m_data.m_user.m_u2 = u2;
ev.m_data.m_user.m_u3 = u3;
if (blocking == JNI_TRUE)
{
return NVEventInsertBlocking(&ev);
}
else
{
NVEventInsert(&ev);
return true;
}
}
void postMWMEvent(void * pFn, bool blocking)
{
NVEvent ev;
ev.m_type = NV_EVENT_MWM;
ev.m_data.m_mwm.m_pFn = pFn;
if (blocking)
(void) NVEventInsertBlocking(&ev);
else
NVEventInsert(&ev);
}
///////////////////////////////////////////////////////////////////////////////
// File and APK handling functions
char* NVEventLoadFile(const char* file)
{
__android_log_print(ANDROID_LOG_DEBUG, MODULE, "loadFile is not implemented");
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// JVM Initialization functions
void InitNVEvent(JavaVM* vm)
{
JNIEnv *env;
NVThreadInit(vm);
NVDEBUG("InitNVEvent called");
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
{
NVDEBUG("Failed to get the environment using GetEnv()");
return;
}
JNINativeMethod methods[] =
{
{
"onCreateNative",
"()Z",
(void *) onCreateNative
},
{
"onStartNative",
"()Z",
(void *) onStartNative
},
{
"onRestartNative",
"()Z",
(void *) onRestartNative
},
{
"onResumeNative",
"()Z",
(void *) onResumeNative
},
{
"onSurfaceCreatedNative",
"(III)Z",
(void *) onSurfaceCreatedNative
},
{
"onFocusChangedNative",
"(Z)Z",
(void *) onFocusChangedNative
},
{
"onSurfaceChangedNative",
"(III)Z",
(void *) onSurfaceChangedNative
},
{
"onSurfaceDestroyedNative",
"()Z",
(void *) onSurfaceDestroyedNative
},
{
"onPauseNative",
"()Z",
(void *) onPauseNative
},
{
"onStopNative",
"()Z",
(void *) onStopNative
},
{
"onDestroyNative",
"()Z",
(void *) onDestroyNative
},
{
"multiTouchEvent",
"(IZZIIIILandroid/view/MotionEvent;)Z",
(void *) NVEventMultiTouchEvent
}/*,
{
"onLongClickNative",
"(II)Z",
(void *) NVEventLongClickEvent
}*/
};
jclass k;
k = (env)->FindClass ("com/nvidia/devtech/NvEventQueueFragment");
(env)->RegisterNatives(k, methods, dimof(methods));
s_InitEGL.QueryID(env, k);
s_CleanupEGL.QueryID(env, k);
s_CreateSurfaceEGL.QueryID(env, k);
s_DestroySurfaceEGL.QueryID(env, k);
s_SwapBuffersEGL.QueryID(env, k);
s_BindSurfaceAndContextEGL.QueryID(env, k);
s_UnbindSurfaceAndContextEGL.QueryID(env, k);
s_GetErrorEGL.QueryID(env, k);
s_finish.QueryID(env, k);
s_ReportUnsupported.QueryID(env, k);
s_OnRenderingInitialized.QueryID(env, k);
}

547
android/jni/nv_event/nv_event.hpp
View file

@ -1,547 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_event\nv_event.h
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA® Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#ifndef _NV_EVENT_H
#define _NV_EVENT_H
#include <jni.h>
#include <sys/types.h>
/** @file nv_event.h
Contains a framework for event loop-based applications. This library replaces
most or all of the normally-required JNI code for Android NDK applications,
presenting the application developer with two callbacks into which they can
write their application. The framework runs in a natively-created thread,
allowing the application to implement a classic "event loop and render" structure
without having to return to Java code to avoid ANR warnings. The library
includes support for input and system event passing as well as JNI initialization
and exposes basic EGL functionality to native as well. Put together, the library
can form the basis of a simple interactive 3D application. All applications that
are based on this library must also be subclassed on the Java side from the
provided NvEventQueueActivity. Additional external documentation on the use of
this library, the related Java code and the tool provided to create a template
application based on the library are provided with the SDK.
@see NvEventQueueActivity
*/
#ifdef ANDROID
#include <jni.h>
typedef jobject NVEventPlatformAppHandle;
#else // unknown platform
typedef void * NVEventPlatformAppHandle;
#endif
enum
{
/** Timeout argument to NVEventGetNextEvent() that indicates the function should
block until there is an event pending or the app exits
@see NVEventGetNextEvent()
*/
NV_EVENT_WAIT_FOREVER = -1
};
/** Event type values
*/
typedef enum NVEventType
{
/** Key up/down events */
NV_EVENT_KEY = 1,
/** Translated character events */
NV_EVENT_CHAR,
/** Single-touch pointer events */
NV_EVENT_TOUCH,
/** Multi-touch events */
NV_EVENT_MULTITOUCH,
/** Long Click Event */
NV_EVENT_LONG_CLICK,
/** Accelerometer events */
NV_EVENT_ACCEL,
/** onStart lifecycle events */
NV_EVENT_START,
/** onRestart lifecycle events */
NV_EVENT_RESTART,
/** onResume lifecycle events */
NV_EVENT_RESUME,
/** onWindowFocusChanged(TRUE) lifecycle events */
NV_EVENT_FOCUS_GAINED,
/** Surface created events */
NV_EVENT_SURFACE_CREATED,
/** Surface size changed events */
NV_EVENT_SURFACE_SIZE,
/** Surface destroyed events */
NV_EVENT_SURFACE_DESTROYED,
/** onWindowFocusChanged(FALSE) lifecycle events */
NV_EVENT_FOCUS_LOST,
/** onPause lifecycle events */
NV_EVENT_PAUSE,
/** onStop lifecycle events */
NV_EVENT_STOP,
/** (onDestroy) Quit request events */
NV_EVENT_QUIT,
/** App-specific events */
NV_EVENT_USER,
NV_EVENT_MWM,
/* a dummy enum value used to compute num_events */
NV_EVENT_NUM_EVENT_DUMMY_DONTUSEME,
/* total number of events */
NV_EVENT_NUM_EVENTS = NV_EVENT_NUM_EVENT_DUMMY_DONTUSEME - 1,
NV_EVENT_FORCE_32BITS = 0x7fffffff
} NVEventType;
/** Touch event actions
*/
typedef enum NVTouchEventType
{
/** Pointer has just left the screen */
NV_TOUCHACTION_UP,
/** Pointer has just gone down onto the screen */
NV_TOUCHACTION_DOWN,
/** Pointer is moving on the screen */
NV_TOUCHACTION_MOVE,
NV_TOUCHACTION_FORCE_32BITS = 0x7fffffff
} NVTouchEventType;
/** Multitouch event flags
*/
typedef enum NVMultiTouchEventType
{
/** Indicated pointers are leaving the screen */
NV_MULTITOUCH_UP = 0x00000001,
/** Indicated pointers have just touched the screen */
NV_MULTITOUCH_DOWN = 0x00000002,
/** Indicated pointers are moving on the screen */
NV_MULTITOUCH_MOVE = 0x00000003,
/** Indicated pointers have halted the current gesture
app should cancel any actions implied by the gesture */
NV_MULTITOUCH_CANCEL = 0x00000004,
/** Mask to be AND'ed with the flag value
to get the active pointer bits */
NV_MULTITOUCH_POINTER_MASK = 0x0000ff00,
/** Number of bits to right-shift the masked value
to get the active pointer bits */
NV_MULTITOUCH_POINTER_SHIFT = 0x00000008,
/** Mask to be AND'ed with the flag value
to get the event action */
NV_MULTITOUCH_ACTION_MASK = 0x000000ff,
NV_MULTITOUCH_FORCE_32BITS = 0x7fffffff
} NVMultiTouchEventType;
/** Key event types
*/
typedef enum NVKeyEventType
{
/** Key has just been pressed (no repeats) */
NV_KEYACTION_UP,
/** Key has just been released */
NV_KEYACTION_DOWN,
NV_KEYACTION_FORCE_32BITS = 0x7fffffff
} NVKeyEventType;
/** Key event key codes
*/
#define NV_MAX_KEYCODE 256
typedef enum NVKeyCode
{
NV_KEYCODE_NULL = 0,
NV_KEYCODE_BACK,
NV_KEYCODE_TAB,
NV_KEYCODE_ENTER,
NV_KEYCODE_DEL,
NV_KEYCODE_SPACE,
NV_KEYCODE_ENDCALL,
NV_KEYCODE_HOME,
NV_KEYCODE_STAR,
NV_KEYCODE_PLUS,
NV_KEYCODE_MINUS,
NV_KEYCODE_NUM,
NV_KEYCODE_DPAD_LEFT,
NV_KEYCODE_DPAD_UP,
NV_KEYCODE_DPAD_RIGHT,
NV_KEYCODE_DPAD_DOWN,
NV_KEYCODE_0,
NV_KEYCODE_1,
NV_KEYCODE_2,
NV_KEYCODE_3,
NV_KEYCODE_4,
NV_KEYCODE_5,
NV_KEYCODE_6,
NV_KEYCODE_7,
NV_KEYCODE_8,
NV_KEYCODE_9,
NV_KEYCODE_A,
NV_KEYCODE_B,
NV_KEYCODE_C,
NV_KEYCODE_D,
NV_KEYCODE_E,
NV_KEYCODE_F,
NV_KEYCODE_G,
NV_KEYCODE_H,
NV_KEYCODE_I,
NV_KEYCODE_J,
NV_KEYCODE_K,
NV_KEYCODE_L,
NV_KEYCODE_M,
NV_KEYCODE_N,
NV_KEYCODE_O,
NV_KEYCODE_P,
NV_KEYCODE_Q,
NV_KEYCODE_R,
NV_KEYCODE_S,
NV_KEYCODE_T,
NV_KEYCODE_U,
NV_KEYCODE_V,
NV_KEYCODE_W,
NV_KEYCODE_X,
NV_KEYCODE_Y,
NV_KEYCODE_Z,
NV_KEYCODE_ALT_LEFT,
NV_KEYCODE_ALT_RIGHT,
NV_KEYCODE_SHIFT_LEFT,
NV_KEYCODE_SHIFT_RIGHT,
NV_KEYCODE_APOSTROPHE,
NV_KEYCODE_SEMICOLON,
NV_KEYCODE_EQUALS,
NV_KEYCODE_COMMA,
NV_KEYCODE_PERIOD,
NV_KEYCODE_SLASH,
NV_KEYCODE_GRAVE,
NV_KEYCODE_BACKSLASH,
NV_KEYCODE_LEFT_BRACKET,
NV_KEYCODE_RIGHT_BRACKET,
NV_KEYCODE_FORCE_32BIT = 0x7fffffff
} NVKeyCode;
/** Single-touch event data
*/
typedef struct NVEventTouch
{
/** The action code */
NVTouchEventType m_action;
/** The window-relative X position (in pixels) */
float m_x;
/** The window-relative Y position (in pixels) */
float m_y;
} NVEventTouch;
/** Multi-touch event data
*/
typedef struct NVEventMultiTouch
{
/** The action flags */
NVMultiTouchEventType m_action;
/** The window-relative X position of the first pointer (in pixels)
only valid if bit 0 of the pointer bits is set */
float m_x1;
/** The window-relative Y position of the first pointer (in pixels)
only valid if bit 0 of the pointer bits is set */
float m_y1;
/** The window-relative X position of the second pointer (in pixels)
only valid if bit 1 of the pointer bits is set */
float m_x2;
/** The window-relative Y position of the second pointer (in pixels)
only valid if bit 1 of the pointer bits is set */
float m_y2;
} NVEventMultiTouch;
/** Key down/up event data
*/
typedef struct NVEventKey
{
/** The action flags */
NVKeyEventType m_action;
/** The code of the key pressed or released */
NVKeyCode m_code;
} NVEventKey;
/** Translated character event data
*/
typedef struct NVEventChar
{
/** The UNICODE character represented */
int32_t m_unichar;
} NVEventChar;
/** Accelerometer event data
*/
typedef struct NVEventAccel
{
/** Signed X magnitude of the force vector */
float m_x;
/** Signed Y magnitude of the force vector */
float m_y;
/** Signed Z magnitude of the force vector */
float m_z;
} NVEventAccel;
/** Surface size change event data
*/
typedef struct NVEventSurfaceSize
{
/** New surface client area width (in pixels) */
int32_t m_w;
/** New surface client area height (in pixels) */
int32_t m_h;
/** Screen density for the screen at which this surface was created*/
int32_t m_density;
} NVEventSurfaceSize;
/** User/App-specific event data
*/
typedef struct NVEventUser
{
/** First 32-bit user data item */
int32_t m_u0;
/** Second 32-bit user data item */
int32_t m_u1;
/** Third 32-bit user data item */
int32_t m_u2;
/** Fourth 32-bit user data item */
int32_t m_u3;
} NVEventUser;
typedef struct NVEventMWM
{
void * m_pFn;
} NVEventMWM;
/** All-encompassing event structure
*/
typedef struct NVEvent
{
/** The type of the event, which also indicates which m_data union holds the data */
NVEventType m_type;
/** Union containing all possible event type data */
union NVEventData
{
/** Data for single-touch events */
NVEventTouch m_touch;
/** Data for multi-touch events */
NVEventMultiTouch m_multi;
/** Data for key up/down events */
NVEventKey m_key;
/** Data for charcter events */
NVEventChar m_char;
/** Data for accelerometer events */
NVEventAccel m_accel;
/** Data for surface size events */
NVEventSurfaceSize m_size;
/** Data for user/app events */
NVEventUser m_user;
NVEventMWM m_mwm;
} m_data;
} NVEvent;
/** Returns a string describing the event
@param eventType The event type
@return Returns a string containing a description of the event. Do not free or delete this memory.
@see NVEvent */
const char * NVEventGetEventStr(NVEventType eventType);
/** Returns the next pending event for the application to process. Can return immediately if there
is no event, or can wait a fixed number of milisecs (or "forever") if desired.
The application should always pair calls to this function that return non-NULL events with calls
to NVEventDoneWithEvent()
@param waitMSecs The maximum time (in milisecs) to wait for an event before returning "no event".
Pass NV_EVENT_WAIT_FOREVER to wait indefinitely for an event. Note that NV_EVENT_WAIT_FOREVER
does not guarantee an event on return. The function can still return on error or if the
app is exiting. Default is to return immediately, event or not.
@return Non-NULL pointer to a constant event structure if an event was pending, NULL if no event was
pending in the requested timeout period
@see NVEvent
@see NVEventDoneWithEvent
*/
const NVEvent * NVEventGetNextEvent(int waitMSecs = 0);
/** Indicates that the application has finished handling the event returned from the last
call to NVEventGetNextEvent. This function should always be called prior to the next call
to NVEventGetNextEvent. If the current event is a blocking event, this call will unblock
the posting thread (normally in Java). This is particularly important for application
lifecycle events like onPause, as calling this function indicates that the native code has
completed the handling of the lifecycle callback. Failure to call this function promptly
for all events can lead to Application Not Responding errors.
@param handled The return value that should be passed back to Java for blocking events. For non-blocking
events, this parameter is discard.
@see NVEvent
@see NVEventGetNextEvent
*/
void NVEventDoneWithEvent(bool handled);
/** The app-supplied "callback" for initialization during JNI_OnLoad.
Declares the application's pre-main initialization function. Does not define the
function. <b>The app must define this in its own code</b>, even if the function is empty.
JNI init code can be safely called from here, as it WILL be called from
within a JNI function thread
@parm argc Passes the number of command line arguments.
This is currently unsupported and is always passed 0
@parm argv Passes the array of command line arguments.
This is currently unsupported and is always passed NULL
@return The function should return 0 on success and nonzero on failure.
*/
extern int32_t NVEventAppInit(int32_t argc, char** argv);
/** The app-supplied "callback" for running the application's main loop.
Declares the application's main loop function. Does not define the
function. <b>The app must define this in its own code</b>
This function will be spawned in its own thread.
@parm argc Passes the number of command line arguments.
This is currently unsupported and is always passed 0
@parm argv Passes the array of command line arguments.
This is currently unsupported and is always passed NULL
@return The function should return 0 on success and nonzero on failure.
*/
extern int32_t NVEventAppMain(int32_t argc, char** argv);
/** Initializes EGL, queries a valid ES1 config and creates (but does not bind)
an ES1-compatible EGLContext
@return true on success, false on failure
*/
bool NVEventInitEGL();
/** Releases any existing EGLSurface and EGLContext and terminates EGL
@return true on success, false on failure
*/
bool NVEventCleanupEGL();
/** Creates an EGLSurface for the current Android surface. Will attempt to initialize
EGL and an EGLContext if not already done. Fails if there is no valid Android surface
or if there is an EGL error.
@return true on success, false on failure
*/
bool NVEventCreateSurfaceEGL();
/** Unbinds (if needed) and releases the app's EGLSurface
@return true on success, false on failure
*/
bool NVEventDestroySurfaceEGL();
/** Binds the app's EGLSurface and EGLContext to the calling thread. The EGLSurface and
EGLContext must both exist already, or else the function will fail.
@return true on success, false on failure
*/
bool NVEventBindSurfaceAndContextEGL();
/** Un-binds the app's EGLSurface and EGLContext from the calling thread.
@return true on success, false on failure
*/
bool NVEventUnbindSurfaceAndContextEGL();
/** Swaps the currently-bound EGLSurface
@return true on success, false on failure
*/
bool NVEventSwapBuffersEGL();
/** Accessor for the last EGL error
@return the EGL error
*/
int NVEventGetErrorEGL();
/** Utility function: checks if EGl is completely ready to render, including
initialization, surface creation and context/surface binding.
@parm allocateIfNeeded If the parameter is false, then the function immediately returns if any
part of the requirements have not already been satisfied. If the parameter is
true, then the function attempts to initialize any of the steps needed, failing
and returning false only if a step cannot be completed at this time.
@return The function returns true if EGL/GLES is ready to render/load content (i.e.
a context and surface are bound) and false it not
*/
bool NVEventReadyToRenderEGL(bool allocateIfNeeded);
/** Convenience conditional function to determine if the app is between onCreate
and onDestroy callbacks (i.e. the app is in a running state).
@return true if the application is between onCreate and onDestroy and false after
an onDestroy event has been delivered.
*/
bool NVEventStatusIsRunning();
/** Convenience conditional function to determine if the app is between onResume and onPause
callbacks (i.e. the app is in a "resumed" state).
@return true if the application is between onResume and onPause and false if the application
has not yet been resumed, or is currently paused.
*/
bool NVEventStatusIsActive();
/** Convenience conditional function to determine if the app's window is focused (between
calls to onWindowFocusChanged(true) and onWindowFocusChanged(false))
@return true between onWindowFocusChanged(true) and onWindowFocusChanged(false)
*/
bool NVEventStatusIsFocused();
/** Convenience conditional function to determine if the app has a surface and that surface
has non-zero area
@return true if the app is between surfaceCreated and surfaceDestroyed callbacks and
the surface has non-zero pixel area (not 0x0 pixels)
*/
bool NVEventStatusHasRealSurface();
/** Convenience conditional function to determine if the app is in a fully-focused, visible
state. This is a logical "AND" of IsRunning, IsActive, IsFocused and HasRealSurface
@return true if IsRunning, IsActive, IsFocused and HasRealSurface are all currently true,
false otherwise
*/
bool NVEventStatusIsInteractable();
/** Convenience conditional function to determine if the app has active EGL
@return true between successful calls to NVEventInitEGL and NVEventCleanupEGL,
false otherwise
*/
bool NVEventStatusEGLInitialized();
/** Convenience conditional function to determine if the app has an EGLSurface (need not be bound)
@return true if the EGLSurface for the app is allocated, false otherwise
*/
bool NVEventStatusEGLHasSurface();
/** Convenience conditional function to determine if the app has an EGLSurface and EGLContext
and they are bound
@return true if the EGLSurface and EGLContext for the app are allocated and bound, false otherwise
*/
bool NVEventStatusEGLIsBound();
bool NVEventRepaint();
void NVEventReportUnsupported();
void NVEventOnRenderingInitialized();
/** Returns the platform-specific handle to the application instance, if supported. This
function is, by definition platform-specific.
@return A platform-specific handle to the application. */
NVEventPlatformAppHandle NVEventGetPlatformAppHandle();
void InitNVEvent(JavaVM * jvm);
void postMWMEvent(void * pFn, bool blocking);
#endif

276
android/jni/nv_event/nv_event_queue.cpp
View file

@ -1,276 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_event\nv_event_queue.cpp
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA<49> Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#define MODULE "NVEventQueue"
#include "../nv_debug/nv_debug.hpp"
#include "nv_event_queue.hpp"
#include <assert.h>
#include <stdlib.h>
#include <jni.h>
#include <pthread.h>
#include <android/log.h>
#define NVNextWrapped(index) (((index) + 1) & QUEUE_MASK)
#define NVPrevWrapped(index) (((index) - 1) & QUEUE_MASK)
/* you must be inside a m_accessLock lock to invoke this! */
static void unlockAll(NVEventSync * sem)
{
sem->m_block = false;
pthread_cond_broadcast(&(sem->m_cond));
}
/* you must be inside mutex lock to invoke this! */
static int32_t wait(NVEventSync * sem, pthread_mutex_t * mutex, int waitMS)
{
// TBD - spec is dodgy; do we definitely release the mutex even if
// wait fails?
if(sem->m_block)
{
if( waitMS < 0 )
return pthread_cond_wait(&sem->m_cond, mutex);
else
return pthread_cond_timeout_np(&sem->m_cond, mutex, (unsigned)waitMS);
}
else
{
// must release this, as failure assumes no lock
pthread_mutex_unlock(mutex);
return 1; // do not return 0 - we do not own the lock!
}
}
static void signal(NVEventSync * sem)
{
pthread_cond_signal(&sem->m_cond);
}
static void broadcast(NVEventSync * sem)
{
pthread_cond_broadcast(&sem->m_cond);
}
static void syncInit(NVEventSync * sync)
{
pthread_cond_init(&sync->m_cond, NULL);
sync->m_block = true;
}
static void syncDestroy(NVEventSync * sync)
{
pthread_cond_destroy(&sync->m_cond);
}
/* you must be inside a m_accessLock lock to invoke this! */
bool NVEventQueue::insert(NVEvent const * ev)
{
// Is the queue full?
int32_t nextNext = NVNextWrapped(m_nextInsertIndex);
if (nextNext == m_headIndex)
{
// TBD - what to do when we cannot insert (full queue)
return false;
}
NVEvent * evDest = m_events + m_nextInsertIndex;
memcpy(evDest, ev, sizeof(NVEvent));
m_nextInsertIndex = nextNext;
return true;
}
void NVEventQueue::Init()
{
m_nextInsertIndex = 0;
m_headIndex = 0;
pthread_mutex_init(&m_accessLock, NULL);
syncInit(&m_consumerSync);
syncInit(&m_blockerSync);
m_blocker = NULL;
m_blockerState = NO_BLOCKER;
m_blockerReturnVal = false;
}
void NVEventQueue::Shutdown()
{
pthread_mutex_destroy(&m_accessLock);
// free everyone...
unlockAll(&m_consumerSync);
unlockAll(&m_blockerSync);
syncDestroy(&m_consumerSync);
syncDestroy(&m_blockerSync);
}
void NVEventQueue::Flush()
{
// TBD: Lock the mutex????
m_headIndex = m_nextInsertIndex;
}
void NVEventQueue::UnblockConsumer()
{
unlockAll(&m_consumerSync);
}
void NVEventQueue::UnblockProducer()
{
unlockAll(&m_blockerSync);
}
void NVEventQueue::Insert(const NVEvent* ev)
{
pthread_mutex_lock(&m_accessLock);
// insert the event and unblock a waiter
insert(ev);
signal(&m_consumerSync);
pthread_mutex_unlock(&m_accessLock);
}
bool NVEventQueue::InsertBlocking(const NVEvent* ev)
{
// TBD - how to handle the destruction of these mutexes
pthread_mutex_lock(&m_accessLock);
while (m_blocker)
{
if (wait(&m_blockerSync, &m_accessLock, NV_EVENT_WAIT_FOREVER))
return false;
}
assert(!m_blocker);
assert(m_blockerState == NO_BLOCKER);
// we have the mutex _and_ the blocking event is NULL
// So now we can push a new one
m_blocker = ev;
m_blockerState = PENDING_BLOCKER;
// Release the consumer, as we just posted a new event
signal(&m_consumerSync);
// Loop on the condition variable until we find out that
// there is a return value waiting for us. Since only we
// will null the blocker pointer, we will not let anyone
// else start to post a blocking event
while (m_blockerState != RETURNED_BLOCKER)
{
if (wait(&m_blockerSync, &m_accessLock, NV_EVENT_WAIT_FOREVER))
return false;
}
bool handled = m_blockerReturnVal;
m_blocker = NULL;
m_blockerState = NO_BLOCKER;
NVDEBUG("producer unblocking from consumer handling blocking event (%s)", handled ? "true" : "false");
// We've handled the event, so the producer can release the
// next thread to potentially post a blocking event
signal(&m_blockerSync);
pthread_mutex_unlock(&m_accessLock);
return handled;
}
const NVEvent* NVEventQueue::RemoveOldest(int waitMSecs)
{
pthread_mutex_lock(&m_accessLock);
// Hmm - the last event we got from RemoveOldest was a
// blocker, and DoneWithEvent not called.
// Default to "false" as a return value
if (m_blockerState == PROCESSING_BLOCKER)
{
m_blockerReturnVal = false;
m_blockerState = RETURNED_BLOCKER;
broadcast(&m_blockerSync);
}
// Blocker is waiting - return it
// And push the blocker pipeline forward
if(m_blockerState == PENDING_BLOCKER)
{
m_blockerState = PROCESSING_BLOCKER;
const NVEvent* ev = m_blocker;
pthread_mutex_unlock(&m_accessLock);
return ev;
}
else if (m_nextInsertIndex == m_headIndex)
{
// We're empty - so what do we do?
if (waitMSecs == 0)
{
goto no_event;
}
else
{
// wait for the specified time
wait(&m_consumerSync, &m_accessLock, (unsigned)waitMSecs);
}
// check again after exiting cond waits, either we had a timeout
if(m_blockerState == PENDING_BLOCKER)
{
m_blockerState = PROCESSING_BLOCKER;
const NVEvent* ev = m_blocker;
pthread_mutex_unlock(&(m_accessLock));
return ev;
}
else if (m_nextInsertIndex == m_headIndex)
{
goto no_event;
}
}
{
// One way or another, we have an event...
NVEvent const * ev = m_events + m_headIndex;
m_headIndex = NVNextWrapped(m_headIndex);
pthread_mutex_unlock(&m_accessLock);
return ev;
}
no_event:
pthread_mutex_unlock(&m_accessLock);
return NULL;
}
void NVEventQueue::DoneWithEvent(bool ret)
{
// We only care about blockers for now.
// All other events just NOP
pthread_mutex_lock(&m_accessLock);
if (m_blockerState == PROCESSING_BLOCKER)
{
m_blockerReturnVal = ret;
m_blockerState = RETURNED_BLOCKER;
broadcast(&m_blockerSync);
}
pthread_mutex_unlock(&m_accessLock);
}

89
android/jni/nv_event/nv_event_queue.hpp
View file

@ -1,89 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_event\nv_event_queue.h
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA<49> Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#ifndef NV_EVENT_QUEUE
#define NV_EVENT_QUEUE
#include "nv_event.hpp"
#include <pthread.h>
class NVEventSync
{
public:
pthread_cond_t m_cond;
bool m_block;
};
class NVEventQueue {
public:
void Init();
void Shutdown();
void Flush();
void UnblockConsumer();
void UnblockProducer();
// Events are copied, so caller can reuse ev immediately
void Insert(NVEvent const * ev);
// Waits until the event is consumed. Returns whether the
// consumer indicates handling the event or ignoring it
bool InsertBlocking(NVEvent const * ev);
// Returned event is valid only until the next call to
// RemoveOldest or until a call to DoneWithEvent
// Calling RemoveOldest again without calling DoneWithEvent
// indicates that the last event returned was NOT handled, and
// thus InsertNewestAndWait for that even would return false
const NVEvent* RemoveOldest(int waitMSecs);
// Indicates that all processing of the last event returned
// from RemoveOldest is complete. Also allows the app to indicate
// whether it handled the event or not.
// Do not dereference the last event pointer after calling this function
void DoneWithEvent(bool ret);
protected:
bool insert(NVEvent const * ev);
enum { QUEUE_ELEMS = 256 };
enum { QUEUE_MASK = 0x000000ff };
int32_t m_nextInsertIndex;
int32_t m_headIndex;
pthread_mutex_t m_accessLock;
NVEventSync m_blockerSync;
NVEventSync m_consumerSync;
NVEvent m_events[QUEUE_ELEMS];
NVEvent const * m_blocker;
enum BlockerState
{
NO_BLOCKER,
PENDING_BLOCKER,
PROCESSING_BLOCKER,
RETURNED_BLOCKER
};
BlockerState m_blockerState;
bool m_blockerReturnVal;
};
#endif // #ifndef NV_EVENT_QUEUE

147
android/jni/nv_event/nv_keycode_mapping.hpp
View file

@ -1,147 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_event\nv_keycode_mapping.h
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA® Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
class NVKeyCodeMapping
{
public:
NVKeyCodeMapping()
{
memset(m_keyMapping, 0, sizeof(NVKeyCode) * NV_MAX_KEYCODE);
}
void Init(JNIEnv* env, jobject thiz);
bool MapKey(int key, NVKeyCode& code);
protected:
void AddKeyMapping(JNIEnv* env, jobject thiz, jclass KeyCode_class, const char* name, NVKeyCode value);
NVKeyCode m_keyMapping[NV_MAX_KEYCODE];
};
/* Init the mapping array, set up the event queue */
void NVKeyCodeMapping::AddKeyMapping(JNIEnv* env, jobject thiz, jclass KeyCode_class, const char* name, NVKeyCode value)
{
// Add a new mapping...
jfieldID id = env->GetStaticFieldID(KeyCode_class, name, "I");
int keyID = env->GetStaticIntField(KeyCode_class, id);
if (keyID < NV_MAX_KEYCODE)
{
/* TODO TBD Should check for collision */
m_keyMapping[keyID] = value;
}
}
#define AddKeymappingMacro(name, value) \
AddKeyMapping(env, thiz, KeyCode_class, name, value)
void NVKeyCodeMapping::Init(JNIEnv* env, jobject thiz)
{
jclass KeyCode_class = env->FindClass("android/view/KeyEvent");
AddKeymappingMacro("KEYCODE_BACK",NV_KEYCODE_BACK);
AddKeymappingMacro("KEYCODE_TAB",NV_KEYCODE_TAB);
AddKeymappingMacro("KEYCODE_ENTER",NV_KEYCODE_ENTER);
AddKeymappingMacro("KEYCODE_SPACE",NV_KEYCODE_SPACE);
AddKeymappingMacro("KEYCODE_ENDCALL",NV_KEYCODE_ENDCALL);
AddKeymappingMacro("KEYCODE_HOME",NV_KEYCODE_HOME);
AddKeymappingMacro("KEYCODE_DPAD_LEFT",NV_KEYCODE_DPAD_LEFT);
AddKeymappingMacro("KEYCODE_DPAD_UP",NV_KEYCODE_DPAD_UP);
AddKeymappingMacro("KEYCODE_DPAD_RIGHT",NV_KEYCODE_DPAD_RIGHT);
AddKeymappingMacro("KEYCODE_DPAD_DOWN",NV_KEYCODE_DPAD_DOWN);
AddKeymappingMacro("KEYCODE_DEL",NV_KEYCODE_DEL);
AddKeymappingMacro("KEYCODE_0",NV_KEYCODE_0);
AddKeymappingMacro("KEYCODE_1",NV_KEYCODE_1);
AddKeymappingMacro("KEYCODE_2",NV_KEYCODE_2);
AddKeymappingMacro("KEYCODE_3",NV_KEYCODE_3);
AddKeymappingMacro("KEYCODE_4",NV_KEYCODE_4);
AddKeymappingMacro("KEYCODE_5",NV_KEYCODE_5);
AddKeymappingMacro("KEYCODE_6",NV_KEYCODE_6);
AddKeymappingMacro("KEYCODE_7",NV_KEYCODE_7);
AddKeymappingMacro("KEYCODE_8",NV_KEYCODE_8);
AddKeymappingMacro("KEYCODE_9",NV_KEYCODE_9);
AddKeymappingMacro("KEYCODE_A",NV_KEYCODE_A);
AddKeymappingMacro("KEYCODE_B",NV_KEYCODE_B);
AddKeymappingMacro("KEYCODE_C",NV_KEYCODE_C);
AddKeymappingMacro("KEYCODE_D",NV_KEYCODE_D);
AddKeymappingMacro("KEYCODE_E",NV_KEYCODE_E);
AddKeymappingMacro("KEYCODE_F",NV_KEYCODE_F);
AddKeymappingMacro("KEYCODE_G",NV_KEYCODE_G);
AddKeymappingMacro("KEYCODE_H",NV_KEYCODE_H);
AddKeymappingMacro("KEYCODE_I",NV_KEYCODE_I);
AddKeymappingMacro("KEYCODE_J",NV_KEYCODE_J);
AddKeymappingMacro("KEYCODE_K",NV_KEYCODE_K);
AddKeymappingMacro("KEYCODE_L",NV_KEYCODE_L);
AddKeymappingMacro("KEYCODE_M",NV_KEYCODE_M);
AddKeymappingMacro("KEYCODE_N",NV_KEYCODE_N);
AddKeymappingMacro("KEYCODE_O",NV_KEYCODE_O);
AddKeymappingMacro("KEYCODE_P",NV_KEYCODE_P);
AddKeymappingMacro("KEYCODE_Q",NV_KEYCODE_Q);
AddKeymappingMacro("KEYCODE_R",NV_KEYCODE_R);
AddKeymappingMacro("KEYCODE_S",NV_KEYCODE_S);
AddKeymappingMacro("KEYCODE_T",NV_KEYCODE_T);
AddKeymappingMacro("KEYCODE_U",NV_KEYCODE_U);
AddKeymappingMacro("KEYCODE_V",NV_KEYCODE_V);
AddKeymappingMacro("KEYCODE_W",NV_KEYCODE_W);
AddKeymappingMacro("KEYCODE_X",NV_KEYCODE_X);
AddKeymappingMacro("KEYCODE_Y",NV_KEYCODE_Y);
AddKeymappingMacro("KEYCODE_Z",NV_KEYCODE_Z);
AddKeymappingMacro("KEYCODE_STAR",NV_KEYCODE_STAR);
AddKeymappingMacro("KEYCODE_PLUS",NV_KEYCODE_PLUS);
AddKeymappingMacro("KEYCODE_MINUS",NV_KEYCODE_MINUS);
AddKeymappingMacro("KEYCODE_NUM",NV_KEYCODE_NUM);
AddKeymappingMacro("KEYCODE_ALT_LEFT",NV_KEYCODE_ALT_LEFT);
AddKeymappingMacro("KEYCODE_ALT_RIGHT",NV_KEYCODE_ALT_RIGHT);
AddKeymappingMacro("KEYCODE_SHIFT_LEFT",NV_KEYCODE_SHIFT_LEFT);
AddKeymappingMacro("KEYCODE_SHIFT_RIGHT",NV_KEYCODE_SHIFT_RIGHT);
AddKeymappingMacro("KEYCODE_APOSTROPHE",NV_KEYCODE_APOSTROPHE);
AddKeymappingMacro("KEYCODE_SEMICOLON",NV_KEYCODE_SEMICOLON);
AddKeymappingMacro("KEYCODE_EQUALS",NV_KEYCODE_EQUALS);
AddKeymappingMacro("KEYCODE_COMMA",NV_KEYCODE_COMMA);
AddKeymappingMacro("KEYCODE_PERIOD",NV_KEYCODE_PERIOD);
AddKeymappingMacro("KEYCODE_SLASH",NV_KEYCODE_SLASH);
AddKeymappingMacro("KEYCODE_GRAVE",NV_KEYCODE_GRAVE);
AddKeymappingMacro("KEYCODE_LEFT_BRACKET",NV_KEYCODE_LEFT_BRACKET);
AddKeymappingMacro("KEYCODE_BACKSLASH",NV_KEYCODE_BACKSLASH);
AddKeymappingMacro("KEYCODE_RIGHT_BRACKET",NV_KEYCODE_RIGHT_BRACKET);
}
bool NVKeyCodeMapping::MapKey(int key, NVKeyCode& code)
{
if (key < NV_MAX_KEYCODE)
{
code = m_keyMapping[key];
return true;
}
else
return false;
}

82
android/jni/nv_event/scoped_profiler.hpp
View file

@ -1,82 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_event\scoped_profiler.h
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA® Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#ifndef SCOPED_PROFILER_H
#define SCOPED_PROFILER_H
#define PERF_STMTS 0
#if PERF_STMTS == 1
#include "../nv_time/nv_time.hpp"
#include "stdio.h"
#include "stdlib.h"
static char s_bigString[4096];
static int s_bigStringSize;
static char s_tmpBuf[1024];
class ScopedProfiler
{
public:
ScopedProfiler(const char* text)
{
_text = text;
_startTime = nvGetSystemTime();
__last = this;
}
~ScopedProfiler()
{
stop();
}
inline void stop()
{
if(_text)
{
int size = snprintf(s_tmpBuf, dimof(s_tmpBuf)-1, "%d ms spent in %s" , (int)(nvGetSystemTime() - _startTime), _text);
strcat(s_bigString + s_bigStringSize, s_tmpBuf);
s_bigStringSize += size;
_text = 0;
}
static void stopLast()
{
if(__last)
__last->stop();
__last = 0;
}
const char* _text;
long _startTime;
static ScopedProfiler* __last;
};
ScopedProfiler* ScopedProfiler::__last = 0;
#define STRINGIFIER(s) #s
#define CONCAT_(a,b) a ## b
#define CONCAT(a,b) CONCAT_(a,b)
#define PERFBLURB(s) static const char CONCAT(___str,__LINE__)[] = s "\n"; ScopedProfiler CONCAT(SCOPED_PROFILER,__LINE__)(CONCAT(___str,__LINE__));
#define RESET_PROFILING() { DEBUG_D("%s", s_bigString); s_bigString[0] = 0; s_bigStringSize = 0; }
#else
#define PERFBLURB(s)
#define RESET_PROFILING()
#endif
#endif // SCOPED_PROFILER_H

136
android/jni/nv_thread/nv_thread.cpp
View file

@ -1,136 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_thread\nv_thread.c
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA<49> Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#include <jni.h>
#include "nv_thread.hpp"
#include <android/log.h>
#include <pthread.h>
static JavaVM* s_vm = NULL;
static pthread_key_t s_jniEnvKey = 0;
#define MODULE "NVThread"
#include "../nv_debug/nv_debug.hpp"
#include "../com/mapswithme/core/jni_helper.hpp"
void NVThreadInit(JavaVM* vm)
{
s_vm = vm;
}
JNIEnv* NVThreadGetCurrentJNIEnv()
{
return jni::GetEnv();
}
typedef void * (*StartRoutine)(void *);
typedef struct NVThreadInitStruct
{
void* m_arg;
StartRoutine m_startRoutine;
} NVThreadInitStruct;
// Implementations are in PThreadImpl.cpp
// They're used automatically if thread is created with base/thread.hpp
// @TODO: refactor and remove
void AndroidThreadAttachToJVM();
void AndroidThreadDetachFromJVM();
static void * NVThreadSpawnProc(void* arg)
{
NVThreadInitStruct * init = (NVThreadInitStruct *)arg;
StartRoutine startRoutine = init->m_startRoutine;
void * data = init->m_arg;
void * ret;
free(arg);
AndroidThreadAttachToJVM();
ret = startRoutine(data);
AndroidThreadDetachFromJVM();
return ret;
}
int NVThreadSpawnJNIThread(pthread_t * thread, pthread_attr_t const * attr,
StartRoutine startRoutine, void * arg)
{
if (!startRoutine)
return -1;
NVThreadInitStruct * initData = new NVThreadInitStruct;
initData->m_startRoutine = startRoutine;
initData->m_arg = arg;
int err = pthread_create(thread, attr, NVThreadSpawnProc, initData);
// If the thread was not started, then we need to delete the init data ourselves
if (err)
free(initData);
return err;
}
// on linuces, signals can interrupt sleep functions, so you might need to
// retry to get the full sleep going. I'm not entirely sure this is necessary
// *here* clients could retry themselves when the exposed function returns
// nonzero
inline int __sleep(const struct timespec *req, struct timespec *rem)
{
int ret = 1;
int i;
static const int sleepTries = 2;
struct timespec req_tmp={0}, rem_tmp={0};
rem_tmp = *req;
for(i = 0; i < sleepTries; ++i)
{
req_tmp = rem_tmp;
int ret = nanosleep(&req_tmp, &rem_tmp);
if(ret == 0)
{
ret = 0;
break;
}
}
if(rem)
*rem = rem_tmp;
return ret;
}
int NVThreadSleep(unsigned long millisec)
{
struct timespec req={0},rem={0};
time_t sec =(int)(millisec/1000);
millisec = millisec-(sec*1000);
req.tv_sec = sec;
req.tv_nsec = millisec*1000000L;
return __sleep(&req,&rem);
}

97
android/jni/nv_thread/nv_thread.hpp
View file

@ -1,97 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_thread\nv_thread.h
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA® Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#ifndef __INCLUDED_NV_THREAD_H
#define __INCLUDED_NV_THREAD_H
#include <jni.h>
#include <pthread.h>
#include <stdlib.h>
#if defined(__cplusplus)
extern "C"
{
#endif
/** @file nv_thread.h
The NVThread library makes it easy to create native threads that can acess
JNI objects. By default, pthreads created in the Android NDK are NOT connected
to the JVM and JNI calls will fail. This library wraps thread creation in
such a way that pthreads created using it will connect to and disconnect from
the JVM as appropriate. Applications creating all of their threads with these
interfaces can use the provided NVThreadGetCurrentJNIEnv() function to
get the current thread's JNI context at any time.
Note that native-created threads still have JNI limitations over threads
that are calls down to native from Java. The JNI function FindClass will
NOT find application-specific classes when called from native threads.
Native code that needs to call FindClass and record the indices of Java
class members for later access must call FindClass and Get*FieldID/Get*MethodID
in threads calling from Java, such as JNI_OnLoad
*/
/**
Initializes the nv_thread system by connecting it to the JVM. This
function must be called as early as possible in the native code's
JNI_OnLoad function, so that the thread system is prepared for any
JNI-dependent library initialization calls.
@param vm The VM pointer - should be the JavaVM pointer sent to JNI_OnLoad.
*/
void NVThreadInit(JavaVM* vm);
/**
Retrieves the JNIEnv object associated with the current thread, allowing
any thread that was creating with NVThreadSpawnJNIThread() to access the
JNI at will. This JNIEnv is NOT usable across multiple calls or threads
The function should be called in each function that requires a JNIEnv
@return The current thread's JNIEnv, or NULL if the thread was not created
by NVThreadSpawnJNIThread
@see NVThreadSpawnJNIThread
*/
JNIEnv* NVThreadGetCurrentJNIEnv();
/**
Spwans a new native thread that is registered for use with JNI. Threads
created with this function will have access to JNI data via the JNIEnv
available from NVThreadGetCurrentJNIEnv().
@param thread is the same as in pthread_create
@param attr is the same as in pthread_create
@param start_routine is the same as in pthread_create
@param arg is the same as in pthread_create
@return 0 on success, -1 on failure
@see NVThreadGetCurrentJNIEnv
*/
int NVThreadSpawnJNIThread(pthread_t *thread, pthread_attr_t const * attr,
void *(*start_routine)(void *), void * arg);
/**
Sleeps the current thread for the specified number of milliseconds
@param millisec Sleep time in ms
@return 0 on success, -1 on failure
*/
int NVThreadSleep(unsigned long millisec);
#if defined(__cplusplus)
}
#endif
#endif

47
android/jni/nv_time/nv_time.cpp
View file

@ -1,47 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_time\nv_time.cpp
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA® Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#include "nv_time.hpp"
#include "../nv_thread/nv_thread.hpp"
#include <time.h>
#include <jni.h>
#include <android/log.h>
#include <stdio.h>
#include <unistd.h>
long nvGetSystemTime()
{
static struct timeval start_time, end_time;
static int isinit = 0;
jlong curr_time = 0;
if (!isinit)
{
gettimeofday(&start_time, 0);
isinit = 1;
}
gettimeofday(&end_time, 0);
curr_time = (end_time.tv_sec - start_time.tv_sec) * 1000;
curr_time += (end_time.tv_usec - start_time.tv_usec) / 1000;
return curr_time;
}

30
android/jni/nv_time/nv_time.hpp
View file

@ -1,30 +0,0 @@
//----------------------------------------------------------------------------------
// File: libs\jni\nv_time\nv_time.h
// Samples Version: NVIDIA Android Lifecycle samples 1_0beta
// Email: tegradev@nvidia.com
// Web: http://developer.nvidia.com/category/zone/mobile-development
//
// Copyright 2009-2011 NVIDIA® Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//----------------------------------------------------------------------------------
#ifndef __INCLUDED_NV_TIME_H
#define __INCLUDED_NV_TIME_H
#include <stdlib.h>
long nvGetSystemTime();
#endif

39
android/jni/opengl/android_gl_utils.h
View file

@ -1,39 +0,0 @@
#pragma once
#include <EGL/egl.h>
#include <GLES2/gl2.h>
class ConfigComparator
{
public:
ConfigComparator(EGLDisplay display)
: m_display(display)
{}
int operator()(EGLConfig const & l, EGLConfig const & r) const
{
return configWeight(l) - configWeight(r);
}
int configWeight(EGLConfig const & config) const
{
int val = -1;
eglGetConfigAttrib(m_display, config, EGL_CONFIG_CAVEAT, &val);
switch (val)
{
case EGL_NONE:
return 0;
case EGL_SLOW_CONFIG:
return 1;
case EGL_NON_CONFORMANT_CONFIG:
return 2;
default:
return 0;
}
}
private:
EGLDisplay m_display;
};

117
android/jni/opengl/androidoglcontextfactory.cpp
View file

@ -1,117 +0,0 @@
#include "androidoglcontextfactory.h"
#include "android_gl_utils.h"
#include "base/assert.hpp"
#include "std/algorithm.hpp"
static EGLint * getConfigAttributesList()
{
static EGLint attr_list[] = {
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_STENCIL_SIZE, 0,
EGL_DEPTH_SIZE, 16,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT,
EGL_NONE
};
return attr_list;
}
AndroidOGLContextFactory::AndroidOGLContextFactory(JNIEnv * env, jobject jsurface)
: m_drawContext(NULL)
, m_uploadContext(NULL)
, m_windowSurface(EGL_NO_SURFACE)
, m_pixelbufferSurface(EGL_NO_SURFACE)
, m_config(NULL)
, m_nativeWindow(NULL)
, m_display(EGL_NO_DISPLAY)
{
CHECK(jsurface, ());
m_nativeWindow = ANativeWindow_fromSurface(env, jsurface);
ASSERT(m_nativeWindow, ());
m_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
ASSERT(m_display != EGL_NO_DISPLAY, ());
EGLint version[2] = {0};
VERIFY(eglInitialize(m_display, &version[0], &version[1]), ());
createWindowSurface();
createPixelbufferSurface();
}
AndroidOGLContextFactory::~AndroidOGLContextFactory()
{
delete m_drawContext;
delete m_uploadContext;
eglDestroySurface(m_display, m_windowSurface);
eglDestroySurface(m_display, m_pixelbufferSurface);
eglTerminate(m_display);
ANativeWindow_release(m_nativeWindow);
}
OGLContext * AndroidOGLContextFactory::getDrawContext()
{
ASSERT(m_windowSurface != EGL_NO_SURFACE, ());
if (m_drawContext == NULL)
m_drawContext = new AndroidOGLContext(m_display, m_windowSurface, m_config, m_uploadContext);
return m_drawContext;
}
OGLContext * AndroidOGLContextFactory::getResourcesUploadContext()
{
ASSERT(m_pixelbufferSurface != EGL_NO_SURFACE, ());
if (m_uploadContext == NULL)
m_uploadContext = new AndroidOGLContext(m_display, m_pixelbufferSurface, m_config, m_drawContext);
return m_uploadContext;
}
void AndroidOGLContextFactory::createWindowSurface()
{
EGLConfig configs[40];
int count = 0;
VERIFY(eglChooseConfig(m_display, getConfigAttributesList(), configs, 40, &count) == EGL_TRUE, ());
ASSERT(count > 0, ("Didn't find any configs."));
sort(&configs[0], &configs[count], ConfigComparator(m_display));
for (int i = 0; i < count; ++i)
{
EGLConfig currentConfig = configs[i];
m_windowSurface = eglCreateWindowSurface(m_display, currentConfig, m_nativeWindow, EGL_BACK_BUFFER);
if (m_windowSurface == EGL_NO_SURFACE)
continue;
else
m_config = currentConfig;
EGLint configId = 0;
eglGetConfigAttrib(m_display, m_config, EGL_CONFIG_ID, &configId);
LOG(LINFO, ("Choosen config id:", configId));
break;
}
CHECK(m_config != NULL, ());
CHECK(m_windowSurface != EGL_NO_SURFACE, ());
}
void AndroidOGLContextFactory::createPixelbufferSurface()
{
ASSERT(m_config != NULL, ());
const GLuint size = 1; // yes, 1 is the correct size, we dont really draw on it
static EGLint surfaceConfig[] = {
EGL_WIDTH, size, EGL_HEIGHT, size, EGL_NONE
};
m_pixelbufferSurface = eglCreatePbufferSurface(m_display, m_config, surfaceConfig);
CHECK(m_pixelbufferSurface != EGL_NO_SURFACE, ());
}

30
android/jni/opengl/androidoglcontextfactory.h
View file

@ -1,30 +0,0 @@
#pragma once
#include "androidoglcontext.hpp"
#include "drape/oglcontextfactory.hpp"
class AndroidOGLContextFactory : public OGLContextFactory
{
public:
AndroidOGLContextFactory(JNIEnv * env, jobject jsurface);
~AndroidOGLContextFactory();
virtual OGLContext * getDrawContext();
virtual OGLContext * getResourcesUploadContext();
private:
void createWindowSurface();
void createPixelbufferSurface();
AndroidOGLContext * m_drawContext;
AndroidOGLContext * m_uploadContext;
EGLSurface m_windowSurface;
EGLSurface m_pixelbufferSurface;
EGLConfig m_config;
ANativeWindow * m_nativeWindow;
EGLDisplay m_display;
};

10
android/res/anim/slide_appear_down.xml
View file

@ -1,10 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
<translate android:fromYDelta="-100%"
android:toYDelta="0%"
android:duration="@integer/anim_default"/>
<alpha android:fromAlpha="0.1"
android:toAlpha="1"
android:duration="@integer/anim_default"/>
</set>

10
android/res/anim/slide_disappear_up.xml
View file

@ -1,10 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
<translate android:fromYDelta="0%"
android:toYDelta="-100%"
android:duration="@integer/anim_default"/>
<alpha android:fromAlpha="1"
android:toAlpha="0.1"
android:duration="@integer/anim_default"/>
</set>

2
android/res/values-ar/strings.xml
View file

@ -92,7 +92,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nقد تم إضافته الى صف الانتظار لعملية التنزيل</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">جاري التنزيل\n^\n^%</string>
<string name="country_status_downloading">جاري التنزيل\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">(^ ^)\nتحميل الخريطة</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-cs/strings.xml
View file

@ -89,7 +89,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\npřidáno do fronty stahování</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Stahování\n^\n^%</string>
<string name="country_status_downloading">Stahování\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Stáhnout mapu\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-da/strings.xml
View file

@ -90,7 +90,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\ner tilføjet til download-køen</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Downloader\n^\n^%</string>
<string name="country_status_downloading">Downloader\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Download kort\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-de/strings.xml
View file

@ -89,7 +89,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nwird zur Download-Warteschleife hinzugefügt</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Wird heruntergeladen\n^\n^%</string>
<string name="country_status_downloading">Wird heruntergeladen\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Karte herunterladen\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-es/strings.xml
View file

@ -87,7 +87,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nañadido a la cola de descarga</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Descargando\n^\n^%</string>
<string name="country_status_downloading">Descargando\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Descargar mapa\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-fi/strings.xml
View file

@ -94,7 +94,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\non lisätty latausjonoon.</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Ladataan\n^\n^%</string>
<string name="country_status_downloading">Ladataan\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Lataa kartta\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-fr/strings.xml
View file

@ -93,7 +93,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nest ajouté à la file de téléchargement</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Téléchargement de\n^\n^%</string>
<string name="country_status_downloading">Téléchargement de\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Téléchargez la carte\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-hu/strings.xml
View file

@ -89,7 +89,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\n-t hozzáadtuk a letöltési sorhoz</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">^\n^%\nletöltése folyamatban</string>
<string name="country_status_downloading">^\n^\nletöltése folyamatban</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Térkép letöltése\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-in/strings.xml
View file

@ -94,7 +94,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\ntelah ditambahkan ke antrean pengunduhan.</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Sedang mengunduh\n^\n^%</string>
<string name="country_status_downloading">Sedang mengunduh\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Unduh Peta\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-it/strings.xml
View file

@ -87,7 +87,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\naggiunto alla coda di download</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Sto scaricando\n^\n^%</string>
<string name="country_status_downloading">Sto scaricando\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Scarica Map\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-ja/strings.xml
View file

@ -87,7 +87,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nをダウンロードキューに追加しました</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">^\n^%\nをダウンロード中</string>
<string name="country_status_downloading">^\n^\nをダウンロード中</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">地図をダウンロード\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-ko/strings.xml
View file

@ -86,7 +86,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\n는 다운로드 대기열에추가됩니다</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">다운로드 중\n^\n^%</string>
<string name="country_status_downloading">다운로드 중\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">지도 다운로드\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-nb/strings.xml
View file

@ -94,7 +94,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\ner lagt til i nedlastingskøen.</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Laster ned\n^\n^%</string>
<string name="country_status_downloading">Laster ned\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Last ned kart\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-nl/strings.xml
View file

@ -85,7 +85,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nis toegevoegd aan de download wachtrij</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">aan het downloaden\n^\n^%</string>
<string name="country_status_downloading">aan het downloaden\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Kaart downloaden\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-pl/strings.xml
View file

@ -89,7 +89,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\ndodano do kolejki pobierania</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Pobieranie\n^\n^%</string>
<string name="country_status_downloading">Pobieranie\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Pobierz mapę\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-pt/strings.xml
View file

@ -87,7 +87,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\né adicionado à fila de descargas</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">A descarregar\n^\n^%</string>
<string name="country_status_downloading">A descarregar\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Descarregar Mapa\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-ro/strings.xml
View file

@ -94,7 +94,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\neste adăugată la coada de descărcare.</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Se descarcă\n^\n^%</string>
<string name="country_status_downloading">Se descarcă\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Descărcare hartă\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-ru/strings.xml
View file

@ -93,7 +93,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nдобавлено в очередь загрузки</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Загружается\n^\n^%</string>
<string name="country_status_downloading">Загружается\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Загрузить карту\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-sk/strings.xml
View file

@ -89,7 +89,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\npridané do zoznamu sťahovania</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Sťahovanie\n^\n^%</string>
<string name="country_status_downloading">Sťahovanie\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Stiahnite si Mapu\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-sv/strings.xml
View file

@ -88,7 +88,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\när tillagd till nedladdningskön</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Laddar ner\n^\n^%</string>
<string name="country_status_downloading">Laddar ner\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Ladda ner karta\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-th/strings.xml
View file

@ -92,7 +92,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">มีการเพิ่ม ^\nไปยังลำดับการดาวน์โหลดแล้ว</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">กำลังดาวน์โหลด\n^\n^%</string>
<string name="country_status_downloading">กำลังดาวน์โหลด\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">ดาวน์โหลดแผนที่\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-tr/strings.xml
View file

@ -92,7 +92,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nindirme kuyruğuna eklendi</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">^\n^%\nindiriliyor</string>
<string name="country_status_downloading">^\n^\nindiriliyor</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Haritayı İndir\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-uk/strings.xml
View file

@ -93,7 +93,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nдобавлено в чергу завантаження</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Завантажується\n^\n^%</string>
<string name="country_status_downloading">Завантажується\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Завантажити мапу\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-vi/strings.xml
View file

@ -94,7 +94,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nđã được thêm vào danh sách đợi tải xuống.</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Đang tải xuống\n^\n^%</string>
<string name="country_status_downloading">Đang tải xuống\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Tải xuống Bản đồ\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-zh-rTW/strings.xml
View file

@ -90,7 +90,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\n已加入到下載佇列中</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">下載中\n^\n^%</string>
<string name="country_status_downloading">下載中\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">下載地圖\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values-zh/strings.xml
View file

@ -88,7 +88,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\n添加至下载序列</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">下载 \n^\n^%中</string>
<string name="country_status_downloading">下载 \n^\n^中</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">下载地图\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

2
android/res/values/strings.xml
View file

@ -94,7 +94,7 @@
<!-- Message to display at the center of the screen when the country is added to the downloading queue -->
<string name="country_status_added_to_queue">^\nis added to the downloading queue.</string>
<!-- Message to display at the center of the screen when the country is downloading -->
<string name="country_status_downloading">Downloading\n^\n^%</string>
<string name="country_status_downloading">Downloading\n^\n^</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->
<string name="country_status_download">Download Map\n(^ ^)</string>
<!-- Button text for the button at the center of the screen when the country is not downloaded -->

1
android/src/com/mapswithme/country/DownloadActivity.java
View file

@ -3,6 +3,7 @@ package com.mapswithme.country;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentTransaction;
import android.util.Log;
import com.mapswithme.maps.base.BaseMwmFragmentActivity;

13
android/src/com/mapswithme/maps/Framework.java
View file

@ -20,13 +20,6 @@ public class Framework
public static final int ROUTER_TYPE_VEHICLE = 0;
public static final int ROUTER_TYPE_PEDESTRIAN = 1;
// should correspond to values from 'information_display.hpp' in core
public static final int MAP_WIDGET_RULER = 0;
public static final int MAP_WIDGET_COPYRIGHT = 1;
public static final int MAP_WIDGET_COUNTRY_STATUS = 2;
public static final int MAP_WIDGET_COMPASS = 3;
public static final int MAP_WIDGET_DEBUG_LABEL = 4;
@SuppressWarnings("unused")
public interface OnBalloonListener
{
@ -87,8 +80,6 @@ public class Framework
public native static MapObject nativeGetMapObjectForPoint(double lat, double lon);
public native static void nativeActivateUserMark(double lat, double lon);
public native static void nativeSetBalloonListener(OnBalloonListener listener);
public native static void nativeRemoveBalloonListener();
@ -103,8 +94,6 @@ public class Framework
public native static void injectData(SearchResult searchResult, long index);
public native static void invalidate();
public native static void deactivatePopup();
public native static String[] nativeGetMovableFilesExts();
@ -182,8 +171,6 @@ public class Framework
public native static void nativeSetRouteEndPoint(double lat, double lon, boolean valid);
public native static void setWidgetPivot(int widget, int pivotX, int pivotY);
/**
* Registers all maps(.mwms). Adds them to the models, generates indexes and does all necessary stuff.
*/

20
android/src/com/mapswithme/maps/LocationState.java
View file

@ -4,32 +4,20 @@ public enum LocationState
{
INSTANCE;
// These values should correspond to values of location::State::Mode defined in map/location_state.hpp
/// These values should correspond to values of
/// location::EMyPositionMode defined in platform/location.hpp
public static final int UNKNOWN_POSITION = 0x0;
public static final int PENDING_POSITION = 0x1;
public static final int NOT_FOLLOW = 0x2;
public static final int FOLLOW = 0x3;
public static final int ROTATE_AND_FOLLOW = 0x4;
public static final int SLOT_UNDEFINED = -1;
public native void switchToNextMode();
public native int getLocationStateMode();
/*
* Adds listener
* @param l
* @return slotId of added listener
*/
public native int addLocationStateModeListener(Object l);
/**
* Removes listener with slotId
*
* @param slotId slotId of listener to remove
*/
public native void removeLocationStateModeListener(int slotId);
public native void setMyPositionModeListener(Object l);
public native void removeMyPositionModeListener();
public native void turnOff();

314
android/src/com/mapswithme/maps/MapFragment.java
View file

@ -2,18 +2,54 @@ package com.mapswithme.maps;
import android.app.Activity;
import android.content.DialogInterface;
import android.graphics.Rect;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AlertDialog;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.util.DisplayMetrics;
import android.view.*;
import com.mapswithme.maps.base.BaseMwmFragment;
import com.mapswithme.maps.downloader.DownloadHelper;
import com.mapswithme.util.UiUtils;
import com.nvidia.devtech.NvEventQueueFragment;
import com.mapswithme.util.concurrency.UiThread;
public class MapFragment extends NvEventQueueFragment
public class MapFragment extends BaseMwmFragment
implements View.OnTouchListener,
SurfaceHolder.Callback
{
// Should correspond to android::MultiTouchAction from Framework.cpp
private static final int NATIVE_ACTION_UP = 0x01;
private static final int NATIVE_ACTION_DOWN = 0x02;
private static final int NATIVE_ACTION_MOVE = 0x03;
private static final int NATIVE_ACTION_CANCEL = 0x04;
// Should correspond to gui::EWidget from skin.hpp
private static final int WIDGET_RULER = 0x01;
private static final int WIDGET_COMPASS = 0x02;
private static final int WIDGET_COPYRIGHT = 0x04;
private static final int WIDGET_SCALE_LABEL = 0x08;
// Should correspond to dp::Anchor from drape_global.hpp
private static final int ANCHOR_CENTER = 0x00;
private static final int ANCHOR_LEFT = 0x01;
private static final int ANCHOR_RIGHT = (ANCHOR_LEFT << 1);
private static final int ANCHOR_TOP = (ANCHOR_RIGHT << 1);
private static final int ANCHOR_BOTTOM = (ANCHOR_TOP << 1);
private static final int ANCHOR_LEFT_TOP = (ANCHOR_LEFT | ANCHOR_TOP);
private static final int ANCHOR_RIGHT_TOP = (ANCHOR_RIGHT | ANCHOR_TOP);
private static final int ANCHOR_LEFT_BOTTOM = (ANCHOR_LEFT | ANCHOR_BOTTOM);
private static final int ANCHOR_RIGHT_BOTTOM = (ANCHOR_RIGHT | ANCHOR_BOTTOM);
// Should correspond to df::TouchEvent::INVALID_MASKED_POINTER from user_event_stream.cpp
private static final int INVALID_POINTER_MASK = 0xFF;
private static final int INVALID_TOUCH_ID = -1;
private int mHeight;
private int mWidth;
private boolean mRequireResize;
private boolean mEngineCreated;
private static boolean sWasCopyrightDisplayed;
public interface MapRenderingListener
{
void onRenderingInitialized();
@ -21,24 +57,139 @@ public class MapFragment extends NvEventQueueFragment
public static final String FRAGMENT_TAG = MapFragment.class.getName();
protected native void nativeConnectDownloadButton();
private void setupWidgets(int width, int height)
{
mHeight = height;
mWidth = width;
protected native void nativeDownloadCountry(MapStorage.Index index, int options);
nativeCleanWidgets();
if (!sWasCopyrightDisplayed)
{
nativeSetupWidget(WIDGET_COPYRIGHT,
mWidth - UiUtils.dimen(R.dimen.margin_ruler_right),
mHeight - UiUtils.dimen(R.dimen.margin_ruler_bottom),
ANCHOR_RIGHT_BOTTOM);
sWasCopyrightDisplayed = true;
}
protected native void nativeOnLocationError(int errorCode);
nativeSetupWidget(WIDGET_RULER,
mWidth - UiUtils.dimen(R.dimen.margin_ruler_right),
mHeight - UiUtils.dimen(R.dimen.margin_ruler_bottom),
ANCHOR_RIGHT_BOTTOM);
protected native void nativeLocationUpdated(long time, double lat, double lon, float accuracy, double altitude, float speed, float bearing);
if (BuildConfig.DEBUG)
{
nativeSetupWidget(WIDGET_SCALE_LABEL,
UiUtils.dimen(R.dimen.margin_base),
UiUtils.dimen(R.dimen.margin_base),
ANCHOR_LEFT_TOP);
}
protected native void nativeCompassUpdated(double magneticNorth, double trueNorth, boolean force);
setupCompass(0, 0, false);
}
protected native void nativeScale(double k);
void setupCompass(int offsetX, int offsetY, boolean forceRedraw)
{
nativeSetupWidget(WIDGET_COMPASS,
UiUtils.dimen(R.dimen.margin_compass_left) + offsetX,
mHeight - UiUtils.dimen(R.dimen.margin_compass_bottom) + offsetY,
ANCHOR_CENTER);
if (forceRedraw)
nativeApplyWidgets();
}
public native boolean showMapForUrl(String url);
void setupRuler(int offsetX, int offsetY, boolean forceRedraw)
{
nativeSetupWidget(WIDGET_RULER,
mWidth - UiUtils.dimen(R.dimen.margin_ruler_right) + offsetX,
mHeight - UiUtils.dimen(R.dimen.margin_ruler_bottom) + offsetY,
ANCHOR_RIGHT_BOTTOM);
if (forceRedraw)
nativeApplyWidgets();
}
private void onRenderingInitialized()
{
final Activity activity = getActivity();
if (isAdded() && activity instanceof MapRenderingListener)
((MapRenderingListener) activity).onRenderingInitialized();
}
private void reportUnsupported()
{
new AlertDialog.Builder(getActivity())
.setMessage(getString(R.string.unsupported_phone))
.setCancelable(false)
.setPositiveButton(getString(R.string.close), new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dlg, int which)
{
getActivity().moveTaskToBack(true);
}
}).show();
}
@Override
public void onCreate(Bundle savedInstanceState)
public void surfaceCreated(SurfaceHolder surfaceHolder)
{
super.onCreate(savedInstanceState);
final Surface surface = surfaceHolder.getSurface();
if (nativeIsEngineCreated())
{
nativeAttachSurface(surface);
mRequireResize = true;
return;
}
mRequireResize = false;
final Rect rect = surfaceHolder.getSurfaceFrame();
setupWidgets(rect.width(), rect.height());
final DisplayMetrics dm = getActivity().getResources().getDisplayMetrics();
final float exactDensityDpi = (dm.xdpi + dm.ydpi) / 2;
mEngineCreated = nativeCreateEngine(surface, (int)exactDensityDpi);
if (mEngineCreated)
onRenderingInitialized();
else
reportUnsupported();
}
@Override
public void surfaceChanged(SurfaceHolder surfaceHolder, int format, int width, int height)
{
if (!mEngineCreated ||
(!mRequireResize && surfaceHolder.isCreating()))
return;
nativeSurfaceChanged(width, height);
mRequireResize = false;
setupWidgets(width, height);
nativeApplyWidgets();
}
@Override
public void surfaceDestroyed(SurfaceHolder surfaceHolder)
{
if (!mEngineCreated)
return;
if (getActivity() == null || !getActivity().isChangingConfigurations())
{
// We're in the main thread here. So nothing from the queue will be run between these two calls.
// Destroy engine first, then clear the queue that theoretically can be filled by nativeDestroyEngine().
nativeDestroyEngine();
MwmApplication.get().clearFunctorsOnUiThread();
}
else
nativeDetachSurface();
}
@Override
public void onCreate(Bundle b)
{
super.onCreate(b);
setRetainInstance(true);
}
@ -52,92 +203,103 @@ public class MapFragment extends NvEventQueueFragment
public void onViewCreated(View view, @Nullable Bundle savedInstanceState)
{
super.onViewCreated(view, savedInstanceState);
final SurfaceView surfaceView = (SurfaceView) view.findViewById(R.id.map_surfaceview);
surfaceView.getHolder().addCallback(this);
nativeConnectDownloadButton();
}
@Override
protected void applyWidgetPivots()
public boolean onTouch(View view, MotionEvent event)
{
Framework.setWidgetPivot(Framework.MAP_WIDGET_RULER,
mSurfaceWidth - UiUtils.dimen(R.dimen.margin_ruler_right),
mSurfaceHeight - UiUtils.dimen(R.dimen.margin_ruler_bottom));
Framework.setWidgetPivot(Framework.MAP_WIDGET_COPYRIGHT,
mSurfaceWidth - UiUtils.dimen(R.dimen.margin_ruler_right),
mSurfaceHeight - UiUtils.dimen(R.dimen.margin_ruler_bottom));
final int count = event.getPointerCount();
adjustCompass(0);
}
if (count == 0)
return false;
public void adjustCompass(int offset)
{
Framework.setWidgetPivot(Framework.MAP_WIDGET_COMPASS,
UiUtils.dimen(R.dimen.margin_compass_left) + offset,
mSurfaceHeight - UiUtils.dimen(R.dimen.margin_compass_bottom));
}
@Override
public void OnRenderingInitialized()
{
final Activity host = getActivity();
if (isAdded() && host instanceof MapRenderingListener)
int action = event.getActionMasked();
int pointerIndex = event.getActionIndex();
switch (action)
{
final MapRenderingListener listener = (MapRenderingListener) host;
listener.onRenderingInitialized();
case MotionEvent.ACTION_POINTER_UP:
action = NATIVE_ACTION_UP;
break;
case MotionEvent.ACTION_UP:
action = NATIVE_ACTION_UP;
pointerIndex = 0;
break;
case MotionEvent.ACTION_POINTER_DOWN:
action = NATIVE_ACTION_DOWN;
break;
case MotionEvent.ACTION_DOWN:
action = NATIVE_ACTION_DOWN;
pointerIndex = 0;
break;
case MotionEvent.ACTION_MOVE:
action = NATIVE_ACTION_MOVE;
pointerIndex = INVALID_POINTER_MASK;
break;
case MotionEvent.ACTION_CANCEL:
action = NATIVE_ACTION_CANCEL;
break;
}
super.OnRenderingInitialized();
}
@Override
public void ReportUnsupported()
{
getActivity().runOnUiThread(new Runnable()
switch (count)
{
@Override
public void run()
{
new AlertDialog.Builder(getActivity())
.setMessage(getString(R.string.unsupported_phone))
.setCancelable(false)
.setPositiveButton(getString(R.string.close), new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dlg, int which)
{
getActivity().moveTaskToBack(true);
dlg.dismiss();
}
})
.create()
.show();
}
});
case 1:
nativeOnTouch(action, event.getPointerId(0), event.getX(), event.getY(), INVALID_TOUCH_ID, 0, 0, 0);
return true;
default:
nativeOnTouch(action,
event.getPointerId(0), event.getX(0), event.getY(0),
event.getPointerId(1), event.getX(1), event.getY(1), pointerIndex);
return true;
}
}
@SuppressWarnings("UnusedDeclaration")
public void OnDownloadCountryClicked(final int group, final int country, final int region, final int options)
public void onDownloadCountryClicked(final int group, final int country, final int region, final int options)
{
getActivity().runOnUiThread(new Runnable()
UiThread.run(new Runnable()
{
@Override
public void run()
{
final MapStorage.Index index = new MapStorage.Index(group, country, region);
if (options == -1)
nativeDownloadCountry(index, options);
else
{
long size = MapStorage.INSTANCE.countryRemoteSizeInBytes(index, options);
DownloadHelper.downloadWithCellularCheck(getActivity(), size, MapStorage.INSTANCE.countryName(index), new DownloadHelper.OnDownloadListener()
{
@Override
public void onDownload()
{
nativeDownloadCountry(index, options);
}
});
nativeDownloadCountry(index, options);
return;
}
final long size = MapStorage.INSTANCE.countryRemoteSizeInBytes(index, options);
DownloadHelper.downloadWithCellularCheck(getActivity(), size, MapStorage.INSTANCE.countryName(index), new DownloadHelper.OnDownloadListener()
{
@Override
public void onDownload()
{
nativeDownloadCountry(index, options);
}
});
}
});
}
private native void nativeConnectDownloadButton();
private static native void nativeDownloadCountry(MapStorage.Index index, int options);
static native void nativeOnLocationError(int errorCode);
static native void nativeLocationUpdated(long time, double lat, double lon, float accuracy, double altitude, float speed, float bearing);
static native void nativeCompassUpdated(double magneticNorth, double trueNorth, boolean forceRedraw);
static native void nativeScalePlus();
static native void nativeScaleMinus();
static native boolean nativeShowMapForUrl(String url);
static native boolean nativeIsEngineCreated();
private static native boolean nativeCreateEngine(Surface surface, int density);
private static native void nativeDestroyEngine();
private static native void nativeAttachSurface(Surface surface);
private static native void nativeDetachSurface();
private static native void nativeSurfaceChanged(int w, int h);
private static native void nativeOnTouch(int actionType, int id1, float x1, float y1, int id2, float x2, float y2, int maskedPointer);
private static native void nativeSetupWidget(int widget, float x, float y, int anchor);
private static native void nativeApplyWidgets();
private static native void nativeCleanWidgets();
}

183
android/src/com/mapswithme/maps/MwmActivity.java
View file

@ -60,6 +60,7 @@ import com.mapswithme.maps.widget.menu.MainMenu;
import com.mapswithme.maps.widget.placepage.BasePlacePageAnimationController;
import com.mapswithme.maps.widget.placepage.PlacePageView;
import com.mapswithme.maps.widget.placepage.PlacePageView.State;
import com.mapswithme.util.Animations;
import com.mapswithme.util.BottomSheetHelper;
import com.mapswithme.util.Config;
import com.mapswithme.util.InputUtils;
@ -75,7 +76,6 @@ import com.mapswithme.util.statistics.Statistics;
import ru.mail.android.mytarget.nativeads.NativeAppwallAd;
import ru.mail.android.mytarget.nativeads.banners.NativeAppwallBanner;
public class MwmActivity extends BaseMwmFragmentActivity
implements LocationHelper.LocationListener,
OnBalloonListener,
@ -88,7 +88,7 @@ public class MwmActivity extends BaseMwmFragmentActivity
RoutingController.Container
{
public static final String EXTRA_TASK = "map_task";
private final static String EXTRA_CONSUMED = "mwm.extra.intent.processed";
private static final String EXTRA_CONSUMED = "mwm.extra.intent.processed";
private static final String EXTRA_UPDATE_COUNTRIES = ".extra.update.countries";
private static final String[] DOCKED_FRAGMENTS = { SearchFragment.class.getName(),
@ -116,14 +116,13 @@ public class MwmActivity extends BaseMwmFragmentActivity
private PanelAnimator mPanelAnimator;
private MytargetHelper mMytargetHelper;
private int mLocationStateModeListenerId = LocationState.SLOT_UNDEFINED;
private FadeView mFadeView;
private ImageButton mBtnZoomIn;
private ImageButton mBtnZoomOut;
private boolean mIsFragmentContainer;
private boolean mIsFullscreen;
private LocationPredictor mLocationPredictor;
private FloatingSearchToolbarController mSearchController;
@ -168,15 +167,8 @@ public class MwmActivity extends BaseMwmFragmentActivity
@Override
public void onRenderingInitialized()
{
runOnUiThread(new Runnable()
{
@Override
public void run()
{
checkMeasurementSystem();
checkKitkatMigrationMove();
}
});
checkMeasurementSystem();
checkKitkatMigrationMove();
runTasks();
}
@ -304,9 +296,6 @@ public class MwmActivity extends BaseMwmFragmentActivity
Statistics.INSTANCE.trackConnectionState();
if (MwmApplication.get().nativeIsBenchmarking())
Utils.keepScreenOn(true, getWindow());
Framework.nativeSetBalloonListener(this);
mSearchController = new FloatingSearchToolbarController(this);
@ -340,11 +329,9 @@ public class MwmActivity extends BaseMwmFragmentActivity
mFrame = findViewById(R.id.map_fragment_container);
mFadeView = (FadeView) findViewById(R.id.fade_view);
mFadeView.setListener(new FadeView.Listener()
{
mFadeView.setListener(new FadeView.Listener() {
@Override
public void onTouch()
{
public void onTouch() {
mMainMenu.close(true);
}
});
@ -419,11 +406,9 @@ public class MwmActivity extends BaseMwmFragmentActivity
private void startLocationToPoint(String statisticsEvent, String alohaEvent, final @Nullable MapObject endPoint)
{
closeMenu(statisticsEvent, alohaEvent, new Runnable()
{
closeMenu(statisticsEvent, alohaEvent, new Runnable() {
@Override
public void run()
{
public void run() {
RoutingController.get().prepare(endPoint);
if (mPlacePage.isDocked() || !mPlacePage.isFloating())
@ -629,7 +614,7 @@ public class MwmActivity extends BaseMwmFragmentActivity
mTasks.add(mapTask);
intent.removeExtra(EXTRA_TASK);
if (mMapFragment.isRenderingInitialized())
if (MapFragment.nativeIsEngineCreated())
runTasks();
// mark intent as consumed
@ -640,7 +625,7 @@ public class MwmActivity extends BaseMwmFragmentActivity
@Override
public void onLocationError(int errorCode)
{
mMapFragment.nativeOnLocationError(errorCode);
MapFragment.nativeOnLocationError(errorCode);
if (errorCode == LocationHelper.ERROR_DENIED)
{
@ -717,22 +702,10 @@ public class MwmActivity extends BaseMwmFragmentActivity
// Callback from native location state mode element processing.
@SuppressWarnings("unused")
public void onLocationStateModeChangedCallback(final int newMode)
{
runOnUiThread(new Runnable()
{
@Override
public void run()
{
refreshLocationState(newMode);
}
});
}
private void refreshLocationState(int newMode)
public void onMyPositionModeChangedCallback(final int newMode)
{
mLocationPredictor.myPositionModeChanged(newMode);
mMainMenu.getMyPositionButton().update(newMode);
switch (newMode)
{
case LocationState.UNKNOWN_POSITION:
@ -749,7 +722,7 @@ public class MwmActivity extends BaseMwmFragmentActivity
{
super.onResume();
mLocationStateModeListenerId = LocationState.INSTANCE.addLocationStateModeListener(this);
LocationState.INSTANCE.setMyPositionModeListener(this);
invalidateLocationState();
mSearchController.refreshToolbar();
@ -832,7 +805,7 @@ public class MwmActivity extends BaseMwmFragmentActivity
@Override
protected void onPause()
{
LocationState.INSTANCE.removeLocationStateModeListener(mLocationStateModeListenerId);
LocationState.INSTANCE.removeMyPositionModeListener();
pauseLocation();
TtsPlayer.INSTANCE.stop();
LikesManager.INSTANCE.cancelDialogs();
@ -855,6 +828,23 @@ public class MwmActivity extends BaseMwmFragmentActivity
mLocationPredictor.pause();
}
private void refreshLocationState(int newMode)
{
mMainMenu.getMyPositionButton().update(newMode);
switch (newMode)
{
case LocationState.UNKNOWN_POSITION:
pauseLocation();
break;
case LocationState.PENDING_POSITION:
resumeLocation();
break;
default:
break;
}
}
/**
* Invalidates location state in core.
* Updates location button accordingly.
@ -954,7 +944,7 @@ public class MwmActivity extends BaseMwmFragmentActivity
return true;
}
// Callbacks from native map objects touch event.
// Callbacks from native touch events on map objects.
@Override
public void onApiPointActivated(final double lat, final double lon, final String name, final String id)
{
@ -981,28 +971,13 @@ public class MwmActivity extends BaseMwmFragmentActivity
{
final MapObject poi = new MapObject.Poi(name, lat, lon, type);
poi.addMetadata(metaTypes, metaValues);
runOnUiThread(new Runnable()
{
@Override
public void run()
{
activateMapObject(poi);
}
});
activateMapObject(poi);
}
@Override
public void onBookmarkActivated(final int category, final int bookmarkIndex)
{
runOnUiThread(new Runnable()
{
@Override
public void run()
{
activateMapObject(BookmarkManager.INSTANCE.getBookmark(category, bookmarkIndex));
}
});
activateMapObject(BookmarkManager.INSTANCE.getBookmark(category, bookmarkIndex));
}
@Override
@ -1026,20 +1001,14 @@ public class MwmActivity extends BaseMwmFragmentActivity
@Override
public void onAdditionalLayerActivated(final String name, final String type, final double lat, final double lon, final int[] metaTypes, final String[] metaValues)
{
runOnUiThread(new Runnable()
{
@Override
public void run()
{
final MapObject sr = new MapObject.SearchResult(name, type, lat, lon);
sr.addMetadata(metaTypes, metaValues);
activateMapObject(sr);
}
});
final MapObject sr = new MapObject.SearchResult(name, type, lat, lon);
sr.addMetadata(metaTypes, metaValues);
activateMapObject(sr);
}
private void activateMapObject(MapObject object)
{
setFullscreen(false);
if (!mPlacePage.hasMapObject(object))
{
mPlacePage.setMapObject(object);
@ -1054,16 +1023,48 @@ public class MwmActivity extends BaseMwmFragmentActivity
public void onDismiss()
{
if (!mPlacePage.hasMapObject(null))
mPlacePage.hide();
else
{
runOnUiThread(new Runnable()
if ((mPanelAnimator != null && mPanelAnimator.isVisible()) ||
UiUtils.isVisible(mSearchController.getToolbar()))
return;
setFullscreen(!mIsFullscreen);
}
}
private void setFullscreen(boolean isFullscreen)
{
mIsFullscreen = isFullscreen;
if (isFullscreen)
{
Animations.disappearSliding(mMainMenu.getFrame(), Animations.BOTTOM, new Runnable()
{
@Override
public void run()
{
mPlacePage.hide();
Framework.deactivatePopup();
final int menuHeight = mMainMenu.getFrame().getHeight();
adjustCompass(0, menuHeight);
adjustRuler(0, menuHeight);
}
});
Animations.disappearSliding(mBtnZoomOut, Animations.RIGHT, null);
Animations.disappearSliding(mBtnZoomIn, Animations.RIGHT, null);
}
else
{
Animations.appearSliding(mMainMenu.getFrame(), Animations.BOTTOM, new Runnable()
{
@Override
public void run()
{
adjustCompass(0, 0);
adjustRuler(0, 0);
}
});
Animations.appearSliding(mBtnZoomOut, Animations.RIGHT, null);
Animations.appearSliding(mBtnZoomIn, Animations.RIGHT, null);
}
}
@ -1098,12 +1099,12 @@ public class MwmActivity extends BaseMwmFragmentActivity
case R.id.map_button_plus:
Statistics.INSTANCE.trackEvent(Statistics.EventName.ZOOM_IN);
AlohaHelper.logClick(AlohaHelper.ZOOM_IN);
mMapFragment.nativeScale(3.0 / 2);
MapFragment.nativeScalePlus();
break;
case R.id.map_button_minus:
Statistics.INSTANCE.trackEvent(Statistics.EventName.ZOOM_OUT);
AlohaHelper.logClick(AlohaHelper.ZOOM_OUT);
mMapFragment.nativeScale(2 / 3.0);
MapFragment.nativeScaleMinus();
break;
}
}
@ -1144,7 +1145,7 @@ public class MwmActivity extends BaseMwmFragmentActivity
@Override
public boolean run(MwmActivity target)
{
return target.mMapFragment.showMapForUrl(mUrl);
return MapFragment.nativeShowMapForUrl(mUrl);
}
}
@ -1164,27 +1165,29 @@ public class MwmActivity extends BaseMwmFragmentActivity
public boolean run(MwmActivity target)
{
if (mDoAutoDownload)
{
Framework.downloadCountry(mIndex);
// set zoom level so that download process is visible
Framework.nativeShowCountry(mIndex, true);
}
else
Framework.nativeShowCountry(mIndex, false);
Framework.nativeShowCountry(mIndex, mDoAutoDownload);
return true;
}
}
public void adjustCompass(int offset)
public void adjustCompass(int offsetX, int offsetY)
{
if (mMapFragment != null && mMapFragment.isAdded())
{
mMapFragment.adjustCompass(mPanelAnimator.isVisible() ? offset : 0);
if (mMapFragment == null || !mMapFragment.isAdded())
return;
if (mLastCompassData != null)
mMapFragment.nativeCompassUpdated(mLastCompassData.magneticNorth, mLastCompassData.trueNorth, true);
}
mMapFragment.setupCompass((mPanelAnimator != null && mPanelAnimator.isVisible()) ? offsetX : 0, offsetY, true);
if (mLastCompassData != null)
MapFragment.nativeCompassUpdated(mLastCompassData.magneticNorth, mLastCompassData.trueNorth, true);
}
public void adjustRuler(int offsetX, int offsetY)
{
if (mMapFragment == null || !mMapFragment.isAdded())
return;
mMapFragment.setupRuler(offsetX, offsetY, true);
}
@Override

42
android/src/com/mapswithme/maps/MwmApplication.java
View file

@ -4,6 +4,8 @@ import android.app.Application;
import android.content.SharedPreferences;
import android.content.pm.PackageManager.NameNotFoundException;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.preference.PreferenceManager;
import android.util.Log;
@ -42,6 +44,9 @@ public class MwmApplication extends Application
private boolean mAreCountersInitialized;
private boolean mIsFrameworkInitialized;
private Handler mMainLoopHandler;
private Object mMainQueueToken = new Object();
public MwmApplication()
{
super();
@ -93,6 +98,7 @@ public class MwmApplication extends Application
public void onCreate()
{
super.onCreate();
mMainLoopHandler = new Handler(getMainLooper());
initPaths();
nativeInitPlatform(getApkPath(), getDataStoragePath(), getTempPath(), getObbGooglePath(),
@ -169,7 +175,7 @@ public class MwmApplication extends Application
return cacheDir.getAbsolutePath();
return Environment.getExternalStorageDirectory().getAbsolutePath() +
String.format(Constants.STORAGE_PATH, BuildConfig.APPLICATION_ID, Constants.CACHE_DIR);
String.format(Constants.STORAGE_PATH, BuildConfig.APPLICATION_ID, Constants.CACHE_DIR);
}
private String getObbGooglePath()
@ -191,10 +197,15 @@ public class MwmApplication extends Application
private native void nativeInitFramework();
public native boolean nativeIsBenchmarking();
private native void nativeAddLocalization(String name, String value);
/**
* Check if device have at least {@code size} bytes free.
*/
public native boolean hasFreeSpace(long size);
private native void runNativeFunctor(final long functorPointer);
/*
* init Parse SDK
*/
@ -217,8 +228,8 @@ public class MwmApplication extends Application
org.alohalytics.Statistics.logEvent(AlohaHelper.PARSE_INSTALLATION_ID, newId);
org.alohalytics.Statistics.logEvent(AlohaHelper.PARSE_DEVICE_TOKEN, newToken);
prefs.edit()
.putString(PREF_PARSE_INSTALLATION_ID, newId)
.putString(PREF_PARSE_DEVICE_TOKEN, newToken).apply();
.putString(PREF_PARSE_INSTALLATION_ID, newId)
.putString(PREF_PARSE_DEVICE_TOKEN, newToken).apply();
}
}
});
@ -238,4 +249,23 @@ public class MwmApplication extends Application
{
Config.resetAppSessionCounters();
}
}
public void runNativeFunctorOnUiThread(final long functorPointer)
{
Message m = Message.obtain(mMainLoopHandler, new Runnable()
{
@Override
public void run()
{
runNativeFunctor(functorPointer);
}
});
m.obj = mMainQueueToken;
mMainLoopHandler.sendMessage(m);
}
public void clearFunctorsOnUiThread()
{
mMainLoopHandler.removeCallbacksAndMessages(mMainQueueToken);
}
}

4
android/src/com/mapswithme/maps/PanelAnimator.java
View file

@ -82,7 +82,7 @@ class PanelAnimator
public void onAnimationEnd(Animator animation)
{
mAnimationTrackListener.onTrackFinished(true);
mActivity.adjustCompass(WIDTH);
mActivity.adjustCompass(WIDTH, 0);
}
});
@ -118,7 +118,7 @@ class PanelAnimator
{
UiUtils.hide(mPanel);
mAnimationTrackListener.onTrackFinished(false);
mActivity.adjustCompass(0);
mActivity.adjustCompass(0, 0);
if (completionListener != null)
completionListener.run();

35
android/src/com/mapswithme/maps/location/LocationPredictor.java
View file

@ -18,7 +18,6 @@ public class LocationPredictor
private Location mLastLocation;
private boolean mGeneratePredictions;
private int mPredictionCount;
private int mConnectionSlot = LocationState.SLOT_UNDEFINED;
public LocationPredictor(Handler handler, LocationHelper.LocationListener listener)
{
@ -38,18 +37,25 @@ public class LocationPredictor
public void resume()
{
mConnectionSlot = LocationState.INSTANCE.addLocationStateModeListener(this);
onLocationStateModeChangedCallback(LocationState.INSTANCE.getLocationStateMode());
myPositionModeChanged(LocationState.INSTANCE.getLocationStateMode());
}
public void pause()
{
LocationState.INSTANCE.removeLocationStateModeListener(mConnectionSlot);
mGeneratePredictions = false;
mLastLocation = null;
resetHandler();
}
public void myPositionModeChanged(final int mode)
{
if (mode < LocationState.NOT_FOLLOW)
mLastLocation = null;
mGeneratePredictions = (mode == LocationState.ROTATE_AND_FOLLOW);
resetHandler();
}
public void reset(Location location)
{
if (location.hasBearing() && location.hasSpeed())
@ -64,27 +70,6 @@ public class LocationPredictor
resetHandler();
}
private void onLocationStateModeChangedCallback(final int mode)
{
mHandler.post(new Runnable()
{
@Override
public void run()
{
onLocationStateModeChangedCallbackImpl(mode);
}
});
}
private void onLocationStateModeChangedCallbackImpl(int mode)
{
if (mode < LocationState.NOT_FOLLOW)
mLastLocation = null;
mGeneratePredictions = (mode == LocationState.ROTATE_AND_FOLLOW);
resetHandler();
}
private boolean isPredict()
{
return mLastLocation != null && mGeneratePredictions;

5
android/src/com/mapswithme/maps/routing/NavigationController.java
View file

@ -10,6 +10,7 @@ import com.mapswithme.maps.R;
import com.mapswithme.maps.bookmarks.data.DistanceAndAzimut;
import com.mapswithme.maps.location.LocationHelper;
import com.mapswithme.maps.widget.FlatProgressView;
import com.mapswithme.util.Animations;
import com.mapswithme.util.UiUtils;
import com.mapswithme.util.Utils;
import com.mapswithme.util.statistics.AlohaHelper;
@ -75,11 +76,11 @@ public class NavigationController
if (info.vehicleNextTurnDirection.containsNextTurn())
{
UiUtils.appearSlidingDown(mNextTurnFrame, null);
Animations.appearSliding(mNextTurnFrame, Animations.TOP, null);
info.vehicleNextTurnDirection.setNextTurnDrawable(mNextTurnImage);
}
else
UiUtils.disappearSlidingUp(mNextTurnFrame, null);
Animations.disappearSliding(mNextTurnFrame, Animations.BOTTOM, null);
}
private void updatePedestrian(RoutingInfo info)

2
android/src/com/mapswithme/maps/routing/SlotFrame.java
View file

@ -223,7 +223,7 @@ public class SlotFrame extends LinearLayout
setClipToPadding(false);
setClickable(true);
int padding = UiUtils.dp(8);
int padding = UiUtils.toPx(8);
setPadding(padding, padding / 4, padding, padding);
mSlotFrom = new Slot(this, R.id.from, 1);

7
android/src/com/mapswithme/maps/search/FloatingSearchToolbarController.java
View file

@ -5,6 +5,7 @@ import android.text.TextUtils;
import com.mapswithme.maps.MwmActivity;
import com.mapswithme.maps.api.ParsedMwmRequest;
import com.mapswithme.maps.widget.SearchToolbarController;
import com.mapswithme.util.Animations;
import com.mapswithme.util.UiUtils;
public class FloatingSearchToolbarController extends SearchToolbarController
@ -42,12 +43,12 @@ public class FloatingSearchToolbarController extends SearchToolbarController
if (ParsedMwmRequest.hasRequest())
{
UiUtils.appearSlidingDown(mToolbar, null);
Animations.appearSliding(mToolbar, Animations.TOP, null);
setQuery(ParsedMwmRequest.getCurrentRequest().getTitle());
}
else if (!TextUtils.isEmpty(SearchEngine.getQuery()))
{
UiUtils.appearSlidingDown(mToolbar, null);
Animations.appearSliding(mToolbar, Animations.TOP, null);
setQuery(SearchEngine.getQuery());
}
else
@ -73,7 +74,7 @@ public class FloatingSearchToolbarController extends SearchToolbarController
if (!UiUtils.isVisible(mToolbar))
return false;
UiUtils.disappearSlidingUp(mToolbar, null);
Animations.disappearSliding(mToolbar, Animations.TOP, null);
return true;
}
}

2
android/src/com/mapswithme/maps/widget/WebViewShadowController.java
View file

@ -18,7 +18,7 @@ public class WebViewShadowController extends BaseShadowController<ObservableWebV
return (mList.getScrollY() > 0);
case BOTTOM:
return (mList.getScrollY() + mList.getHeight() < UiUtils.dp(mList.getContentHeight() - 1));
return (mList.getScrollY() + mList.getHeight() < UiUtils.toPx(mList.getContentHeight() - 1));
default:
throw new IllegalArgumentException("Invalid shadow id: " + id);

4
android/src/com/mapswithme/maps/widget/placepage/PlacePageBottomAnimationController.java
View file

@ -103,8 +103,8 @@ class PlacePageBottomAnimationController extends BasePlacePageAnimationControlle
{
mGestureDetector = new GestureDetectorCompat(mPlacePage.getContext(), new GestureDetector.SimpleOnGestureListener()
{
private final int Y_MIN = UiUtils.dp(10);
private final int Y_MAX = UiUtils.dp(50);
private final int Y_MIN = UiUtils.toPx(10);
private final int Y_MAX = UiUtils.toPx(50);
private static final int X_TO_Y_SCROLL_RATIO = 2;
@Override

4
android/src/com/mapswithme/maps/widget/placepage/PlacePageLeftAnimationController.java
View file

@ -61,8 +61,8 @@ class PlacePageLeftAnimationController extends BasePlacePageAnimationController
{
mGestureDetector = new GestureDetectorCompat(mPlacePage.getContext(), new GestureDetector.SimpleOnGestureListener()
{
private final int X_MIN = UiUtils.dp(30);
private final int X_MAX = UiUtils.dp(100);
private final int X_MIN = UiUtils.toPx(30);
private final int X_MAX = UiUtils.toPx(100);
private static final int X_TO_Y_SCROLL_RATIO = 2;
@Override

1
android/src/com/mapswithme/maps/widget/placepage/PlacePageView.java
View file

@ -818,7 +818,6 @@ public class PlacePageView extends RelativeLayout implements View.OnClickListene
}
});
}
Framework.invalidate();
}
private void selectBookmarkSet()

112
android/src/com/mapswithme/util/Animations.java Normal file
View file

@ -0,0 +1,112 @@
package com.mapswithme.util;
import android.animation.Animator;
import android.support.annotation.IntDef;
import android.support.annotation.Nullable;
import android.view.View;
import android.view.ViewPropertyAnimator;
import com.mapswithme.maps.MwmApplication;
import com.mapswithme.maps.R;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
public final class Animations
{
private Animations() {}
@IntDef({LEFT, RIGHT, TOP, BOTTOM})
@Retention(RetentionPolicy.SOURCE)
public @interface AnimationDirection {}
public static final int LEFT = 0;
public static final int RIGHT = 1;
public static final int TOP = 2;
public static final int BOTTOM = 3;
private static final int DURATION_DEFAULT = MwmApplication.get().getResources().getInteger(R.integer.anim_default);
public static void appearSliding(final View view, @AnimationDirection int appearFrom, @Nullable final Runnable completionListener)
{
if (UiUtils.isVisible(view))
{
if (completionListener != null)
completionListener.run();
return;
}
final ViewPropertyAnimator animator = view.animate().setDuration(DURATION_DEFAULT).alpha(1).setListener(new UiUtils.SimpleAnimatorListener()
{
@Override
public void onAnimationEnd(Animator animation)
{
if (completionListener != null)
completionListener.run();
}
});
switch (appearFrom)
{
case LEFT:
case RIGHT:
animator.translationX(0);
break;
case TOP:
case BOTTOM:
animator.translationY(0);
break;
}
UiUtils.show(view);
}
public static void disappearSliding(final View view, @AnimationDirection int disappearTo, @Nullable final Runnable completionListener)
{
if (!UiUtils.isVisible(view))
{
if (completionListener != null)
completionListener.run();
return;
}
final ViewPropertyAnimator animator = view.animate().setDuration(DURATION_DEFAULT).alpha(0).setListener(new UiUtils.SimpleAnimatorListener()
{
@Override
public void onAnimationEnd(Animator animation)
{
UiUtils.hide(view);
if (completionListener != null)
completionListener.run();
}
});
switch (disappearTo)
{
case RIGHT:
animator.translationX(view.getWidth());
break;
case LEFT:
animator.translationX(-view.getWidth());
break;
case BOTTOM:
animator.translationY(view.getHeight());
break;
case TOP:
animator.translationY(-view.getHeight());
break;
}
}
public static void exchangeViews(final View viewToHide, final @AnimationDirection int disappearTo,
final View viewToShow, final @AnimationDirection int appearFrom, @Nullable final Runnable completionListener)
{
disappearSliding(viewToHide, disappearTo, new Runnable()
{
@Override
public void run()
{
appearSliding(viewToShow, appearFrom, completionListener);
}
});
}
}

195
android/src/com/mapswithme/util/UiUtils.java
View file

@ -10,7 +10,6 @@ import android.provider.Settings;
import android.support.annotation.DimenRes;
import android.support.annotation.IdRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v7.app.AlertDialog;
import android.support.v7.widget.Toolbar;
import android.text.TextUtils;
@ -19,7 +18,6 @@ import android.view.View;
import android.view.ViewTreeObserver;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.AnimationUtils;
import android.widget.TextView;
import com.mapswithme.maps.MwmApplication;
@ -29,7 +27,6 @@ public final class UiUtils
{
private static float sScreenDensity;
public static class SimpleAnimationListener implements AnimationListener
{
@Override
@ -65,19 +62,11 @@ public final class UiUtils
void onViewMeasured(int width, int height);
}
public static void waitLayout(final View view, @NonNull final ViewTreeObserver.OnGlobalLayoutListener callback)
{
ViewTreeObserver observer = view.getViewTreeObserver();
if (!observer.isAlive())
throw new IllegalArgumentException("ViewTreeObserver is not alive");
observer.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener()
{
public static void waitLayout(final View view, @NonNull final ViewTreeObserver.OnGlobalLayoutListener callback) {
view.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@SuppressWarnings("deprecation")
@Override
public void onGlobalLayout()
{
public void onGlobalLayout() {
// viewTreeObserver can be dead(isAlive() == false), we should get a new one here.
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN)
view.getViewTreeObserver().removeGlobalOnLayoutListener(this);
@ -171,6 +160,21 @@ public final class UiUtils
invisible(frame, id);
}
public static boolean isHidden(View view)
{
return view.getVisibility() == View.GONE;
}
public static boolean isInvisible(View view)
{
return view.getVisibility() == View.INVISIBLE;
}
public static boolean isVisible(View view)
{
return view.getVisibility() == View.VISIBLE;
}
public static void visibleIf(boolean condition, View view)
{
view.setVisibility(condition ? View.VISIBLE : View.INVISIBLE);
@ -197,11 +201,6 @@ public final class UiUtils
hide(views);
}
public static boolean isVisible(View view)
{
return (view.getVisibility() == View.VISIBLE);
}
public static void setTextAndShow(TextView tv, CharSequence text)
{
tv.setText(text);
@ -224,34 +223,34 @@ public final class UiUtils
public void run()
{
new AlertDialog.Builder(activity)
.setCancelable(false)
.setMessage(message)
.setPositiveButton(activity.getString(R.string.connection_settings), new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dlg, int which)
{
try
.setCancelable(false)
.setMessage(message)
.setPositiveButton(activity.getString(R.string.connection_settings), new DialogInterface.OnClickListener()
{
activity.startActivity(new Intent(Settings.ACTION_WIRELESS_SETTINGS));
} catch (final Exception ex)
{
ex.printStackTrace();
}
@Override
public void onClick(DialogInterface dlg, int which)
{
try
{
activity.startActivity(new Intent(Settings.ACTION_WIRELESS_SETTINGS));
} catch (final Exception ex)
{
ex.printStackTrace();
}
dlg.dismiss();
}
})
.setNegativeButton(activity.getString(R.string.close), new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dlg, int which)
{
dlg.dismiss();
}
})
.create()
.show();
dlg.dismiss();
}
})
.setNegativeButton(activity.getString(R.string.close), new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dlg, int which)
{
dlg.dismiss();
}
})
.create()
.show();
}
});
}
@ -265,14 +264,13 @@ public final class UiUtils
public static AlertDialog buildAlertDialog(Activity activity, int titleId)
{
return new AlertDialog.Builder(activity)
.setCancelable(false)
.setMessage(titleId)
.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener()
{
@Override
public void onClick(DialogInterface dlg, int which) { dlg.dismiss(); }
})
.create();
.setCancelable(false)
.setMessage(titleId)
.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dlg, int which) { dlg.dismiss(); }
})
.create();
}
public static void showAlertDialog(Activity activity, int titleId)
@ -286,18 +284,18 @@ public final class UiUtils
String rotation = activity.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT ? "|" : "-";
switch (activity.getWindowManager().getDefaultDisplay().getRotation())
{
case Surface.ROTATION_0:
rotation += "0";
break;
case Surface.ROTATION_90:
rotation += "90";
break;
case Surface.ROTATION_180:
rotation += "180";
break;
case Surface.ROTATION_270:
rotation += "270";
break;
case Surface.ROTATION_0:
rotation += "0";
break;
case Surface.ROTATION_90:
rotation += "90";
break;
case Surface.ROTATION_180:
rotation += "180";
break;
case Surface.ROTATION_270:
rotation += "270";
break;
}
return rotation;
}
@ -317,80 +315,17 @@ public final class UiUtils
return isSmallTablet() || isBigTablet();
}
public static void appearSlidingDown(final View view, @Nullable final Runnable completionListener)
{
if (isVisible(view) || view.getAnimation() != null)
{
if (completionListener != null)
completionListener.run();
return;
}
show(view);
Animation a = AnimationUtils.loadAnimation(view.getContext(), R.anim.slide_appear_down);
if (completionListener != null)
a.setAnimationListener(new UiUtils.SimpleAnimationListener()
{
@Override
public void onAnimationEnd(Animation animation)
{
completionListener.run();
}
});
view.startAnimation(a);
}
public static void disappearSlidingUp(final View view, @Nullable final Runnable completionListener)
{
if (!isVisible(view) || view.getAnimation() != null)
{
if (completionListener != null)
completionListener.run();
return;
}
Animation a = AnimationUtils.loadAnimation(view.getContext(), R.anim.slide_disappear_up);
a.setAnimationListener(new UiUtils.SimpleAnimationListener()
{
@Override
public void onAnimationEnd(Animation animation)
{
hide(view);
view.clearAnimation();
if (completionListener != null)
completionListener.run();
}
});
view.startAnimation(a);
}
public static void exchangeViewsAnimatedDown(final View toHide, final View toShow, @Nullable final Runnable completionListener)
{
disappearSlidingUp(toHide, new Runnable()
{
@Override
public void run()
{
appearSlidingDown(toShow, completionListener);
}
});
}
public static int dimen(@DimenRes int id)
{
return MwmApplication.get().getResources().getDimensionPixelSize(id);
}
public static int dp(int v)
public static int toPx(int dp)
{
if (sScreenDensity == 0)
sScreenDensity = MwmApplication.get().getResources().getDisplayMetrics().density;
return (int) (v * sScreenDensity + 0.5);
return (int) (dp * sScreenDensity + 0.5);
}
// utility class

110
android/src/com/nvidia/devtech/BaseEglWrapper.java
View file

@ -1,110 +0,0 @@
package com.nvidia.devtech;
import android.opengl.EGL14;
import javax.microedition.khronos.egl.EGL10;
abstract public class BaseEglWrapper extends EglWrapper
{
private static final int EGL_RENDERABLE_TYPE = 0x3040;
private static final int EGL_OPENGL_ES2_BIT = 0x0004;
private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
// The number of bits requested for the red component
private static int redSize = 5;
// The number of bits requested for the green component
private static int greenSize = 6;
// The number of bits requested for the blue component
private static int blueSize = 5;
// The number of bits requested for the alpha component
private static int alphaSize = 0;
// The number of bits requested for the stencil component
private static int stencilSize = 0;
// The number of bits requested for the depth component
private static int depthSize = 16;
protected int[] GetConfigAttributes10()
{
final int[] configAttributes = new int[]{EGL10.EGL_RED_SIZE, redSize,
EGL10.EGL_GREEN_SIZE, greenSize,
EGL10.EGL_BLUE_SIZE, blueSize,
EGL10.EGL_ALPHA_SIZE, alphaSize,
EGL10.EGL_STENCIL_SIZE, stencilSize,
EGL10.EGL_DEPTH_SIZE, depthSize,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL10.EGL_NONE};
return configAttributes;
}
protected int[] GetSurfaceAttributes10()
{
return new int[]{EGL10.EGL_NONE};
}
protected int[] GetContextAttributes10()
{
return new int[]{EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE};
}
protected int[] GetConfigAttributes14()
{
final int[] configAttributes = new int[]{EGL14.EGL_RED_SIZE, redSize,
EGL14.EGL_GREEN_SIZE, greenSize,
EGL14.EGL_BLUE_SIZE, blueSize,
EGL14.EGL_ALPHA_SIZE, alphaSize,
EGL14.EGL_STENCIL_SIZE, stencilSize,
EGL14.EGL_DEPTH_SIZE, depthSize,
EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
EGL14.EGL_NONE};
return configAttributes;
}
protected int[] GetSurfaceAttributes14()
{
return new int[]{EGL14.EGL_NONE};
}
protected int[] GetContextAttributes14()
{
return new int[]{EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL14.EGL_NONE};
}
protected boolean ValidateSurfaceSize()
{
return GetSurfaceWidth() * GetSurfaceWidth() != 0;
}
public class ConfigComparatorBase
{
private int EglNone;
private int EglSlowConfig;
private int EglNonConformantConfig;
public ConfigComparatorBase(int eglNone, int eglSlow, int eglNonComformant)
{
EglNone = eglNone;
EglSlowConfig = eglSlow;
EglNonConformantConfig = eglNonComformant;
}
public int CompareConfigs(int rCav, int lCav)
{
if (lCav != rCav)
return GetCaveatValue(lCav) - GetCaveatValue(rCav);
return 0;
}
int GetCaveatValue(int cav)
{
if (cav == EglSlowConfig)
return 1;
else if (cav == EglNonConformantConfig)
return 2;
return 0;
}
}
}

383
android/src/com/nvidia/devtech/Egl10Wrapper.java
View file

@ -1,383 +0,0 @@
package com.nvidia.devtech;
import android.os.Build;
import android.view.SurfaceHolder;
import com.mapswithme.util.log.Logger;
import java.util.Arrays;
import java.util.Comparator;
import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
public class Egl10Wrapper extends BaseEglWrapper
{
private static final String TAG = "Egl10Wrapper";
final private EGL10 mEgl = (EGL10) EGLContext.getEGL();
private EGLDisplay mDisplay = EGL10.EGL_NO_DISPLAY;
private EGLContext mContext = EGL10.EGL_NO_CONTEXT;
private EGLSurface mSurface = EGL10.EGL_NO_SURFACE;
private EGLConfig mConfig = null;
private EGLConfig[] mConfigs = new EGLConfig[40];
private int mChoosenConfigIndex = 0;
private int mActualConfigsNumber[] = new int[]{0};
private Logger mLog = null;
public Egl10Wrapper(Logger logger)
{
mLog = logger;
}
private class EGLConfigComparator extends ConfigComparatorBase
implements Comparator<EGLConfig>
{
EGLConfigComparator()
{
super(EGL10.EGL_NONE, EGL10.EGL_SLOW_CONFIG, EGL10.EGL_NON_CONFORMANT_CONFIG);
}
@Override
public int compare(EGLConfig l, EGLConfig r)
{
final int[] value = new int[1];
/// splitting by EGL_CONFIG_CAVEAT,
/// firstly selecting EGL_NONE, then EGL_SLOW_CONFIG
/// and then EGL_NON_CONFORMANT_CONFIG
mEgl.eglGetConfigAttrib(mDisplay, l, EGL10.EGL_CONFIG_CAVEAT, value);
final int lcav = value[0];
mEgl.eglGetConfigAttrib(mDisplay, r, EGL10.EGL_CONFIG_CAVEAT, value);
final int rcav = value[0];
return CompareConfigs(rcav, lcav);
}
}
;
@Override
public boolean InitEGL()
{
mDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
if (mDisplay == EGL10.EGL_NO_DISPLAY)
{
LogIt("eglGetDisplay failed");
return false;
}
int[] version = new int[2];
if (!mEgl.eglInitialize(mDisplay, version))
{
LogIt("eglInitialize failed");
return false;
}
if (version[0] != 1 && version[1] >= 4 && Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1)
{
LogIt("Incorrect EGL wrapper choosed");
return false;
}
if (!mEgl.eglChooseConfig(mDisplay, GetConfigAttributes10(), mConfigs, mConfigs.length, mActualConfigsNumber))
{
LogEgl("eglChooseConfig failed with error ");
return false;
}
if (mActualConfigsNumber[0] == 0)
{
LogIt("eglChooseConfig returned zero configs");
return false;
}
Arrays.sort(mConfigs, 0, mActualConfigsNumber[0], new EGLConfigComparator());
mChoosenConfigIndex = 0;
while (true)
{
mConfig = mConfigs[mChoosenConfigIndex];
// Debug print
LogIt("Matched egl configs:");
for (int i = 0; i < mActualConfigsNumber[0]; ++i)
LogIt((i == mChoosenConfigIndex ? "*" : " ") + i + ": " + eglConfigToString(mConfigs[i]));
mContext = mEgl.eglCreateContext(mDisplay, mConfig, EGL10.EGL_NO_CONTEXT, GetContextAttributes10());
if (mContext == EGL10.EGL_NO_CONTEXT)
{
LogEgl("eglCreateContext failed with error ");
mChoosenConfigIndex++;
}
else
break;
if (mChoosenConfigIndex == mConfigs.length)
{
LogIt("No more configs left to choose");
return false;
}
}
return true;
}
@Override
public boolean IsInitialized()
{
return mContext != EGL10.EGL_NO_CONTEXT;
}
@Override
public boolean TerminateEGL()
{
LogIt("CleanupEGL");
if (!IsInitialized())
return false;
if (!DestroySurfaceEGL())
return false;
if (mDisplay != EGL10.EGL_NO_DISPLAY)
mEgl.eglMakeCurrent(mDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
if (mContext != EGL10.EGL_NO_CONTEXT)
mEgl.eglDestroyContext(mDisplay, mContext);
mEgl.eglTerminate(mDisplay);
mDisplay = EGL10.EGL_NO_DISPLAY;
mContext = EGL10.EGL_NO_CONTEXT;
mConfig = null;
return true;
}
@Override
public boolean CreateSurfaceEGL(SurfaceHolder holder)
{
if (holder == null)
{
LogIt("createEGLSurface failed, mCachedSurfaceHolder is null");
return false;
}
if (!IsInitialized())
InitEGL();
if (!IsInitialized())
{
LogIt("createEGLSurface failed, cannot initialize EGL");
return false;
}
if (mDisplay == EGL10.EGL_NO_DISPLAY)
{
LogIt("createEGLSurface: display is null");
return false;
}
else if (mConfig == null)
{
LogIt("createEGLSurface: config is null");
return false;
}
int choosenSurfaceConfigIndex = mChoosenConfigIndex;
while (true)
{
/// trying to create window surface with one of the EGL configs, recreating the m_eglConfig if necessary
mSurface = mEgl.eglCreateWindowSurface(mDisplay, mConfigs[choosenSurfaceConfigIndex], holder, GetSurfaceAttributes10());
final boolean surfaceCreated = (mSurface != EGL10.EGL_NO_SURFACE);
final boolean surfaceValidated = surfaceCreated ? ValidateSurfaceSize() : false;
if (surfaceCreated && !surfaceValidated)
mEgl.eglDestroySurface(mDisplay, mSurface);
if (!surfaceCreated || !surfaceValidated)
{
LogIt("eglCreateWindowSurface failed for config : " + eglConfigToString(mConfigs[choosenSurfaceConfigIndex]));
choosenSurfaceConfigIndex += 1;
if (choosenSurfaceConfigIndex == mActualConfigsNumber[0])
{
mSurface = EGL10.EGL_NO_SURFACE;
LogIt("no eglConfigs left");
break;
}
else
LogIt("trying : " + eglConfigToString(mConfigs[choosenSurfaceConfigIndex]));
}
else
break;
}
if ((choosenSurfaceConfigIndex != mChoosenConfigIndex) && (mSurface != null))
{
LogIt("window surface is created for eglConfig : " + eglConfigToString(mConfigs[choosenSurfaceConfigIndex]));
// unbinding context
if (mDisplay != null)
mEgl.eglMakeCurrent(mDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
// destroying context
if (mContext != null)
mEgl.eglDestroyContext(mDisplay, mContext);
// recreating context with same eglConfig as eglWindowSurface has
mContext = mEgl.eglCreateContext(mDisplay, mConfigs[choosenSurfaceConfigIndex], EGL10.EGL_NO_CONTEXT, GetContextAttributes10());
if (mContext == EGL10.EGL_NO_CONTEXT)
{
LogEgl("context recreation failed with error ");
return false;
}
mChoosenConfigIndex = choosenSurfaceConfigIndex;
mConfig = mConfigs[mChoosenConfigIndex];
}
return true;
}
@Override
public boolean DestroySurfaceEGL()
{
if (mDisplay != EGL10.EGL_NO_DISPLAY && mSurface != EGL10.EGL_NO_SURFACE)
mEgl.eglMakeCurrent(mDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, mContext);
if (mSurface != EGL10.EGL_NO_SURFACE)
mEgl.eglDestroySurface(mDisplay, mSurface);
mSurface = EGL10.EGL_NO_SURFACE;
return true;
}
@Override
public boolean SwapBuffersEGL()
{
if (mSurface == EGL10.EGL_NO_SURFACE)
{
LogIt("Surface is NULL");
return false;
}
if (mDisplay == EGL10.EGL_NO_DISPLAY)
{
LogIt("Display is NULL");
return false;
}
if (!mEgl.eglSwapBuffers(mDisplay, mSurface))
{
LogEgl("eglSwapBuffer: ");
return false;
}
return true;
}
@Override
public int GetSurfaceWidth()
{
final int sizes[] = new int[1];
mEgl.eglQuerySurface(mDisplay, mSurface, EGL10.EGL_WIDTH, sizes);
return sizes[0];
}
@Override
public int GetSurfaceHeight()
{
final int sizes[] = new int[1];
mEgl.eglQuerySurface(mDisplay, mSurface, EGL10.EGL_HEIGHT, sizes);
return sizes[0];
}
@Override
public boolean Bind()
{
if (mContext == EGL10.EGL_NO_CONTEXT)
{
LogIt("m_eglContext is NULL");
return false;
}
else if (mSurface == EGL10.EGL_NO_SURFACE)
{
LogIt("m_eglSurface is NULL");
return false;
}
else if (!mEgl.eglMakeCurrent(mDisplay, mSurface, mSurface, mContext))
{
LogEgl("eglMakeCurrent err: ");
return false;
}
return true;
}
@Override
public boolean Unbind()
{
if (mDisplay == EGL10.EGL_NO_DISPLAY)
return false;
return mEgl.eglMakeCurrent(mDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
}
@Override
public int GetErrorEGL()
{
return mEgl.eglGetError();
}
private void LogIt(String message)
{
mLog.d(TAG, message);
}
private void LogEgl(String message)
{
mLog.d(TAG, message + mEgl.eglGetError());
}
String eglConfigToString(final EGLConfig config)
{
final int[] value = new int[1];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_RED_SIZE, value);
final int red = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_GREEN_SIZE, value);
final int green = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_BLUE_SIZE, value);
final int blue = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_ALPHA_SIZE, value);
final int alpha = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_STENCIL_SIZE, value);
final int stencil = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_DEPTH_SIZE, value);
final int depth = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_CONFIG_CAVEAT, value);
final String caveat = (value[0] == EGL10.EGL_NONE) ? "EGL_NONE" :
(value[0] == EGL10.EGL_SLOW_CONFIG) ? "EGL_SLOW_CONFIG" : "EGL_NON_CONFORMANT_CONFIG";
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_BUFFER_SIZE, value);
final int buffer = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_LEVEL, value);
final int level = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_SAMPLE_BUFFERS, value);
final int sampleBuffers = value[0];
mEgl.eglGetConfigAttrib(mDisplay, config, EGL10.EGL_SAMPLES, value);
final int samples = value[0];
return "R" + red + "G" + green + "B" + blue + "A" + alpha +
" Stencil:" + stencil + " Depth:" + depth + " Caveat:" + caveat +
" BufferSize:" + buffer + " Level:" + level + " SampleBuffers:" + sampleBuffers +
" Samples:" + samples;
}
}

Some files were not shown because too many files have changed in this diff Show more