Justifying text in Android

Question

I need to justify some text (RTL), which is a string (S1) from the server. But a TextView can't justify text, so I have to use a WebView, now I have to create a HTML file in which will display S1. And then I store the address of that html file in the database and then I display that html file. I've seen this question asked before on SO and many have recommended to use a 3rd party library, I've tried all of those approaches to no avail (they work in 90% of scenarios but are no fully reliable).

I feel that this approach seems convoluted, I was wondering if there is a better approach?

Answer 1

Try this:

Add a TextViewJustify.java file in src folder.

TextViewJustify.java wil be like this

import android.graphics.Paint;
import android.view.Gravity;
import android.widget.TextView;

public class TextViewJustify {

    /*
     * PLEASE DO NOT REMOVE Coded by Mathew Kurian I wrote this code for a
     * Google Interview for Internship. Unfortunately, I got too nervous during
     * the interview that I messed, but anyhow that doesn't matter. I have
     * resent my work in hopes that I might still get a position there. Thank
     * you :DD
     */

    final static String SYSTEM_NEWLINE = "\n";
    final static float COMPLEXITY = 5.12f; // Reducing this will increase
                                            // efficiency but will decrease
                                            // effectiveness
    final static Paint p = new Paint();

    public static void justifyText(final TextView tv, final float origWidth) {
        String s = tv.getText().toString();
        p.setTypeface(tv.getTypeface());
        String[] splits = s.split(SYSTEM_NEWLINE);
        float width = origWidth - 5;
        for (int x = 0; x < splits.length; x++)
            if (p.measureText(splits[x]) > width) {
                splits[x] = wrap(splits[x], width, p);
                String[] microSplits = splits[x].split(SYSTEM_NEWLINE);
                for (int y = 0; y < microSplits.length - 1; y++)
                    microSplits[y] = justify(removeLast(microSplits[y], " "),
                            width, p);
                StringBuilder smb_internal = new StringBuilder();
                for (int z = 0; z < microSplits.length; z++)
                    smb_internal.append(microSplits[z]
                            + ((z + 1 < microSplits.length) ? SYSTEM_NEWLINE
                                    : ""));
                splits[x] = smb_internal.toString();
            }
        final StringBuilder smb = new StringBuilder();
        for (String cleaned : splits)
            smb.append(cleaned + SYSTEM_NEWLINE);
        tv.setGravity(Gravity.LEFT);
        tv.setText(smb);
    }

    private static String wrap(String s, float width, Paint p) {
        String[] str = s.split("\\s"); // regex
        StringBuilder smb = new StringBuilder(); // save memory
        smb.append(SYSTEM_NEWLINE);
        for (int x = 0; x < str.length; x++) {
            float length = p.measureText(str[x]);
            String[] pieces = smb.toString().split(SYSTEM_NEWLINE);
            try {
                if (p.measureText(pieces[pieces.length - 1]) + length > width)
                    smb.append(SYSTEM_NEWLINE);
            } catch (Exception e) {
            }
            smb.append(str[x] + " ");
        }
        return smb.toString().replaceFirst(SYSTEM_NEWLINE, "");
    }

    private static String removeLast(String s, String g) {
        if (s.contains(g)) {
            int index = s.lastIndexOf(g);
            int indexEnd = index + g.length();
            if (index == 0)
                return s.substring(1);
            else if (index == s.length() - 1)
                return s.substring(0, index);
            else
                return s.substring(0, index) + s.substring(indexEnd);
        }
        return s;
    }

    private static String justifyOperation(String s, float width, Paint p) {
        float holder = (float) (COMPLEXITY * Math.random());
        while (s.contains(Float.toString(holder)))
            holder = (float) (COMPLEXITY * Math.random());
        String holder_string = Float.toString(holder);
        float lessThan = width;
        int timeOut = 100;
        int current = 0;
        while (p.measureText(s) < lessThan && current < timeOut) {
            s = s.replaceFirst(" ([^" + holder_string + "])", " "
                    + holder_string + "$1");
            lessThan = p.measureText(holder_string) + lessThan
                    - p.measureText(" ");
            current++;
        }
        String cleaned = s.replaceAll(holder_string, " ");
        return cleaned;
    }

    private static String justify(String s, float width, Paint p) {
        while (p.measureText(s) < width) {
            s = justifyOperation(s, width, p);
        }
        return s;
    }
}

And use this class like this:

TextViewJustify.justifyText(your_text_view, 225f);

In my case it was 225f. change it according to your need.

Answer 2

i made simple class.
this can be used just like TextView

import android.content.Context;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.widget.TextView;

/**
 * text justifying
 * you can just use like TextView
 * @author hyunsikkim
 *
 */
public class JustifiedTextView extends TextView {

public JustifiedTextView(Context context) {
    super(context);
}

public JustifiedTextView(Context context, AttributeSet attrs) {
    super(context, attrs);
}

private void setBreakText(String text) {
    if(text == null) return;

    String breakText = breakText(getPaint(), text, 
            getWidth()-this.getPaddingLeft()-this.getPaddingRight());

    if(breakText.equals(getText()) == false) {
        setText(breakText);
    }
}

public String breakText(Paint textPaint, String strText, int breakWidth) { 
    StringBuilder sb = new StringBuilder(); 
    int endValue = 0; 
    final String NEW_LINE = "\n";
    do{ 
        endValue = textPaint.breakText(strText, true, breakWidth, null); 
        if(endValue > 0) {
            /**
             * handle if text contains NEW_LINE
             */
            final int index = strText.indexOf(NEW_LINE);
            if(0<=index && index <= endValue) {
                endValue = index + NEW_LINE.length();
            }
            final String sub = strText.substring(0, endValue);
            sb.append(sub);
            /**
             * handle breaked text endWidth NEW_LINE
             */
            if(sub.endsWith(NEW_LINE) == false) {
                if(strText.length() != endValue) {
                    sb.append(NEW_LINE);
                }
            }

            strText = strText.substring(endValue); 
        } 
    } while(endValue > 0);
    return sb.toString();
} 

public String breakText(Paint textPaint, int id, int breakWidth) {
    String strText = getResources().getString(id);
    return breakText(textPaint, strText, breakWidth);
}

@Override
protected void onTextChanged(CharSequence text, int start,
        int lengthBefore, int lengthAfter) {
    super.onTextChanged(text, start, lengthBefore, lengthAfter);
    /**
     * this control changes from setText(Charsequence text)
     */
    if(getWidth() != 0) {
        setBreakText(text.toString());
    }
}

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);
    /**
     * this help to break initial text.
     */
    if(w != oldw) {
        setBreakText(getText().toString());
    }
}


}

Answer 3

You can justify Text using WebView Simply

LinearLayout lv=(LinearLayout)dialog.findViewById(R.id.**yourId**);


                     String text1 = "<html><body>"
                                + "<p align=\"justify\">"                
                                   +**your text**
                                + "</p> "
                                + "</body></html>";



                     WebView wv=new WebView(getApplicationContext());
                     wv.loadData(text1,"text/html","utf-8");



                    lv.removeAllViews();

                    lv.addView(wv);

Answer 4

Use web view

  WebView tv = (WebView) findViewById(R.id.aboutme); 
  String youtContentStr = String.valueOf(Html
                        .fromHtml("<![CDATA[<body style=\"text-align:justify;background-color:#00222222;\">"
                                    + text
                                    + "</body>]]>"));

  tv.setBackgroundColor(Color.TRANSPARENT);
  tv.loadData(youtContentStr, "text/html", "utf-8");`

Answer 5

I use the following code that answer with very people that need this subject and i create formula that support in every display.

    public class TextJustify {

final static String SYSTEM_NEWLINE = "\n";
final static float COMPLEXITY = 5.12f; // Reducing this will increase
                                        // efficiency but will decrease
                                        // effectiveness
final static Paint p = new Paint();

/* @author Mathew Kurian */

public static void run(final TextView tv, float origWidth, int paddingLeft, int paddingRight, int marginLeft, int marginRight) {


    origWidth-= paddingRight+marginRight+paddingLeft+marginLeft;
    String s = tv.getText().toString();
    p.setTypeface(tv.getTypeface());
    String[] splits = s.split(SYSTEM_NEWLINE);
    float width = origWidth - 5;
    for (int x = 0; x < splits.length; x++)
        if (p.measureText(splits[x]) > width) {
            splits[x] = wrap(splits[x], width, p);
            String[] microSplits = splits[x].split(SYSTEM_NEWLINE);
            for (int y = 0; y < microSplits.length - 1; y++)
                microSplits[y] = justify(removeLast(microSplits[y], " "),
                        width, p);
            StringBuilder smb_internal = new StringBuilder();
            for (int z = 0; z < microSplits.length; z++)
                smb_internal.append(microSplits[z]
                        + ((z + 1 < microSplits.length) ? SYSTEM_NEWLINE
                                : ""));
            splits[x] = smb_internal.toString();
        }
    final StringBuilder smb = new StringBuilder();
    for (String cleaned : splits)
        smb.append(cleaned + SYSTEM_NEWLINE);
    tv.setGravity(Gravity.RIGHT);
    tv.setText(smb);
}

private static String wrap(String s, float width, Paint p) {
    String[] str = s.split("\\s"); // regex
    StringBuilder smb = new StringBuilder(); // save memory
    smb.append(SYSTEM_NEWLINE);
    for (int x = 0; x < str.length; x++) {
        float length = p.measureText(str[x]);
        String[] pieces = smb.toString().split(SYSTEM_NEWLINE);
        try {
            if (p.measureText(pieces[pieces.length - 1]) + length > width)
                smb.append(SYSTEM_NEWLINE);
        } catch (Exception e) {
        }
        smb.append(str[x] + " ");
    }
    return smb.toString().replaceFirst(SYSTEM_NEWLINE, "");
}

private static String removeLast(String s, String g) {
    if (s.contains(g)) {
        int index = s.lastIndexOf(g);
        int indexEnd = index + g.length();
        if (index == 0)
            return s.substring(1);
        else if (index == s.length() - 1)
            return s.substring(0, index);
        else
            return s.substring(0, index) + s.substring(indexEnd);
    }
    return s;
}

private static String justifyOperation(String s, float width, Paint p) {
    float holder = (float) (COMPLEXITY * Math.random());
    while (s.contains(Float.toString(holder)))
        holder = (float) (COMPLEXITY * Math.random());
    String holder_string = Float.toString(holder);
    float lessThan = width;
    int timeOut = 100;
    int current = 0;
    while (p.measureText(s) < lessThan && current < timeOut) {
        s = s.replaceFirst(" ([^" + holder_string + "])", " "
                + holder_string + "$1");
        lessThan = p.measureText(holder_string) + lessThan
                - p.measureText(" ");
        current++;
    }
    String cleaned = s.replaceAll(holder_string, " ");
    return cleaned;
}

private static String justify(String s, float width, Paint p) {
    while (p.measureText(s) < width) {
        s = justifyOperation(s, width, p);
    }
    return s;
}
  }

and for calling this you mus use following code, I tested for Persian language and in every display and device worked fine.

     public static final int FinallwidthDp  = 320 ;
     public static final int widthJustify  = 223 ;

     DisplayMetrics metrics = new DisplayMetrics();
     getWindowManager().getDefaultDisplay().getMetrics(metrics);
     int widthPixels = metrics.widthPixels;

     float scaleFactor = metrics.density;
     float widthDp = widthPixels / scaleFactor;

     TextView tv = (TextView) findViewById(R.id.textView1);
     ViewGroup.MarginLayoutParams lp1 = (ViewGroup.MarginLayoutParams) tv.getLayoutParams();

     tv.setText(text);
     TextJustify.run(tv,widthDp / FinallwidthDp * widthJustify , tv.getPaddingLeft(),tv.getPaddingRight() , lp1.leftMargin, lp1.rightMargin);

this algorithm tested on various device and worked fine in normal activity (not dialog) and wrap-content width for TextView, and worked with every padding and margin.if not good for you, you can change widthJustify until look good to you, I hope this useful. for newly update see This

Answer 6

LIBRARY: https://github.com/bluejamesbond/TextJustify-Android

SUPPORTS: Android 2.0 to 5.X; String/Spannables; RTL language support! NO WEBVIEW :)

SCREENSHOT