blob: a2fef1e19328fed1cd75a099c2cf1fda69b2946d [file] [log] [blame]
/*
* Copyright (C) 2014 The Android Open Source Project
*
* 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.
*/
#undef LOG_TAG
#define LOG_TAG "Minikin"
#include "SkData.h"
#include "SkFontMgr.h"
#include "SkRefCnt.h"
#include "SkTypeface.h"
#include "GraphicsJNI.h"
#include <nativehelper/ScopedPrimitiveArray.h>
#include <nativehelper/ScopedUtfChars.h>
#include "Utils.h"
#include "FontUtils.h"
#include <hwui/MinikinSkia.h>
#include <hwui/Typeface.h>
#include <minikin/FontFamily.h>
#include <minikin/LocaleList.h>
#include <ui/FatVector.h>
#include <memory>
namespace android {
struct NativeFamilyBuilder {
NativeFamilyBuilder(uint32_t langId, int variant)
: langId(langId), variant(static_cast<minikin::FamilyVariant>(variant)) {}
uint32_t langId;
minikin::FamilyVariant variant;
std::vector<minikin::Font> fonts;
std::vector<minikin::FontVariation> axes;
};
static inline NativeFamilyBuilder* toNativeBuilder(jlong ptr) {
return reinterpret_cast<NativeFamilyBuilder*>(ptr);
}
static inline FontFamilyWrapper* toFamily(jlong ptr) {
return reinterpret_cast<FontFamilyWrapper*>(ptr);
}
template<typename Ptr> static inline jlong toJLong(Ptr ptr) {
return reinterpret_cast<jlong>(ptr);
}
static jlong FontFamily_initBuilder(JNIEnv* env, jobject clazz, jstring langs, jint variant) {
NativeFamilyBuilder* builder;
if (langs != nullptr) {
ScopedUtfChars str(env, langs);
builder = new NativeFamilyBuilder(minikin::registerLocaleList(str.c_str()), variant);
} else {
builder = new NativeFamilyBuilder(minikin::registerLocaleList(""), variant);
}
return toJLong(builder);
}
static jlong FontFamily_create(CRITICAL_JNI_PARAMS_COMMA jlong builderPtr) {
if (builderPtr == 0) {
return 0;
}
NativeFamilyBuilder* builder = toNativeBuilder(builderPtr);
if (builder->fonts.empty()) {
return 0;
}
std::shared_ptr<minikin::FontFamily> family = std::make_shared<minikin::FontFamily>(
builder->langId, builder->variant, std::move(builder->fonts),
true /* isCustomFallback */);
if (family->getCoverage().length() == 0) {
return 0;
}
return toJLong(new FontFamilyWrapper(std::move(family)));
}
static void releaseBuilder(jlong builderPtr) {
delete toNativeBuilder(builderPtr);
}
static jlong FontFamily_getBuilderReleaseFunc(CRITICAL_JNI_PARAMS) {
return toJLong(&releaseBuilder);
}
static void releaseFamily(jlong familyPtr) {
delete toFamily(familyPtr);
}
static jlong FontFamily_getFamilyReleaseFunc(CRITICAL_JNI_PARAMS) {
return toJLong(&releaseFamily);
}
static bool addSkTypeface(NativeFamilyBuilder* builder, sk_sp<SkData>&& data, int ttcIndex,
jint weight, jint italic) {
FatVector<SkFontArguments::Axis, 2> skiaAxes;
for (const auto& axis : builder->axes) {
skiaAxes.emplace_back(SkFontArguments::Axis{axis.axisTag, axis.value});
}
const size_t fontSize = data->size();
const void* fontPtr = data->data();
std::unique_ptr<SkStreamAsset> fontData(new SkMemoryStream(std::move(data)));
SkFontArguments params;
params.setCollectionIndex(ttcIndex);
params.setAxes(skiaAxes.data(), skiaAxes.size());
sk_sp<SkFontMgr> fm(SkFontMgr::RefDefault());
sk_sp<SkTypeface> face(fm->makeFromStream(std::move(fontData), params));
if (face == NULL) {
ALOGE("addFont failed to create font, invalid request");
builder->axes.clear();
return false;
}
std::shared_ptr<minikin::MinikinFont> minikinFont =
std::make_shared<MinikinFontSkia>(std::move(face), fontPtr, fontSize, "", ttcIndex,
builder->axes);
minikin::Font::Builder fontBuilder(minikinFont);
if (weight != RESOLVE_BY_FONT_TABLE) {
fontBuilder.setWeight(weight);
}
if (italic != RESOLVE_BY_FONT_TABLE) {
fontBuilder.setSlant(static_cast<minikin::FontStyle::Slant>(italic != 0));
}
builder->fonts.push_back(fontBuilder.build());
builder->axes.clear();
return true;
}
static void release_global_ref(const void* /*data*/, void* context) {
JNIEnv* env = GraphicsJNI::getJNIEnv();
bool needToAttach = (env == NULL);
if (needToAttach) {
env = GraphicsJNI::attachJNIEnv("release_font_data");
if (env == nullptr) {
ALOGE("failed to attach to thread to release global ref.");
return;
}
}
jobject obj = reinterpret_cast<jobject>(context);
env->DeleteGlobalRef(obj);
if (needToAttach) {
GraphicsJNI::detachJNIEnv();
}
}
static jboolean FontFamily_addFont(JNIEnv* env, jobject clazz, jlong builderPtr, jobject bytebuf,
jint ttcIndex, jint weight, jint isItalic) {
NPE_CHECK_RETURN_ZERO(env, bytebuf);
NativeFamilyBuilder* builder = reinterpret_cast<NativeFamilyBuilder*>(builderPtr);
const void* fontPtr = env->GetDirectBufferAddress(bytebuf);
if (fontPtr == NULL) {
ALOGE("addFont failed to create font, buffer invalid");
builder->axes.clear();
return false;
}
jlong fontSize = env->GetDirectBufferCapacity(bytebuf);
if (fontSize < 0) {
ALOGE("addFont failed to create font, buffer size invalid");
builder->axes.clear();
return false;
}
jobject fontRef = MakeGlobalRefOrDie(env, bytebuf);
sk_sp<SkData> data(SkData::MakeWithProc(fontPtr, fontSize,
release_global_ref, reinterpret_cast<void*>(fontRef)));
return addSkTypeface(builder, std::move(data), ttcIndex, weight, isItalic);
}
static jboolean FontFamily_addFontWeightStyle(JNIEnv* env, jobject clazz, jlong builderPtr,
jobject font, jint ttcIndex, jint weight, jint isItalic) {
NPE_CHECK_RETURN_ZERO(env, font);
NativeFamilyBuilder* builder = toNativeBuilder(builderPtr);
const void* fontPtr = env->GetDirectBufferAddress(font);
if (fontPtr == NULL) {
ALOGE("addFont failed to create font, buffer invalid");
builder->axes.clear();
return false;
}
jlong fontSize = env->GetDirectBufferCapacity(font);
if (fontSize < 0) {
ALOGE("addFont failed to create font, buffer size invalid");
builder->axes.clear();
return false;
}
jobject fontRef = MakeGlobalRefOrDie(env, font);
sk_sp<SkData> data(SkData::MakeWithProc(fontPtr, fontSize,
release_global_ref, reinterpret_cast<void*>(fontRef)));
return addSkTypeface(builder, std::move(data), ttcIndex, weight, isItalic);
}
static void FontFamily_addAxisValue(CRITICAL_JNI_PARAMS_COMMA jlong builderPtr, jint tag, jfloat value) {
NativeFamilyBuilder* builder = toNativeBuilder(builderPtr);
builder->axes.push_back({static_cast<minikin::AxisTag>(tag), value});
}
///////////////////////////////////////////////////////////////////////////////
static const JNINativeMethod gFontFamilyMethods[] = {
{ "nInitBuilder", "(Ljava/lang/String;I)J", (void*)FontFamily_initBuilder },
{ "nCreateFamily", "(J)J", (void*)FontFamily_create },
{ "nGetBuilderReleaseFunc", "()J", (void*)FontFamily_getBuilderReleaseFunc },
{ "nGetFamilyReleaseFunc", "()J", (void*)FontFamily_getFamilyReleaseFunc },
{ "nAddFont", "(JLjava/nio/ByteBuffer;III)Z", (void*)FontFamily_addFont },
{ "nAddFontWeightStyle", "(JLjava/nio/ByteBuffer;III)Z",
(void*)FontFamily_addFontWeightStyle },
{ "nAddAxisValue", "(JIF)V", (void*)FontFamily_addAxisValue },
};
int register_android_graphics_FontFamily(JNIEnv* env)
{
int err = RegisterMethodsOrDie(env, "android/graphics/FontFamily", gFontFamilyMethods,
NELEM(gFontFamilyMethods));
init_FontUtils(env);
return err;
}
}