cr 1

Author: scrinoman

omegatypes/src/main/java/com/omega_r/libs/omegatypes/LeakyTypefaceStorageCompat.kt

@@ -0,0 +1,56 @@
+package com.omega_r.libs.omegatypes
+
+import android.graphics.Typeface
+import android.os.Parcel
+import android.os.Process
+import java.util.ArrayList
+
+object LeakyTypefaceStorageCompat {
+
+    private val lock = Any()
+
+    private val storage = ArrayList<Typeface>()
+
+    /**
+     * Write typeface to parcel.
+     *
+     * You can't transfer Typeface to a different process. [readTypefaceFromParcel] will
+     * return `null` if the [readTypefaceFromParcel] is called in a different process.
+     *
+     * @param typeface A [Typeface] to be written.
+     * @param parcel A [Parcel] object.
+     */
+    fun writeTypefaceToParcel(typeface: Typeface, parcel: Parcel) {
+        parcel.writeInt(Process.myPid())
+        synchronized(lock) {
+            val id: Int
+            val i = storage.indexOf(typeface)
+            if (i != -1) {
+                id = i
+            } else {
+                id = storage.size
+                storage.add(typeface)
+            }
+            parcel.writeInt(id)
+        }
+    }
+
+    /**
+     * Read typeface from parcel.
+     *
+     * If the [Typeface] was created in another process, this method returns null.
+     *
+     * @param parcel A [Parcel] object
+     * @return A [Typeface] object.
+     */
+    fun readTypefaceFromParcel(parcel: Parcel): Typeface? {
+        val pid = parcel.readInt()
+        val typefaceId = parcel.readInt()
+        if (pid != Process.myPid()) {
+            return null  // The Typeface was created and written in another process.
+        }
+        synchronized(lock) {
+            return storage[typefaceId]
+        }
+    }
+}

omegatypes/src/main/java/com/omega_r/libs/omegatypes/TextStyle.kt

@@ -42,13 +42,13 @@ abstract class TextStyle : Serializable {
         fun strikethrough(): TextStyle = strikethroughTextStyle
 
         @JvmStatic
-        fun font(fontName: Text): TextStyle = FontTextStyle(fontNameText = fontName)
+        fun font(fontName: Text): TextStyle = NameFontTextStyle(fontNameText = fontName)
 
         @JvmStatic
-        fun font(fontName: String): TextStyle = FontTextStyle(fontNameText = fontName.toText())
+        fun font(fontName: String): TextStyle = NameFontTextStyle(fontNameText = fontName.toText())
 
         @JvmStatic
-        fun font(typeface: Typeface): TextStyle = FontTextStyle(fontTypeface = typeface)
+        fun font(typeface: Typeface): TextStyle = TypefaceFontTextStyle(fontTypeface = typeface)
 
         @JvmStatic
         fun size(size: Size): TextStyle = SizeTextStyle(size)
@@ -118,23 +118,20 @@ abstract class TextStyle : Serializable {
         }
     }
 
-    private class FontTextStyle(
-            private val fontNameText: Text? = null,
-            private val fontTypeface: Typeface? = null
-    ) : TextStyle() {
+    private class NameFontTextStyle(private val fontNameText: Text) : TextStyle() {
 
         override fun SpannableString.applyStyle(context: Context) {
-            setSpan(createSpan(context), 0, length, 0)
+            fontNameText.getString(context)?.let {
+                setSpan(TypefaceSpan(it), 0, length, 0)
+            }
         }
 
-        private fun createSpan(context: Context): Any {
-            if (fontTypeface != null) {
-                return StyleSpan(fontTypeface.style)
-            }
-            fontNameText?.getString(context)?.let {
-                return TypefaceSpan(it)
-            }
-            throw IllegalStateException()
+    }
+
+    private class TypefaceFontTextStyle(private val fontTypeface: Typeface) : TextStyle() {
+
+        override fun SpannableString.applyStyle(context: Context) {
+            setSpan(TypefaceSpanCompat(typeface = fontTypeface), 0, length, 0)
         }
 
     }

omegatypes/src/main/java/com/omega_r/libs/omegatypes/TypefaceSpanCompat.kt

@@ -0,0 +1,69 @@
+package com.omega_r.libs.omegatypes
+
+import android.graphics.Paint
+import android.graphics.Typeface
+import android.os.Parcel
+import android.text.ParcelableSpan
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+import android.text.style.TypefaceSpan
+
+class TypefaceSpanCompat(
+        var family: String? = null,
+        var typeface: Typeface? = null) : MetricAffectingSpan(), ParcelableSpan {
+
+    companion object {
+        private const val SPAN_TYPE_ID = 13
+    }
+
+    /**
+     * Constructs a [TypefaceSpan] from a  parcel.
+     */
+    constructor(src: Parcel) : this(family = src.readString(), typeface = LeakyTypefaceStorageCompat.readTypefaceFromParcel(src))
+
+    override fun getSpanTypeId(): Int {
+        return SPAN_TYPE_ID
+    }
+
+    override fun describeContents(): Int {
+        return 0
+    }
+
+    override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeString(family)
+        typeface?.let { LeakyTypefaceStorageCompat.writeTypefaceToParcel(it, dest) }
+    }
+
+    override fun updateDrawState(ds: TextPaint) {
+        updateTypeface(ds)
+    }
+
+    override fun updateMeasureState(paint: TextPaint) {
+        updateTypeface(paint)
+    }
+
+    private fun updateTypeface(paint: Paint) {
+        if (typeface != null) {
+            paint.typeface = typeface
+        } else if (family != null) {
+            applyFontFamily(paint, family!!)
+        }
+    }
+
+    private fun applyFontFamily(paint: Paint, family: String) {
+        val style: Int
+        val old = paint.typeface
+        style = old?.style ?: Typeface.NORMAL
+        val styledTypeface = Typeface.create(family, style)
+        val fake = style and styledTypeface.style.inv()
+
+        if (fake and Typeface.BOLD != 0) {
+            paint.isFakeBoldText = true
+        }
+
+        if (fake and Typeface.ITALIC != 0) {
+            paint.textSkewX = -0.25f
+        }
+        paint.typeface = styledTypeface
+    }
+}