core/jni/android_text_StaticLayout.cpp - platform/frameworks/base - Gitiles

 /*
  * 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.
  */

 #define LOG_TAG "StaticLayout"

 #include "ScopedIcuLocale.h"
 #include "unicode/locid.h"
 #include "unicode/brkiter.h"
 #include "utils/misc.h"
 #include "utils/Log.h"
 #include <nativehelper/ScopedStringChars.h>
 #include <nativehelper/ScopedPrimitiveArray.h>
 #include <nativehelper/JNIHelp.h>
 #include "core_jni_helpers.h"
 #include <cstdint>
 #include <vector>
 #include <list>
 #include <algorithm>

 #include "SkPaint.h"
 #include "SkTypeface.h"
 #include <hwui/MinikinSkia.h>
 #include <hwui/MinikinUtils.h>
 #include <hwui/Paint.h>
 #include <minikin/FontCollection.h>
 #include <minikin/LineBreaker.h>
 #include <minikin/MinikinFont.h>

 namespace android {

 struct JLineBreaksID {
     jfieldID breaks;
     jfieldID widths;
     jfieldID ascents;
     jfieldID descents;
     jfieldID flags;
 };

 static jclass gLineBreaks_class;
 static JLineBreaksID gLineBreaks_fieldID;

 class JNILineBreakerLineWidth : public minikin::LineBreaker::LineWidthDelegate {
     public:
         JNILineBreakerLineWidth(float firstWidth, int32_t firstLineCount, float restWidth,
                 const std::vector<float>& indents, const std::vector<float>& leftPaddings,
                 const std::vector<float>& rightPaddings, int32_t indentsAndPaddingsOffset)
             : mFirstWidth(firstWidth), mFirstLineCount(firstLineCount), mRestWidth(restWidth),
               mIndents(indents), mLeftPaddings(leftPaddings),
               mRightPaddings(rightPaddings), mOffset(indentsAndPaddingsOffset) {}

         float getLineWidth(size_t lineNo) override {
             const float width = ((ssize_t)lineNo < (ssize_t)mFirstLineCount)
                     ? mFirstWidth : mRestWidth;
             return width - get(mIndents, lineNo);
         }

         float getLeftPadding(size_t lineNo) override {
             return get(mLeftPaddings, lineNo);
         }

         float getRightPadding(size_t lineNo) override {
             return get(mRightPaddings, lineNo);
         }

     private:
         float get(const std::vector<float>& vec, size_t lineNo) {
             if (vec.empty()) {
                 return 0;
             }
             const size_t index = lineNo + mOffset;
             if (index < vec.size()) {
                 return vec[index];
             } else {
                 return vec.back();
             }
         }

         const float mFirstWidth;
         const int32_t mFirstLineCount;
         const float mRestWidth;
         const std::vector<float>& mIndents;
         const std::vector<float>& mLeftPaddings;
         const std::vector<float>& mRightPaddings;
         const int32_t mOffset;
 };

 static inline std::vector<float> jintArrayToFloatVector(JNIEnv* env, jintArray javaArray) {
     if (javaArray == nullptr) {
          return std::vector<float>();
     } else {
         ScopedIntArrayRO intArr(env, javaArray);
         return std::vector<float>(intArr.get(), intArr.get() + intArr.size());
     }
 }

 class Run {
     public:
         Run(int32_t start, int32_t end) : mStart(start), mEnd(end) {}
         virtual ~Run() {}

         virtual void addTo(minikin::LineBreaker* lineBreaker) = 0;

     protected:
         const int32_t mStart;
         const int32_t mEnd;

     private:
         // Forbid copy and assign.
         Run(const Run&) = delete;
         void operator=(const Run&) = delete;
 };

 class StyleRun : public Run {
     public:
         StyleRun(int32_t start, int32_t end, minikin::MinikinPaint&& paint,
                 std::shared_ptr<minikin::FontCollection>&& collection,
                 minikin::FontStyle&& style, bool isRtl)
             : Run(start, end), mPaint(std::move(paint)), mCollection(std::move(collection)),
               mStyle(std::move(style)), mIsRtl(isRtl) {}

         void addTo(minikin::LineBreaker* lineBreaker) override {
             lineBreaker->addStyleRun(&mPaint, mCollection, mStyle, mStart, mEnd, mIsRtl);
         }

     private:
         minikin::MinikinPaint mPaint;
         std::shared_ptr<minikin::FontCollection> mCollection;
         minikin::FontStyle mStyle;
         const bool mIsRtl;
 };

 class Replacement : public Run {
     public:
         Replacement(int32_t start, int32_t end, float width, uint32_t localeListId)
             : Run(start, end), mWidth(width), mLocaleListId(localeListId) {}

         void addTo(minikin::LineBreaker* lineBreaker) override {
             lineBreaker->addReplacement(mStart, mEnd, mWidth, mLocaleListId);
         }

     private:
         const float mWidth;
         const uint32_t mLocaleListId;
 };

 class StaticLayoutNative {
     public:
         StaticLayoutNative(
                 minikin::BreakStrategy strategy, minikin::HyphenationFrequency frequency,
                 bool isJustified, std::vector<float>&& indents, std::vector<float>&& leftPaddings,
                 std::vector<float>&& rightPaddings)
             : mStrategy(strategy), mFrequency(frequency), mIsJustified(isJustified),
               mIndents(std::move(indents)), mLeftPaddings(std::move(leftPaddings)),
               mRightPaddings(std::move(rightPaddings)) {}

         void addStyleRun(int32_t start, int32_t end, minikin::MinikinPaint&& paint,
                          std::shared_ptr<minikin::FontCollection> collection,
                          minikin::FontStyle&& style, bool isRtl) {
             mRuns.emplace_back(std::make_unique<StyleRun>(
                     start, end, std::move(paint), std::move(collection), std::move(style), isRtl));
         }

         void addReplacementRun(int32_t start, int32_t end, float width, uint32_t localeListId) {
             mRuns.emplace_back(std::make_unique<Replacement>(start, end, width, localeListId));
         }

         // Only valid while this instance is alive.
         inline std::unique_ptr<minikin::LineBreaker::LineWidthDelegate> buildLineWidthDelegate(
                 float firstWidth, int32_t firstLineCount, float restWidth,
                 int32_t indentsAndPaddingsOffset) {
             return std::make_unique<JNILineBreakerLineWidth>(
                 firstWidth, firstLineCount, restWidth, mIndents, mLeftPaddings, mRightPaddings,
                 indentsAndPaddingsOffset);
         }

         void addRuns(minikin::LineBreaker* lineBreaker) {
             for (const auto& run : mRuns) {
                 run->addTo(lineBreaker);
             }
         }

         void clearRuns() {
             mRuns.clear();
         }

         inline minikin::BreakStrategy getStrategy() const { return mStrategy; }
         inline minikin::HyphenationFrequency getFrequency() const { return mFrequency; }
         inline bool isJustified() const { return mIsJustified; }

     private:
         const minikin::BreakStrategy mStrategy;
         const minikin::HyphenationFrequency mFrequency;
         const bool mIsJustified;
         const std::vector<float> mIndents;
         const std::vector<float> mLeftPaddings;
         const std::vector<float> mRightPaddings;

         std::vector<std::unique_ptr<Run>> mRuns;
 };

 static inline StaticLayoutNative* toNative(jlong ptr) {
     return reinterpret_cast<StaticLayoutNative*>(ptr);
 }

 // set text and set a number of parameters for creating a layout (width, tabstops, strategy,
 // hyphenFrequency)
 static jlong nInit(JNIEnv* env, jclass /* unused */,
         jint breakStrategy, jint hyphenationFrequency, jboolean isJustified,
         jintArray indents, jintArray leftPaddings, jintArray rightPaddings) {
     return reinterpret_cast<jlong>(new StaticLayoutNative(
             static_cast<minikin::BreakStrategy>(breakStrategy),
             static_cast<minikin::HyphenationFrequency>(hyphenationFrequency),
             isJustified,
             jintArrayToFloatVector(env, indents),
             jintArrayToFloatVector(env, leftPaddings),
             jintArrayToFloatVector(env, rightPaddings)));
 }

 // CriticalNative
 static void nFinish(jlong nativePtr) {
     delete toNative(nativePtr);
 }

 static void recycleCopy(JNIEnv* env, jobject recycle, jintArray recycleBreaks,
                         jfloatArray recycleWidths, jfloatArray recycleAscents,
                         jfloatArray recycleDescents, jintArray recycleFlags,
                         jint recycleLength, size_t nBreaks, const jint* breaks,
                         const jfloat* widths, const jfloat* ascents, const jfloat* descents,
                         const jint* flags) {
     if ((size_t)recycleLength < nBreaks) {
         // have to reallocate buffers
         recycleBreaks = env->NewIntArray(nBreaks);
         recycleWidths = env->NewFloatArray(nBreaks);
         recycleAscents = env->NewFloatArray(nBreaks);
         recycleDescents = env->NewFloatArray(nBreaks);
         recycleFlags = env->NewIntArray(nBreaks);

         env->SetObjectField(recycle, gLineBreaks_fieldID.breaks, recycleBreaks);
         env->SetObjectField(recycle, gLineBreaks_fieldID.widths, recycleWidths);
         env->SetObjectField(recycle, gLineBreaks_fieldID.ascents, recycleAscents);
         env->SetObjectField(recycle, gLineBreaks_fieldID.descents, recycleDescents);
         env->SetObjectField(recycle, gLineBreaks_fieldID.flags, recycleFlags);
     }
     // copy data
     env->SetIntArrayRegion(recycleBreaks, 0, nBreaks, breaks);
     env->SetFloatArrayRegion(recycleWidths, 0, nBreaks, widths);
     env->SetFloatArrayRegion(recycleAscents, 0, nBreaks, ascents);
     env->SetFloatArrayRegion(recycleDescents, 0, nBreaks, descents);
     env->SetIntArrayRegion(recycleFlags, 0, nBreaks, flags);
 }

 static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr,
         // Inputs
         jcharArray text,
         jint length,
         jfloat firstWidth,
         jint firstWidthLineCount,
         jfloat restWidth,
         jintArray variableTabStops,
         jint defaultTabStop,
         jint indentsOffset,

         // Outputs
         jobject recycle,
         jint recycleLength,
         jintArray recycleBreaks,
         jfloatArray recycleWidths,
         jfloatArray recycleAscents,
         jfloatArray recycleDescents,
         jintArray recycleFlags,
         jfloatArray charWidths) {

     StaticLayoutNative* builder = toNative(nativePtr);

     // TODO: Reorganize minikin APIs.
     minikin::LineBreaker b;
     b.resize(length);
     env->GetCharArrayRegion(text, 0, length, b.buffer());
     b.setText();
     if (variableTabStops == nullptr) {
         b.setTabStops(nullptr, 0, defaultTabStop);
     } else {
         ScopedIntArrayRO stops(env, variableTabStops);
         b.setTabStops(stops.get(), stops.size(), defaultTabStop);
     }
     b.setStrategy(builder->getStrategy());
     b.setHyphenationFrequency(builder->getFrequency());
     b.setJustified(builder->isJustified());
     b.setLineWidthDelegate(builder->buildLineWidthDelegate(
             firstWidth, firstWidthLineCount, restWidth, indentsOffset));

     builder->addRuns(&b);

     size_t nBreaks = b.computeBreaks();

     recycleCopy(env, recycle, recycleBreaks, recycleWidths, recycleAscents, recycleDescents,
             recycleFlags, recycleLength, nBreaks, b.getBreaks(), b.getWidths(), b.getAscents(),
             b.getDescents(), b.getFlags());

     env->SetFloatArrayRegion(charWidths, 0, b.size(), b.charWidths());

     b.finish();
     builder->clearRuns();

     return static_cast<jint>(nBreaks);
 }

 // Basically similar to Paint.getTextRunAdvances but with C++ interface
 // CriticalNative
 static void nAddStyleRun(jlong nativePtr, jlong nativePaint, jint start, jint end, jboolean isRtl) {
     StaticLayoutNative* builder = toNative(nativePtr);
     Paint* paint = reinterpret_cast<Paint*>(nativePaint);
     const Typeface* typeface = paint->getAndroidTypeface();
     minikin::MinikinPaint minikinPaint;
     const Typeface* resolvedTypeface = Typeface::resolveDefault(typeface);
     minikin::FontStyle style = MinikinUtils::prepareMinikinPaint(&minikinPaint, paint,
             typeface);

     builder->addStyleRun(
         start, end, std::move(minikinPaint), resolvedTypeface->fFontCollection, std::move(style),
         isRtl);
 }

 // CriticalNative
 static void nAddReplacementRun(jlong nativePtr, jlong nativePaint, jint start, jint end,
         jfloat width) {
     StaticLayoutNative* builder = toNative(nativePtr);
     Paint* paint = reinterpret_cast<Paint*>(nativePaint);
     builder->addReplacementRun(start, end, width, paint->getMinikinLangListId());
 }

 static const JNINativeMethod gMethods[] = {
     // Fast Natives
     {"nInit", "("
         "I"  // breakStrategy
         "I"  // hyphenationFrequency
         "Z"  // isJustified
         "[I"  // indents
         "[I"  // left paddings
         "[I"  // right paddings
         ")J", (void*) nInit},

     // Critical Natives
     {"nFinish", "(J)V", (void*) nFinish},
     {"nAddStyleRun", "(JJIIZ)V", (void*) nAddStyleRun},
     {"nAddReplacementRun", "(JJIIF)V", (void*) nAddReplacementRun},

     // Regular JNI
     {"nComputeLineBreaks", "("
         "J"  // nativePtr

         // Inputs
         "[C"  // text
         "I"  // length
         "F"  // firstWidth
         "I"  // firstWidthLineCount
         "F"  // restWidth
         "[I"  // variableTabStops
         "I"  // defaultTabStop
         "I"  // indentsOffset

         // Outputs
         "Landroid/text/StaticLayout$LineBreaks;"  // recycle
         "I"  // recycleLength
         "[I"  // recycleBreaks
         "[F"  // recycleWidths
         "[F"  // recycleAscents
         "[F"  // recycleDescents
         "[I"  // recycleFlags
         "[F"  // charWidths
         ")I", (void*) nComputeLineBreaks}
 };

 int register_android_text_StaticLayout(JNIEnv* env)
 {
     gLineBreaks_class = MakeGlobalRefOrDie(env,
             FindClassOrDie(env, "android/text/StaticLayout$LineBreaks"));

     gLineBreaks_fieldID.breaks = GetFieldIDOrDie(env, gLineBreaks_class, "breaks", "[I");
     gLineBreaks_fieldID.widths = GetFieldIDOrDie(env, gLineBreaks_class, "widths", "[F");
     gLineBreaks_fieldID.ascents = GetFieldIDOrDie(env, gLineBreaks_class, "ascents", "[F");
     gLineBreaks_fieldID.descents = GetFieldIDOrDie(env, gLineBreaks_class, "descents", "[F");
     gLineBreaks_fieldID.flags = GetFieldIDOrDie(env, gLineBreaks_class, "flags", "[I");

     return RegisterMethodsOrDie(env, "android/text/StaticLayout", gMethods, NELEM(gMethods));
 }

 }
	/*
	* 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.
	*/

	#define LOG_TAG "StaticLayout"

	#include "ScopedIcuLocale.h"
	#include "unicode/locid.h"
	#include "unicode/brkiter.h"
	#include "utils/misc.h"
	#include "utils/Log.h"
	#include <nativehelper/ScopedStringChars.h>
	#include <nativehelper/ScopedPrimitiveArray.h>
	#include <nativehelper/JNIHelp.h>
	#include "core_jni_helpers.h"
	#include <cstdint>
	#include <vector>
	#include <list>
	#include <algorithm>

	#include "SkPaint.h"
	#include "SkTypeface.h"
	#include <hwui/MinikinSkia.h>
	#include <hwui/MinikinUtils.h>
	#include <hwui/Paint.h>
	#include <minikin/FontCollection.h>
	#include <minikin/LineBreaker.h>
	#include <minikin/MinikinFont.h>

	namespace android {

	struct JLineBreaksID {
	jfieldID breaks;
	jfieldID widths;
	jfieldID ascents;
	jfieldID descents;
	jfieldID flags;
	};

	static jclass gLineBreaks_class;
	static JLineBreaksID gLineBreaks_fieldID;

	class JNILineBreakerLineWidth : public minikin::LineBreaker::LineWidthDelegate {
	public:
	JNILineBreakerLineWidth(float firstWidth, int32_t firstLineCount, float restWidth,
	const std::vector<float>& indents, const std::vector<float>& leftPaddings,
	const std::vector<float>& rightPaddings, int32_t indentsAndPaddingsOffset)
	: mFirstWidth(firstWidth), mFirstLineCount(firstLineCount), mRestWidth(restWidth),
	mIndents(indents), mLeftPaddings(leftPaddings),
	mRightPaddings(rightPaddings), mOffset(indentsAndPaddingsOffset) {}

	float getLineWidth(size_t lineNo) override {
	const float width = ((ssize_t)lineNo < (ssize_t)mFirstLineCount)
	? mFirstWidth : mRestWidth;
	return width - get(mIndents, lineNo);
	}

	float getLeftPadding(size_t lineNo) override {
	return get(mLeftPaddings, lineNo);
	}

	float getRightPadding(size_t lineNo) override {
	return get(mRightPaddings, lineNo);
	}

	private:
	float get(const std::vector<float>& vec, size_t lineNo) {
	if (vec.empty()) {
	return 0;
	}
	const size_t index = lineNo + mOffset;
	if (index < vec.size()) {
	return vec[index];
	} else {
	return vec.back();
	}
	}

	const float mFirstWidth;
	const int32_t mFirstLineCount;
	const float mRestWidth;
	const std::vector<float>& mIndents;
	const std::vector<float>& mLeftPaddings;
	const std::vector<float>& mRightPaddings;
	const int32_t mOffset;
	};

	static inline std::vector<float> jintArrayToFloatVector(JNIEnv* env, jintArray javaArray) {
	if (javaArray == nullptr) {
	return std::vector<float>();
	} else {
	ScopedIntArrayRO intArr(env, javaArray);
	return std::vector<float>(intArr.get(), intArr.get() + intArr.size());
	}
	}

	class Run {
	public:
	Run(int32_t start, int32_t end) : mStart(start), mEnd(end) {}
	virtual ~Run() {}

	virtual void addTo(minikin::LineBreaker* lineBreaker) = 0;

	protected:
	const int32_t mStart;
	const int32_t mEnd;

	private:
	// Forbid copy and assign.
	Run(const Run&) = delete;
	void operator=(const Run&) = delete;
	};

	class StyleRun : public Run {
	public:
	StyleRun(int32_t start, int32_t end, minikin::MinikinPaint&& paint,
	std::shared_ptr<minikin::FontCollection>&& collection,
	minikin::FontStyle&& style, bool isRtl)
	: Run(start, end), mPaint(std::move(paint)), mCollection(std::move(collection)),
	mStyle(std::move(style)), mIsRtl(isRtl) {}

	void addTo(minikin::LineBreaker* lineBreaker) override {
	lineBreaker->addStyleRun(&mPaint, mCollection, mStyle, mStart, mEnd, mIsRtl);
	}

	private:
	minikin::MinikinPaint mPaint;
	std::shared_ptr<minikin::FontCollection> mCollection;
	minikin::FontStyle mStyle;
	const bool mIsRtl;
	};

	class Replacement : public Run {
	public:
	Replacement(int32_t start, int32_t end, float width, uint32_t localeListId)
	: Run(start, end), mWidth(width), mLocaleListId(localeListId) {}

	void addTo(minikin::LineBreaker* lineBreaker) override {
	lineBreaker->addReplacement(mStart, mEnd, mWidth, mLocaleListId);
	}

	private:
	const float mWidth;
	const uint32_t mLocaleListId;
	};

	class StaticLayoutNative {
	public:
	StaticLayoutNative(
	minikin::BreakStrategy strategy, minikin::HyphenationFrequency frequency,
	bool isJustified, std::vector<float>&& indents, std::vector<float>&& leftPaddings,
	std::vector<float>&& rightPaddings)
	: mStrategy(strategy), mFrequency(frequency), mIsJustified(isJustified),
	mIndents(std::move(indents)), mLeftPaddings(std::move(leftPaddings)),
	mRightPaddings(std::move(rightPaddings)) {}

	void addStyleRun(int32_t start, int32_t end, minikin::MinikinPaint&& paint,
	std::shared_ptr<minikin::FontCollection> collection,
	minikin::FontStyle&& style, bool isRtl) {
	mRuns.emplace_back(std::make_unique<StyleRun>(
	start, end, std::move(paint), std::move(collection), std::move(style), isRtl));
	}

	void addReplacementRun(int32_t start, int32_t end, float width, uint32_t localeListId) {
	mRuns.emplace_back(std::make_unique<Replacement>(start, end, width, localeListId));
	}

	// Only valid while this instance is alive.
	inline std::unique_ptr<minikin::LineBreaker::LineWidthDelegate> buildLineWidthDelegate(
	float firstWidth, int32_t firstLineCount, float restWidth,
	int32_t indentsAndPaddingsOffset) {
	return std::make_unique<JNILineBreakerLineWidth>(
	firstWidth, firstLineCount, restWidth, mIndents, mLeftPaddings, mRightPaddings,
	indentsAndPaddingsOffset);
	}

	void addRuns(minikin::LineBreaker* lineBreaker) {
	for (const auto& run : mRuns) {
	run->addTo(lineBreaker);
	}
	}

	void clearRuns() {
	mRuns.clear();
	}

	inline minikin::BreakStrategy getStrategy() const { return mStrategy; }
	inline minikin::HyphenationFrequency getFrequency() const { return mFrequency; }
	inline bool isJustified() const { return mIsJustified; }

	private:
	const minikin::BreakStrategy mStrategy;
	const minikin::HyphenationFrequency mFrequency;
	const bool mIsJustified;
	const std::vector<float> mIndents;
	const std::vector<float> mLeftPaddings;
	const std::vector<float> mRightPaddings;

	std::vector<std::unique_ptr<Run>> mRuns;
	};

	static inline StaticLayoutNative* toNative(jlong ptr) {
	return reinterpret_cast<StaticLayoutNative*>(ptr);
	}

	// set text and set a number of parameters for creating a layout (width, tabstops, strategy,
	// hyphenFrequency)
	static jlong nInit(JNIEnv* env, jclass /* unused */,
	jint breakStrategy, jint hyphenationFrequency, jboolean isJustified,
	jintArray indents, jintArray leftPaddings, jintArray rightPaddings) {
	return reinterpret_cast<jlong>(new StaticLayoutNative(
	static_cast<minikin::BreakStrategy>(breakStrategy),
	static_cast<minikin::HyphenationFrequency>(hyphenationFrequency),
	isJustified,
	jintArrayToFloatVector(env, indents),
	jintArrayToFloatVector(env, leftPaddings),
	jintArrayToFloatVector(env, rightPaddings)));
	}

	// CriticalNative
	static void nFinish(jlong nativePtr) {
	delete toNative(nativePtr);
	}

	static void recycleCopy(JNIEnv* env, jobject recycle, jintArray recycleBreaks,
	jfloatArray recycleWidths, jfloatArray recycleAscents,
	jfloatArray recycleDescents, jintArray recycleFlags,
	jint recycleLength, size_t nBreaks, const jint* breaks,
	const jfloat* widths, const jfloat* ascents, const jfloat* descents,
	const jint* flags) {
	if ((size_t)recycleLength < nBreaks) {
	// have to reallocate buffers
	recycleBreaks = env->NewIntArray(nBreaks);
	recycleWidths = env->NewFloatArray(nBreaks);
	recycleAscents = env->NewFloatArray(nBreaks);
	recycleDescents = env->NewFloatArray(nBreaks);
	recycleFlags = env->NewIntArray(nBreaks);

	env->SetObjectField(recycle, gLineBreaks_fieldID.breaks, recycleBreaks);
	env->SetObjectField(recycle, gLineBreaks_fieldID.widths, recycleWidths);
	env->SetObjectField(recycle, gLineBreaks_fieldID.ascents, recycleAscents);
	env->SetObjectField(recycle, gLineBreaks_fieldID.descents, recycleDescents);
	env->SetObjectField(recycle, gLineBreaks_fieldID.flags, recycleFlags);
	}
	// copy data
	env->SetIntArrayRegion(recycleBreaks, 0, nBreaks, breaks);
	env->SetFloatArrayRegion(recycleWidths, 0, nBreaks, widths);
	env->SetFloatArrayRegion(recycleAscents, 0, nBreaks, ascents);
	env->SetFloatArrayRegion(recycleDescents, 0, nBreaks, descents);
	env->SetIntArrayRegion(recycleFlags, 0, nBreaks, flags);
	}

	static jint nComputeLineBreaks(JNIEnv* env, jclass, jlong nativePtr,
	// Inputs
	jcharArray text,
	jint length,
	jfloat firstWidth,
	jint firstWidthLineCount,
	jfloat restWidth,
	jintArray variableTabStops,
	jint defaultTabStop,
	jint indentsOffset,

	// Outputs
	jobject recycle,
	jint recycleLength,
	jintArray recycleBreaks,
	jfloatArray recycleWidths,
	jfloatArray recycleAscents,
	jfloatArray recycleDescents,
	jintArray recycleFlags,
	jfloatArray charWidths) {

	StaticLayoutNative* builder = toNative(nativePtr);

	// TODO: Reorganize minikin APIs.
	minikin::LineBreaker b;
	b.resize(length);
	env->GetCharArrayRegion(text, 0, length, b.buffer());
	b.setText();
	if (variableTabStops == nullptr) {
	b.setTabStops(nullptr, 0, defaultTabStop);
	} else {
	ScopedIntArrayRO stops(env, variableTabStops);
	b.setTabStops(stops.get(), stops.size(), defaultTabStop);
	}
	b.setStrategy(builder->getStrategy());
	b.setHyphenationFrequency(builder->getFrequency());
	b.setJustified(builder->isJustified());
	b.setLineWidthDelegate(builder->buildLineWidthDelegate(
	firstWidth, firstWidthLineCount, restWidth, indentsOffset));

	builder->addRuns(&b);

	size_t nBreaks = b.computeBreaks();

	recycleCopy(env, recycle, recycleBreaks, recycleWidths, recycleAscents, recycleDescents,
	recycleFlags, recycleLength, nBreaks, b.getBreaks(), b.getWidths(), b.getAscents(),
	b.getDescents(), b.getFlags());

	env->SetFloatArrayRegion(charWidths, 0, b.size(), b.charWidths());

	b.finish();
	builder->clearRuns();

	return static_cast<jint>(nBreaks);
	}

	// Basically similar to Paint.getTextRunAdvances but with C++ interface
	// CriticalNative
	static void nAddStyleRun(jlong nativePtr, jlong nativePaint, jint start, jint end, jboolean isRtl) {
	StaticLayoutNative* builder = toNative(nativePtr);
	Paint* paint = reinterpret_cast<Paint*>(nativePaint);
	const Typeface* typeface = paint->getAndroidTypeface();
	minikin::MinikinPaint minikinPaint;
	const Typeface* resolvedTypeface = Typeface::resolveDefault(typeface);
	minikin::FontStyle style = MinikinUtils::prepareMinikinPaint(&minikinPaint, paint,
	typeface);

	builder->addStyleRun(
	start, end, std::move(minikinPaint), resolvedTypeface->fFontCollection, std::move(style),
	isRtl);
	}

	// CriticalNative
	static void nAddReplacementRun(jlong nativePtr, jlong nativePaint, jint start, jint end,
	jfloat width) {
	StaticLayoutNative* builder = toNative(nativePtr);
	Paint* paint = reinterpret_cast<Paint*>(nativePaint);
	builder->addReplacementRun(start, end, width, paint->getMinikinLangListId());
	}

	static const JNINativeMethod gMethods[] = {
	// Fast Natives
	{"nInit", "("
	"I" // breakStrategy
	"I" // hyphenationFrequency
	"Z" // isJustified
	"[I" // indents
	"[I" // left paddings
	"[I" // right paddings
	")J", (void*) nInit},

	// Critical Natives
	{"nFinish", "(J)V", (void*) nFinish},
	{"nAddStyleRun", "(JJIIZ)V", (void*) nAddStyleRun},
	{"nAddReplacementRun", "(JJIIF)V", (void*) nAddReplacementRun},

	// Regular JNI
	{"nComputeLineBreaks", "("
	"J" // nativePtr

	// Inputs
	"[C" // text
	"I" // length
	"F" // firstWidth
	"I" // firstWidthLineCount
	"F" // restWidth
	"[I" // variableTabStops
	"I" // defaultTabStop
	"I" // indentsOffset

	// Outputs
	"Landroid/text/StaticLayout$LineBreaks;" // recycle
	"I" // recycleLength
	"[I" // recycleBreaks
	"[F" // recycleWidths
	"[F" // recycleAscents
	"[F" // recycleDescents
	"[I" // recycleFlags
	"[F" // charWidths
	")I", (void*) nComputeLineBreaks}
	};

	int register_android_text_StaticLayout(JNIEnv* env)
	{
	gLineBreaks_class = MakeGlobalRefOrDie(env,
	FindClassOrDie(env, "android/text/StaticLayout$LineBreaks"));

	gLineBreaks_fieldID.breaks = GetFieldIDOrDie(env, gLineBreaks_class, "breaks", "[I");
	gLineBreaks_fieldID.widths = GetFieldIDOrDie(env, gLineBreaks_class, "widths", "[F");
	gLineBreaks_fieldID.ascents = GetFieldIDOrDie(env, gLineBreaks_class, "ascents", "[F");
	gLineBreaks_fieldID.descents = GetFieldIDOrDie(env, gLineBreaks_class, "descents", "[F");
	gLineBreaks_fieldID.flags = GetFieldIDOrDie(env, gLineBreaks_class, "flags", "[I");

	return RegisterMethodsOrDie(env, "android/text/StaticLayout", gMethods, NELEM(gMethods));
	}

	}