Combined font file names to font family names,

changed to store the font family name instead of the font file path (as it was before the previous commit),
 added reading of existing system font files with file extension .otf (i.e., additionally to .ttf)

app/src/main/java/om/sstvencoder/EditTextActivity.java

@@ -37,7 +37,6 @@ import android.widget.CheckBox;
 import android.widget.EditText;
 import android.widget.Spinner;
 
-import java.util.ArrayList;
 import java.util.List;
 
 import om.sstvencoder.TextOverlay.Label;
@@ -55,7 +54,7 @@ public class EditTextActivity extends AppCompatActivity
     public static final String EXTRA = "EDIT_TEXT_EXTRA";
     private Label mLabel;
     private EditColorMode mEditColor;
-    private List<String> mFontFilePathList;
+    private List<String> mFontFamilyNameList;
     private CheckBox mEditItalic, mEditBold, mEditOutline;
     private int mClearTextButtonWidth;
 
@@ -148,20 +147,10 @@ public class EditTextActivity extends AppCompatActivity
     private void initFontFamilySpinner(String familyName) {
         Spinner spinner = findViewById(R.id.edit_font_family);
         spinner.setOnItemSelectedListener(this);
-        mFontFilePathList = Utility.getSystemFontFilePaths();
+        mFontFamilyNameList = Utility.getSystemFontFamilyList();
-        mFontFilePathList.add(0, Label.DEFAULT_FONT);
-        List<String> fontFamilyNameList = getFontNames(mFontFilePathList);
         spinner.setAdapter(new ArrayAdapter<>(this,
-                android.R.layout.simple_spinner_dropdown_item, fontFamilyNameList));
+                android.R.layout.simple_spinner_dropdown_item, mFontFamilyNameList));
-        spinner.setSelection(mFontFilePathList.indexOf(familyName));
+        spinner.setSelection(mFontFamilyNameList.indexOf(familyName));
-    }
-
-    private static List<String> getFontNames(List<String> fontFilePathList) {
-        List<String> fontNameList = new ArrayList<>();
-        for (String path : fontFilePathList) {
-            fontNameList.add(Utility.getFileNameWithoutExtension(path));
-        }
-        return fontNameList;
     }
 
     private void initTextSizeSpinner(float textSize) {
@@ -227,7 +216,7 @@ public class EditTextActivity extends AppCompatActivity
             mLabel.setOutlineSize(positionToOutlineSize(position));
         }
         else if (parentId == R.id.edit_font_family) {
-            mLabel.setFamilyName(mFontFilePathList.get(position));
+            mLabel.setFamilyName(mFontFamilyNameList.get(position));
         }
     }
 

app/src/main/java/om/sstvencoder/TextOverlay/Label.java

@@ -24,7 +24,6 @@ import java.lang.reflect.Modifier;
 public class Label implements Serializable {
     public static final float TEXT_SIZE_NORMAL = 2f;
     public static final float OUTLINE_SIZE_NORMAL = 0.05f;
-    public static final String DEFAULT_FONT = "Default";
     private String mText;
     private float mTextSize, mOutlineSize;
     private String mFamilyName;

app/src/main/java/om/sstvencoder/TextOverlay/LabelPainter.java

@@ -23,9 +23,8 @@ import android.graphics.Rect;
 import android.graphics.RectF;
 import android.graphics.Typeface;
 
-import java.io.File;
-
 import androidx.annotation.NonNull;
+import om.sstvencoder.Utility;
 
 class LabelPainter {
     private interface IDrawer {
@@ -134,10 +133,7 @@ class LabelPainter {
         private void setPaintSettings(float sizeFactor) {
             mPaint.setAlpha(255);
             try {
-                Typeface tf = Typeface.create(
+                mPaint.setTypeface(createTypeface());
-                        createTypefaceFromFontFile(),
-                        createTypefaceFromFontAttributes());
-                mPaint.setTypeface(tf);
             } catch (Exception ignore) {
             }
             setTextPaintSettings();
@@ -160,30 +156,22 @@ class LabelPainter {
             mPaint.setStrokeWidth(mLabel.getOutlineSize() * textSize);
         }
 
-        private Typeface createTypefaceFromFontFile() {
+        private Typeface createTypeface() {
-            Typeface typeface = null; // Typeface.DEFAULT
+            int style = Typeface.NORMAL;
-            String fontFilePath = mLabel.getFamilyName();
-
-            if (!fontFilePath.equalsIgnoreCase(Label.DEFAULT_FONT)) {
-                File fontFile = new File(fontFilePath);
-                if (fontFile.exists() && fontFile.canRead())
-                    typeface = Typeface.createFromFile(fontFilePath);
-            }
-            return typeface;
-        }
-
-        private int createTypefaceFromFontAttributes() {
-            int typeface = Typeface.NORMAL;
 
             if (mLabel.getBold() && mLabel.getItalic())
-                typeface = Typeface.BOLD_ITALIC;
+                style = Typeface.BOLD_ITALIC;
             else {
                 if (mLabel.getBold())
-                    typeface = Typeface.BOLD;
+                    style = Typeface.BOLD;
                 else if (mLabel.getItalic())
-                    typeface = Typeface.ITALIC;
+                    style = Typeface.ITALIC;
             }
-            return typeface;
+
+            String fontFilePath = Utility.getFontFilePath(mLabel.getFamilyName(), style);
+            Typeface family = Typeface.createFromFile(fontFilePath);
+
+            return Typeface.create(family, style);
         }
     }
 

app/src/main/java/om/sstvencoder/Utility.java

@@ -18,7 +18,10 @@ package om.sstvencoder;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.Rect;
+
 import androidx.exifinterface.media.ExifInterface;
+
+import android.graphics.Typeface;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Environment;
@@ -33,8 +36,9 @@ import java.util.Date;
 import java.util.List;
 import java.util.Locale;
 
-final class Utility {
+public final class Utility {
-    static final String DIRECTORY_SYSTEM_FONTS = "/system/fonts";
+    private static final String DIRECTORY_SYSTEM_FONTS = "/system/fonts";
+    private static final String DEFAULT_FONT_FAMILY = "Default";
 
     @NonNull
     static Rect getEmbeddedRect(int w, int h, int iw, int ih) {
@@ -118,31 +122,93 @@ final class Utility {
         return Environment.MEDIA_MOUNTED.equals(state);
     }
 
-    static List<String> getSystemFontFilePaths() {
+    static List<String> getSystemFontFamilyList() {
-        List<String> fontList = new ArrayList<>();
+        List<String> fontFamilyNameList = new ArrayList<>();
         File fontsDir = new File(DIRECTORY_SYSTEM_FONTS);
-        String fontFileExtension = ".ttf";
 
         if (fontsDir.exists() && fontsDir.isDirectory()) {
             File[] files = fontsDir.listFiles();
             if (files != null) {
                 for (File file : files) {
-                    if (file.isFile() && file.getName().endsWith(fontFileExtension)) {
+                    String fileName = file.getName();
-                        fontList.add(file.getAbsolutePath());
+                    if (file.isFile() && isSupportedFontFileFormat(fileName)) {
+                        String fontFamilyName = getFontFamilyName(fileName);
+                        if (!fontFamilyNameList.contains(fontFamilyName))
+                            fontFamilyNameList.add(fontFamilyName);
                     }
                 }
             }
         }
-        return fontList;
-    }
 
-    static String getFileNameWithoutExtension(String filePath) {
+        fontFamilyNameList.add(0, Utility.DEFAULT_FONT_FAMILY);
-        File file = new File(filePath);
+        return fontFamilyNameList;
-        String fileName = file.getName();
-        int dotIndex = fileName.lastIndexOf('.');
-        if (dotIndex > 0 && dotIndex < fileName.length() - 1) {
-            return fileName.substring(0, dotIndex);
     }
-        return fileName;
+
+    private static boolean isSupportedFontFileFormat(String fileName) {
+        return fileName.endsWith(".ttf") || fileName.endsWith(".otf");
+    }
+
+    private static String getFontFamilyName(String fileName) {
+        String fontFamilyName = fileName;
+        int lastIndex = fileName.length() - 1;
+
+        int charIndex = fileName.indexOf('-');
+        if (0 < charIndex && charIndex < lastIndex) {
+            fontFamilyName = fileName.substring(0, charIndex);
+        } else {
+            charIndex = fileName.lastIndexOf('.');
+            if (0 < charIndex && charIndex < lastIndex) {
+                fontFamilyName = fileName.substring(0, charIndex);
+            }
+        }
+        return fontFamilyName;
+    }
+
+    public static String getFontFilePath(String fontFamilyName, int style) {
+        List<String> fontFamilyFilePathList = getFontFamilyFilePathList(fontFamilyName);
+        String fontFilePath = fontFamilyFilePathList.get(0);
+
+        String styleString = getFontFileStyleString(style);
+        if (!styleString.isEmpty()) {
+            for (String path : fontFamilyFilePathList) {
+                if (path.contains(styleString)) {
+                    fontFilePath = path;
+                    break;
+                }
+            }
+        }
+        return fontFilePath;
+    }
+
+    private static List<String> getFontFamilyFilePathList(String fontFamilyName) {
+        List<String> fontFamilyFilePathList = new ArrayList<>();
+        File fontsDir = new File(DIRECTORY_SYSTEM_FONTS);
+
+        if (fontsDir.exists() && fontsDir.isDirectory()) {
+            File[] files = fontsDir.listFiles();
+            if (files != null) {
+                for (File file : files) {
+                    if (file.isFile()) {
+                        String path = file.getAbsolutePath();
+                        if (path.contains(fontFamilyName)) {
+                            fontFamilyFilePathList.add(path);
+                        }
+                    }
+                }
+            }
+        }
+        return fontFamilyFilePathList;
+    }
+
+    private static String getFontFileStyleString(int style) {
+        if (style == Typeface.NORMAL)
+            return "-Regular";
+        if (style == Typeface.BOLD_ITALIC)
+            return "-BoldItalic";
+        if (style == Typeface.BOLD)
+            return "-Bold";
+        if (style == Typeface.ITALIC)
+            return "-Italic";
+        return "";
     }
 }