<option value="$PROJECT_DIR$/furiganatextview" />

</project>

    implementation project(path: ':furiganatextview')

import android.os.Build;

import android.view.Gravity;

import org.w3c.dom.Text;

import se.fekete.furiganatextview.furiganaview.FuriganaTextView;

                FuriganaTextView kanji_view = child_result.findViewById(R.id.kanji_view);

                    kanji_view.setFuriganaText(result.getKanjiFurigana());

                    kanji_view.setFuriganaText(result.getKanji());

                current.append("<ruby>");

                current.append("<rt>");

                current.append("</rt>");

                current.append("</ruby>");

            <se.fekete.furiganatextview.furiganaview.FuriganaTextView

                android:layout_width="match_parent"

                app:contains_ruby_tags="true"

    ext.kotlin_version = '1.3.72'

        classpath 'com.android.tools.build:gradle:4.0.0'

        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

/build

apply plugin: 'com.android.library'

apply plugin: 'kotlin-android'

android {

    compileSdkVersion 29

    defaultConfig {

        minSdkVersion 15

        targetSdkVersion 29

        versionCode 1

        versionName "1.0"

    }

    buildTypes {

        release {

            minifyEnabled false

            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

        }

    }

}

dependencies {

    implementation fileTree(dir: 'libs', include: ['*.jar'])

    testImplementation 'junit:junit:4.12'

    implementation 'androidx.appcompat:appcompat:1.3.0'

    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"

}

repositories {

    mavenCentral()

}

# Add project specific ProGuard rules here.

# By default, the flags in this file are appended to flags specified

# in /Users/lorand/Android_SDK/sdk/tools/proguard/proguard-android.txt

# You can edit the include path and order by changing the proguardFiles

# directive in build.gradle.

#

# For more details, see

#   http://developer.android.com/guide/developing/tools/proguard.html

# Add any project specific keep options here:

# If your project uses WebView with JS, uncomment the following

# and specify the fully qualified class name to the JavaScript interface

# class:

#-keepclassmembers class fqcn.of.javascript.interface.for.webview {

#   public *;

#}

package eu.lepiller.furiganatextview;

import android.content.Context;

import androidx.test.platform.app.InstrumentationRegistry;

import androidx.test.ext.junit.runners.AndroidJUnit4;

import org.junit.Test;

import org.junit.runner.RunWith;

import static org.junit.Assert.*;

/**

 * Instrumented test, which will execute on an Android device.

 *

 * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>

 */

@RunWith(AndroidJUnit4.class)

public class ExampleInstrumentedTest {

    @Test

    public void useAppContext() {

        // Context of the app under test.

        Context appContext = InstrumentationRegistry.getTargetContext();

        assertEquals("eu.lepiller.furiganatextview.test", appContext.getPackageName());

    }

}

package se.fekete.furiganatextview;

import android.app.Application;

import android.test.ApplicationTestCase;

/**

 * <a href="http://d.android.com/tools/testing/testing_android.html">Testing Fundamentals</a>

 */

public class ApplicationTest extends ApplicationTestCase<Application> {

    public ApplicationTest() {

        super(Application.class);

    }

}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="se.fekete.furiganatextview">

    <application android:allowBackup="true"

        android:label="@string/app_name"

        android:supportsRtl="true"

>

    </application>

</manifest>

/*

 * FuriganaView widget

 * Copyright (C) 2013 sh0 <sh0@yutani.ee>

 * Licensed under Creative Commons BY-SA 3.0

 */

package se.fekete.furiganatextview.furiganaview

import android.content.Context

import android.graphics.Canvas

import android.text.SpannableString

import android.text.TextPaint

import android.util.AttributeSet

import android.view.View

import android.widget.TextView

import se.fekete.furiganatextview.R

import java.util.*

class FuriganaTextView : TextView {

    // Paints

    private var textPaintFurigana = TextPaint()

    private var textPaintNormal = TextPaint()

    // Sizes

    private var lineSize = 0.0f

    private var normalHeight = 0.0f

    private var furiganaHeight = 0.0f

    private var lineMax = 0.0f

    // Spans and lines

    private val spans = Vector<Span>()

    private val normalLines = Vector<LineNormal>()

    private val furiganaLines = Vector<LineFurigana>()

    //attributes

    private var hasRuby: Boolean = false

    private var furiganaTextColor: Int = 0

    // Constructors

    constructor(context: Context) : super(context) {

        initialize()

    }

    constructor(context: Context, attrs: AttributeSet) : super(context, attrs) {

        val typedArray = context.obtainStyledAttributes(attrs, R.styleable.FuriganaTextView, 0, 0)

        try {

            hasRuby = typedArray.getBoolean(R.styleable.FuriganaTextView_contains_ruby_tags, false)

            furiganaTextColor = typedArray.getColor(R.styleable.FuriganaTextView_furigana_text_color, 0)

        } finally {

            typedArray.recycle()

        }

        initialize()

    }

    private fun initialize() {

        val viewText = text

        if (viewText.isNotEmpty()) {

            if (viewText is String)

                setFuriganaText(viewText, hasRuby)

            else

                setFuriganaText((viewText as SpannableString).toString(), hasRuby)

        }

    }

    /**

     * The method parseRuby converts kanji enclosed in ruby tags to the

     * format which is supported by the textview {Kanji:furigana}

     * @param textWithRuby

     * The text string with Kanji enclosed in ruby tags.

     */

    private fun replaceRuby(textWithRuby: String): String {

        var parsed = textWithRuby.replace("<ruby>", "{")

        parsed = parsed.replace("<rt>", ";")

        parsed = parsed.replace("</rt>", "")

        return parsed.replace("</ruby>", "}")

    }

    override fun setTextColor(color: Int) {

        super.setTextColor(color)

        invalidate()

    }

    fun setFuriganaText(text: String) {

        setFuriganaText(text, hasRuby = false)

    }

    fun setFuriganaText(text: String, hasRuby: Boolean) {

        super.setText(text)

        var textToDisplay = text

        if (this.hasRuby || hasRuby) {

            textToDisplay = replaceRuby(text)

        }

        setText(paint, textToDisplay, 0, 0)

    }

    private fun setText(tp: TextPaint, text: String, markS: Int, markE: Int) {

        var mutableText = text

        var mutableMarkS = markS

        var mutableMarkE = markE

        // Text

        textPaintNormal = TextPaint(tp)

        textPaintFurigana = TextPaint(tp)

        textPaintFurigana.textSize = textPaintFurigana.textSize / 2.0f

        // Line size

        normalHeight = textPaintNormal.descent() - textPaintNormal.ascent()

        furiganaHeight = textPaintFurigana.descent() - textPaintFurigana.ascent()

        lineSize = normalHeight + furiganaHeight

        // Clear spans

        spans.clear()

        // Sizes

        lineSize = textPaintFurigana.fontSpacing + Math.max(textPaintNormal.fontSpacing, 0f)

        // Spannify text

        while (mutableText.isNotEmpty()) {

            var idx = mutableText.indexOf('{')

            if (idx >= 0) {

                // Prefix string

                if (idx > 0) {

                    // Spans

                    spans.add(Span("", mutableText.substring(0, idx), mutableMarkS, mutableMarkE, textPaintNormal, textPaintFurigana))

                    // Remove text

                    mutableText = mutableText.substring(idx)

                    mutableMarkS -= idx

                    mutableMarkE -= idx

                }

                // End bracket

                idx = mutableText.indexOf('}')

                if (idx < 1) {

                    // Error

                    break

                } else if (idx == 1) {

                    // Empty bracket

                    mutableText = mutableText.substring(2)

                    continue

                }

                // Spans

                val split = mutableText.substring(1, idx).split(";".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()

                spans.add(Span(if (split.size > 1) split[1] else "", split[0], mutableMarkS, mutableMarkE, textPaintNormal, textPaintFurigana))

                // Remove text

                mutableText = mutableText.substring(idx + 1)

                mutableMarkS -= split[0].length

                mutableMarkE -= split[0].length

            } else {

                // Single span

                spans.add(Span("", mutableText, mutableMarkS, mutableMarkE, textPaintNormal, textPaintFurigana))

                mutableText = ""

            }

        }

        // Invalidate view

        this.invalidate()

        this.requestLayout()

    }

    // Size calculation

    override fun onMeasure(width_ms: Int, height_ms: Int) {

        // Modes

        val wmode = View.MeasureSpec.getMode(width_ms)

        val hmode = View.MeasureSpec.getMode(height_ms)

        // Dimensions

        val wold = View.MeasureSpec.getSize(width_ms)

        val hold = View.MeasureSpec.getSize(height_ms)

        if (text.isNotEmpty()) {

            // Draw mode

            if (wmode == View.MeasureSpec.EXACTLY || wmode == View.MeasureSpec.AT_MOST && wold > 0) {

                // Width limited

                calculateText(wold.toFloat())

            } else {

                // Width unlimited

                calculateText(-1.0f)

            }

        }

        // New height

        var hnew = Math.round(Math.ceil((lineSize * normalLines.size.toFloat()).toDouble())).toInt()

        var wnew = wold

        if (wmode != View.MeasureSpec.EXACTLY && normalLines.size <= 1)

            wnew = Math.round(Math.ceil(lineMax.toDouble())).toInt()

        if (hmode != View.MeasureSpec.UNSPECIFIED && hnew > hold)

            hnew = hnew or View.MEASURED_STATE_TOO_SMALL

        // Set result

        setMeasuredDimension(wnew, hnew)

    }

    private fun calculateText(lineMax: Float) {

        // Clear lines

        normalLines.clear()

        furiganaLines.clear()

        // Sizes

        this.lineMax = 0.0f

        // Check if no limits on width

        if (lineMax < 0.0) {

            // Create single normal and furigana line

            val lineN = LineNormal(textPaintNormal)

            val lineF = LineFurigana(this.lineMax, textPaintFurigana)

            // Loop spans

            for (span in spans) {

                // Text

                lineN.add(span.normal())

                lineF.add(span.furigana(this.lineMax))

                // Widths update

                for (width in span.widths())

                    this.lineMax += width

            }

            // Commit both lines

            normalLines.add(lineN)

            furiganaLines.add(lineF)

        } else {

            // Lines

            var lineX = 0.0f

            var lineN = LineNormal(textPaintNormal)

            var lineF = LineFurigana(this.lineMax, textPaintFurigana)

            // Initial span

            var spanI = 0

            var span: Span? = if (spans.isNotEmpty()) spans[spanI] else null

            // Iterate

            while (span != null) {

                // Start offset

                val lineS = lineX

                // Calculate possible line size

                val widths = span.widths()

                var i = 0

                while (i < widths.size) {

                    if (lineX + widths[i] <= lineMax) {

                        lineX += widths[i]

                    } else {

                        break

                    }

                    i++

                }

                // Add span to line

                if (i >= 0 && i < widths.size) {

                    // Span does not fit entirely

                    if (i > 0) {

                        // Split half that fits

                        val normalA = Vector<TextNormal>()

                        val normalB = Vector<TextNormal>()

                        span.split(i, normalA, normalB)

                        lineN.add(normalA)

                        span = Span(normalB)

                    }

                    // Add new line with current spans

                    if (lineN.size() != 0) {

                        // Add

                        this.lineMax = if (this.lineMax > lineX) this.lineMax else lineX

                        normalLines.add(lineN)

                        furiganaLines.add(lineF)

                        // Reset

                        lineN = LineNormal(textPaintNormal)

                        lineF = LineFurigana(this.lineMax, textPaintFurigana)

                        lineX = 0.0f

                        // Next span

                        continue

                    }

                } else {

                    // Span fits entirely

                    lineN.add(span.normal())

                    lineF.add(span.furigana(lineS))

                }

                // Next span

                span = null

                spanI++

                if (spanI < this.spans.size) {

                    span = this.spans[spanI]

                }

            }

            // Last span

            if (lineN.size() != 0) {

                // Add

                this.lineMax = if (this.lineMax > lineX) this.lineMax else lineX

                normalLines.add(lineN)

                furiganaLines.add(lineF)

            }

        }

        // Calculate furigana

        for (line in furiganaLines) {

            line.calculate()

        }

    }

    // Drawing

    public override fun onDraw(canvas: Canvas) {

        textPaintNormal.color = currentTextColor

        if (furiganaTextColor != 0) {

            textPaintFurigana.color = furiganaTextColor

        } else {

            textPaintFurigana.color = currentTextColor

        }

        // Coordinates

        var y = lineSize

        // Loop lines

        for (i in normalLines.indices) {

            normalLines[i].draw(canvas, y)

            furiganaLines[i].draw(canvas, y - normalHeight)

            y += lineSize

        }

    }

}

package se.fekete.furiganatextview.furiganaview

import android.graphics.Canvas

import android.graphics.Paint

import java.util.*

class LineFurigana(private val lineMax: Float, private val paint: Paint) {

    // Text

    private val texts = Vector<TextFurigana>()

    private val offsets = Vector<Float>()

    // Add

    fun add(text: TextFurigana?) {

        if (text != null) {

            this.texts.add(text)

        }

    }

    // Calculate

    fun calculate() {

        // Check size

        if (texts.size == 0) {

            return

        }

        val r = FloatArray(texts.size)

        for (i in texts.indices) {

            r[i] = texts[i].getOffset()

        }

        // a[] - constraint matrix

        val a = Array(texts.size + 1) { FloatArray(texts.size) }

        for (i in a.indices) {

            for (j in 0 until a[0].size) {

                a[i][j] = 0.0f

            }

        }

        a[0][0] = 1.0f

        for (i in 1 until a.size - 2) {

            a[i][i - 1] = -1.0f

            a[i][i] = 1.0f

        }

        a[a.size - 1][a[0].size - 1] = -1.0f

        // b[] - constraint vector

        val b = FloatArray(texts.size + 1)

        b[0] = -r[0] + 0.5f * texts[0].width()

        for (i in 1 until b.size - 2) {

            b[i] = 0.5f * (texts[i].width() + texts[i - 1].width()) + (r[i - 1] - r[i])

        }

        b[b.size - 1] = -lineMax + r[r.size - 1] + 0.5f * texts[texts.size - 1].width()

        // Calculate constraint optimization

        val x = FloatArray(texts.size)

        for (i in x.indices) {

            x[i] = 0.0f

        }

        val co = QuadraticOptimizer(a, b)

        co.calculate(x)

        for (i in x.indices) {

            offsets.add(x[i] + r[i])

        }

    }

    // Draw

    fun draw(canvas: Canvas, y: Float) {

        var mutableY = y

        mutableY -= paint.descent()

        if (offsets.size == texts.size) {

            // Render with fixed offsets

            for (i in offsets.indices) {

                texts[i].draw(canvas, offsets[i], mutableY)

            }

        } else {

            // Render with original offsets

            for (text in texts) {

                text.draw(canvas, text.getOffset(), mutableY)

            }

        }

    }

}

package se.fekete.furiganatextview.furiganaview

import android.graphics.Canvas

import android.graphics.Paint

import java.util.*

class LineNormal(val paint: Paint) {

    // Text

    private val text = Vector<TextNormal>()

    // Elements

    fun size(): Int {

        return text.size

    }

    fun add(text: Vector<TextNormal>) {

        this.text.addAll(text)

    }

    // Draw

    fun draw(canvas: Canvas, y: Float) {

        var mutableY = y

        mutableY -= paint.descent()

        var x = 0.0f

        for (text in text) {

            x += text.draw(canvas, x, mutableY)

        }

    }

}

/*

 * FuriganaView widget

 * Copyright (C) 2013 sh0 <sh0@yutani.ee>

 * Licensed under Creative Commons BY-SA 3.0

 */

package se.fekete.furiganatextview.furiganaview

// Constraint optimizer class

class QuadraticOptimizer(private var a: Array<FloatArray>, private var b: FloatArray) {

    // Calculate

    fun calculate(x: FloatArray) {

        // Check if calculation needed

        if (phi(1.0f, x) == 0.0f) {

            return

        }

        // Calculate

        var sigma = 1.0f

        for (k in 0 until penaltyRuns) {

            newtonSolve(x, sigma)

            sigma *= sigmaMul

        }

    }

    private fun newtonSolve(x: FloatArray, sigma: Float) {

        for (i in 0 until newtonRuns) {

            newtonIteration(x, sigma)

        }

    }

    private fun newtonIteration(x: FloatArray, sigma: Float) {

        // Calculate gradient

        val d = FloatArray(x.size)

        for (i in d.indices) {

            d[i] = phiD1(i, sigma, x)

        }

        // Calculate Hessian matrix (symmetric)

        val h = Array(x.size) { FloatArray(x.size) }

        for (i in h.indices) {

            for (j in i until h[0].size) {

                h[i][j] = phiD2(i, j, sigma, x)

            }

        }

        for (i in h.indices) {

            for (j in 0 until i) {

                h[i][j] = h[j][i]

            }

        }

        // Linear system solver

        val p = gsSolver(h, d)

        // Iteration

        for (i in x.indices) {

            x[i] = x[i] - wolfeGamma * p[i]

        }

    }

    // Gauss-Seidel solver

    private fun gsSolver(a: Array<FloatArray>, b: FloatArray): FloatArray {

        // Initial guess

        val p = FloatArray(b.size)

        for (i in p.indices) {

            p[i] = 1.0f

        }

        for (z in 0 until gsRuns) {

            for (i in p.indices) {

                var s = 0.0f

                for (j in p.indices) {

                    if (i != j) {

                        s += a[i][j] * p[j]

                    }

                }

                p[i] = (b[i] - s) / a[i][i]

            }

        }

        // Result

        return p

    }

    // Math

    private fun dot(a: FloatArray, b: FloatArray): Float {

        assert(a.size == b.size)

        var r = 0.0f

        for (i in a.indices) {

            r += a[i] * b[i]

        }

        return r

    }

    // Cost function f(x)

    private fun f(x: FloatArray): Float {

        return dot(x, x)

    }

    // Cost function phi(x)

    private fun phi(sigma: Float, x: FloatArray): Float {

        var r = 0.0f

        for (i in x.indices) {

            r += Math.pow(Math.min(0f, dot(a[i], x) - b[i]).toDouble(), 2.0).toFloat()

        }

        return f(x) + sigma * r

    }

    private fun phiD1(n: Int, sigma: Float, x: FloatArray): Float {

        var r = 0.0f

        for (i in a.indices) {

            val c = dot(a[i], x) - b[i]

            if (c < 0) {

                r += 2.0f * a[i][n] * c

            }

        }

        return 2.0f * x[n] + sigma * r

    }

    private fun phiD2(n: Int, m: Int, sigma: Float, x: FloatArray): Float {

        var r = 0.0f

        for (i in a.indices) {

            val c = dot(a[i], x) - b[i]

            if (c < 0) {

                r += 2.0f * a[i][n] * a[i][m]

            }

        }

        return (if (n == m) 2.0f else 0.0f) + sigma * r

    }

    companion object {

        // Constants

        internal const val wolfeGamma = 0.1f

        internal const val sigmaMul = 10.0f

        internal const val penaltyRuns = 5

        internal const val newtonRuns = 20

        internal const val gsRuns = 20

    }

}

package se.fekete.furiganatextview.furiganaview

import android.graphics.Paint

import java.util.*

internal class Span {

    // Text

    private var furigana: TextFurigana? = null

    private var normal = Vector<TextNormal>()

    // Widths

    private val widthChars = Vector<Float>()

    private var widthTotal = 0.0f

    // Constructors

    constructor(textF: String, textK: String, markS: Int, markE: Int, paint: Paint, paintF: Paint) {

        var mutableMarkS = markS

        var mutableMarkE = markE

        // Furigana text

        if (textF.isNotEmpty()) {

            furigana = TextFurigana(textF, paintF)

        }

        // Normal text

        if (mutableMarkS < textK.length && mutableMarkE > 0 && mutableMarkS < mutableMarkE) {

            // Fix marked bounds

            mutableMarkS = Math.max(0, mutableMarkS)

            mutableMarkE = Math.min(textK.length, mutableMarkE)

            // Prefix

            if (mutableMarkS > 0) {

                normal.add(TextNormal(textK.substring(0, mutableMarkS), paint))

            }

            // Marked

            if (mutableMarkE > mutableMarkS) {

                normal.add(TextNormal(textK.substring(mutableMarkS, mutableMarkE), paint))

            }

            // Postfix

            if (mutableMarkE < textK.length) {

                normal.add(TextNormal(textK.substring(mutableMarkE), paint))

            }

        } else {

            // Non marked

            normal.add(TextNormal(textK, paint))

        }

        // Widths

        calculateWidths()

    }

    constructor(normal: Vector<TextNormal>) {

        // Only normal text

        this.normal = normal

        // Widths

        calculateWidths()

    }

    // Text

    fun furigana(x: Float): TextFurigana? {

        if (furigana == null) {

            return null

        }

        furigana?.setOffset(x + widthTotal / 2.0f)

        return furigana

    }

    fun normal(): Vector<TextNormal> {

        return normal

    }

    // Widths

    fun widths(): Vector<Float> {

        return widthChars

    }

    private fun calculateWidths() {

        // Chars

        if (furigana == null) {

            for (normal in normal) {

                for (v in normal.charsWidth()) {

                    widthChars.add(v)

                }

            }

        } else {

            var sum = 0.0f

            for (normal in normal) {

                for (v in normal.charsWidth()) {

                    sum += v

                }

            }

            widthChars.add(sum)

        }

        // Total

        widthTotal = 0.0f

        for (v in widthChars) {

            widthTotal += v

        }

    }

    // Split

    fun split(offset: Int, normalA: Vector<TextNormal>, normalB: Vector<TextNormal>) {

        var mutableOffset = offset

        // Check if no furigana

        if (furigana == null) {

            return

        }

        // Split normal list

        for (cur in normal) {

            when {

                mutableOffset <= 0 -> normalB.add(cur)

                mutableOffset >= cur.length() -> normalA.add(cur)

                else -> {

                    val split = cur.split(mutableOffset)

                    normalA.add(split[0])

                    normalB.add(split[1])

                }

            }

            mutableOffset -= cur.length()

        }

    }

}

package se.fekete.furiganatextview.furiganaview

import android.graphics.Canvas

import android.graphics.Paint

class TextFurigana(private val text: String, private val paintF: Paint) {

    // Coordinates

    private var offset = 0.0f

    private var width = 0.0f

    init {

        width = paintF.measureText(text)

    }

    fun getOffset(): Float {

        return offset

    }

    fun setOffset(value: Float) {

        offset = value

    }

    fun width(): Float {

        return width

    }

    fun draw(canvas: Canvas, x: Float, y: Float) {

        var mutableX = x

        mutableX -= width / 2.0f

        canvas.drawText(text, 0, text.length, mutableX, y, paintF)

    }

}

package se.fekete.furiganatextview.furiganaview

import android.graphics.Canvas

import android.graphics.Paint

class TextNormal(private val text: String, private val paint: Paint) {

    private var totalWidth: Float = 0.toFloat()

    private val charsWidth: FloatArray = FloatArray(text.length)

    init {

        paint.getTextWidths(text, charsWidth)

        // Total width

        totalWidth = 0.0f

        for (v in charsWidth)

            totalWidth += v

    }

    // Info

    fun length(): Int {

        return text.length

    }

    // Widths

    fun charsWidth(): FloatArray {

        return charsWidth

    }

    // Split

    fun split(offset: Int): Array<TextNormal> {

        return arrayOf(TextNormal(text.substring(0, offset), paint), TextNormal(text.substring(offset), paint))

    }

    // Draw

    fun draw(canvas: Canvas, x: Float, y: Float): Float {

        canvas.drawText(text, 0, text.length, x, y, paint)

        return totalWidth

    }

}

package se.fekete.furiganatextview.utils;

@Deprecated

public class FuriganaUtils {

    /**

     * The method parseRuby converts kanji enclosed in ruby tags to the

     * format which is supported by the textview {Kanji:furigana}

     *

     * @param textWithRuby

     * @deprecated Use the set{@link se.fekete.furiganatextview.furiganaview.FuriganaTextView}

     */

    public static String parseRuby(String textWithRuby) {

        String parsed = textWithRuby.replace("<ruby>", "{");

        parsed = parsed.replace("<rt>", ";");

        parsed = parsed.replace("</rt>", "");

        return parsed.replace("</ruby>", "}");

    }

}

<?xml version="1.0" encoding="utf-8"?>

<resources>

    <declare-styleable name="FuriganaTextView">

        <attr name="contains_ruby_tags" format="boolean"/>

        <attr name="furigana_text_color" format="color"/>

    </declare-styleable>

</resources>

<resources>

    <string name="app_name">FuriganaTextView</string>

</resources>

package eu.lepiller.furiganatextview;

import org.junit.Test;

import static org.junit.Assert.*;

/**

 * Example local unit test, which will execute on the development machine (host).

 *

 * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>

 */

public class ExampleUnitTest {

    @Test

    public void addition_isCorrect() {

        assertEquals(4, 2 + 2);

    }

}

package se.fekete.furiganatextview;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

/**

 * To work on unit tests, switch the Test Artifact in the Build Variants view.

 */

public class ExampleUnitTest {

    @Test

    public void addition_isCorrect() {

        assertEquals(4, 2 + 2);

    }

}