summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/text/LocalGlyphRasterizer.java46
-rw-r--r--platform/android/config.cmake3
-rwxr-xr-xplatform/android/src/jni.cpp4
-rw-r--r--platform/android/src/text/local_glyph_rasterizer.cpp126
-rw-r--r--platform/android/src/text/local_glyph_rasterizer_jni.hpp31
5 files changed, 209 insertions, 1 deletions
diff --git a/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/text/LocalGlyphRasterizer.java b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/text/LocalGlyphRasterizer.java
new file mode 100644
index 0000000000..920a1270ac
--- /dev/null
+++ b/platform/android/MapboxGLAndroidSDK/src/main/java/com/mapbox/mapboxsdk/text/LocalGlyphRasterizer.java
@@ -0,0 +1,46 @@
+package com.mapbox.mapboxsdk.text;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Bitmap;
+import android.graphics.Typeface;
+import android.support.annotation.WorkerThread;
+
+/**
+ * LocalGlyphRasterizer is the Android-specific platform implementation used
+ * by the portable local_glyph_rasterizer.hpp
+ */
+public class LocalGlyphRasterizer {
+
+ /***
+ * Uses Android-native drawing code to rasterize a single glyph
+ * to a square @{link Bitmap} which can be returned to portable
+ * code for transformation into a Signed Distance Field glyph.
+ *
+ * @param fontFamily Font family string to pass to Typeface.create
+ * @param bold If true, use Typeface.BOLD option
+ * @param glyphID 16-bit Unicode BMP codepoint to draw
+ *
+ * @return Return a @{link Bitmap} to be displayed in the requested tile.
+ */
+ @WorkerThread
+ protected static Bitmap drawGlyphBitmap(String fontFamily, boolean bold, char glyphID) {
+ /*
+ 35x35px dimensions are hardwired to match local_glyph_rasterizer.cpp
+ These dimensions are large enough to draw a 24 point character in the middle
+ of the bitmap (y: 20) with some buffer around the edge
+ */
+ Bitmap bitmap = Bitmap.createBitmap(35, 35, Bitmap.Config.ARGB_8888);
+
+ Paint paint = new Paint();
+ paint.setAntiAlias(true);
+ paint.setTextSize(24);
+ paint.setTypeface(Typeface.create(fontFamily, bold ? Typeface.BOLD : Typeface.NORMAL));
+
+ Canvas canvas = new Canvas();
+ canvas.setBitmap(bitmap);
+ canvas.drawText(String.valueOf(glyphID), 0, 20, paint);
+
+ return bitmap;
+ }
+}
diff --git a/platform/android/config.cmake b/platform/android/config.cmake
index c7609f1644..34a8963042 100644
--- a/platform/android/config.cmake
+++ b/platform/android/config.cmake
@@ -32,11 +32,12 @@ macro(mbgl_platform_core)
PRIVATE platform/android/src/timer.cpp
# Misc
+ PRIVATE platform/android/src/text/local_glyph_rasterizer_jni.hpp
+ PRIVATE platform/android/src/text/local_glyph_rasterizer.cpp
PRIVATE platform/android/src/logging_android.cpp
PRIVATE platform/android/src/thread.cpp
PRIVATE platform/default/string_stdlib.cpp
PRIVATE platform/default/bidi.cpp
- PRIVATE platform/default/local_glyph_rasterizer.cpp
PRIVATE platform/default/thread_local.cpp
PRIVATE platform/default/utf.cpp
diff --git a/platform/android/src/jni.cpp b/platform/android/src/jni.cpp
index f4e5734861..e75a9c6985 100755
--- a/platform/android/src/jni.cpp
+++ b/platform/android/src/jni.cpp
@@ -51,6 +51,7 @@
#include "style/light.hpp"
#include "snapshotter/map_snapshotter.hpp"
#include "snapshotter/map_snapshot.hpp"
+#include "text/local_glyph_rasterizer_jni.hpp"
namespace mbgl {
namespace android {
@@ -188,6 +189,9 @@ void registerNatives(JavaVM *vm) {
// Snapshotter
MapSnapshotter::registerNative(env);
MapSnapshot::registerNative(env);
+
+ // text
+ LocalGlyphRasterizer::registerNative(env);
}
} // namespace android
diff --git a/platform/android/src/text/local_glyph_rasterizer.cpp b/platform/android/src/text/local_glyph_rasterizer.cpp
new file mode 100644
index 0000000000..ce1b0fc8fd
--- /dev/null
+++ b/platform/android/src/text/local_glyph_rasterizer.cpp
@@ -0,0 +1,126 @@
+#include <mbgl/text/local_glyph_rasterizer.hpp>
+#include <mbgl/util/i18n.hpp>
+#include <mbgl/util/platform.hpp>
+
+#include <jni/jni.hpp>
+
+#include "../attach_env.hpp"
+#include "../bitmap.hpp"
+
+#include "local_glyph_rasterizer_jni.hpp"
+
+/*
+ Android implementation of LocalGlyphRasterizer:
+ Draws CJK glyphs using locally available fonts.
+
+ Follows pattern of GL JS implementation in that:
+ - Only CJK glyphs are drawn locally (because we can guess their metrics effectively)
+ * Render size/metrics determined experimentally using Noto Sans
+ - Configuration is done at map creation time by setting a "font family"
+ * JS uses a CSS font-family, this uses android.graphics.Typeface
+ https://developer.android.com/reference/android/graphics/Typeface.html
+ - We use heuristics to extract a font-weight based on the incoming font stack
+ * JS tries to extract multiple weights, this implementation only looks for
+ "bold"
+
+ mbgl::LocalGlyphRasterizer is the portable interface
+ mbgl::LocalGlyphRasterizer::Impl stores platform-specific configuration data
+ mbgl::android::LocalGlyphRasterizer is the JNI wrapper
+ com.mapbox.mapboxsdk.text.LocalGlyphRasterizer is the Java implementation that
+ actually does the drawing
+ */
+
+namespace mbgl {
+namespace android {
+
+PremultipliedImage LocalGlyphRasterizer::drawGlyphBitmap(const std::string& fontFamily, const bool bold, const GlyphID glyphID) {
+ UniqueEnv env { AttachEnv() };
+
+ using Signature = jni::Object<Bitmap>(jni::String, jni::jboolean, jni::jchar);
+ auto method = javaClass.GetStaticMethod<Signature>(*env, "drawGlyphBitmap");
+
+ jni::String jniFontFamily = jni::Make<jni::String>(*env, fontFamily);
+
+ auto javaBitmap = javaClass.Call(*env,
+ method,
+ jniFontFamily,
+ static_cast<jni::jboolean>(bold),
+ static_cast<jni::jchar>(glyphID));
+
+ PremultipliedImage result = Bitmap::GetImage(*env, javaBitmap);
+ jni::DeleteLocalRef(*env, javaBitmap);
+ return result;
+}
+
+void LocalGlyphRasterizer::registerNative(jni::JNIEnv& env) {
+ javaClass = *jni::Class<LocalGlyphRasterizer>::Find(env).NewGlobalRef(env).release();
+}
+
+jni::Class<LocalGlyphRasterizer> LocalGlyphRasterizer::javaClass;
+
+} // namespace android
+
+class LocalGlyphRasterizer::Impl {
+public:
+ Impl(const optional<std::string> fontFamily_)
+ : fontFamily(fontFamily_)
+ {}
+
+ bool isConfigured() const {
+ return bool(fontFamily);
+ }
+
+ PremultipliedImage drawGlyphBitmap(const FontStack& fontStack, GlyphID glyphID) {
+ bool bold = false;
+ for (auto font : fontStack) {
+ std::string lowercaseFont = platform::lowercase(font);
+ if (lowercaseFont.find("bold") != std::string::npos) {
+ bold = true;
+ }
+ }
+ return android::LocalGlyphRasterizer::drawGlyphBitmap(*fontFamily, bold, glyphID);
+ }
+
+private:
+ optional<std::string> fontFamily;
+};
+
+LocalGlyphRasterizer::LocalGlyphRasterizer(const optional<std::string> fontFamily)
+ : impl(std::make_unique<Impl>(fontFamily))
+{}
+
+LocalGlyphRasterizer::~LocalGlyphRasterizer()
+{}
+
+bool LocalGlyphRasterizer::canRasterizeGlyph(const FontStack&, GlyphID glyphID) {
+ return util::i18n::allowsFixedWidthGlyphGeneration(glyphID) && impl->isConfigured();
+}
+
+Glyph LocalGlyphRasterizer::rasterizeGlyph(const FontStack& fontStack, GlyphID glyphID) {
+ Glyph fixedMetrics;
+ if (!impl->isConfigured()) {
+ return fixedMetrics;
+ }
+
+ fixedMetrics.id = glyphID;
+
+ Size size(35, 35);
+
+ fixedMetrics.metrics.width = size.width;
+ fixedMetrics.metrics.height = size.height;
+ fixedMetrics.metrics.left = 3;
+ fixedMetrics.metrics.top = -10;
+ fixedMetrics.metrics.advance = 24;
+
+ PremultipliedImage rgbaBitmap = impl->drawGlyphBitmap(fontStack, glyphID);
+
+ // Copy alpha values from RGBA bitmap into the AlphaImage output
+ fixedMetrics.bitmap = AlphaImage(size);
+ for (uint32_t i = 0; i < size.width * size.height; i++) {
+ fixedMetrics.bitmap.data[i] = rgbaBitmap.data[4 * i + 3];
+ }
+
+ return fixedMetrics;
+}
+
+} // namespace mbgl
diff --git a/platform/android/src/text/local_glyph_rasterizer_jni.hpp b/platform/android/src/text/local_glyph_rasterizer_jni.hpp
new file mode 100644
index 0000000000..38d98d5368
--- /dev/null
+++ b/platform/android/src/text/local_glyph_rasterizer_jni.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <mbgl/util/image.hpp>
+
+#include <jni/jni.hpp>
+
+/*
+ android::LocalGlyphRasterizer is the JNI wrapper of
+ com/mapbox/mapboxsdk/text/LocalGlyphRasterizer
+
+ mbgl::LocalGlyphRasterizer is the portable interface
+ Both implementations are in local_glyph_rasterizer.cpp
+ */
+
+namespace mbgl {
+namespace android {
+
+class LocalGlyphRasterizer {
+public:
+ static PremultipliedImage drawGlyphBitmap(const std::string& fontFamily, const bool bold, const char16_t glyphID);
+
+ static constexpr auto Name() { return "com/mapbox/mapboxsdk/text/LocalGlyphRasterizer"; };
+
+ static jni::Class<LocalGlyphRasterizer> javaClass;
+
+ static void registerNative(jni::JNIEnv&);
+
+};
+
+} // namespace android
+} // namespace mbgl