Keywords: Android | TextView | Text Justification | Full Justification | justificationMode | WebView | Custom View
Abstract: This article provides an in-depth exploration of the technical evolution of TextView text justification on the Android platform, from the lack of native support in early versions to the complete solution introduced in Android 8.0+. By analyzing the evolution of official APIs, implementation principles of third-party libraries, and WebView alternatives, it offers comprehensive code examples and best practice guidelines to help developers choose the most suitable implementation based on target API levels.
Overview of Android Text Alignment Technology Development
In Android application development, the aesthetics and readability of text layout have always been crucial components of user experience. Text justification, as a common typesetting requirement, has undergone a technological evolution on the Android platform from non-existence to full support. Early Android versions lacked native support, forcing developers to seek various alternative solutions until Android 8.0 (API level 26) officially introduced comprehensive justification functionality.
Native Support in Android 8.0+
With the release of Android 8.0, Google formally added the justificationMode property to the TextView component, providing developers with native text justification support. This property supports two modes: JUSTIFICATION_MODE_NONE (default value, no justification) and JUSTIFICATION_MODE_INTER_WORD (inter-word justification).
Implementation in Kotlin:
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
textView.justificationMode = JUSTIFICATION_MODE_INTER_WORD
}Corresponding Java implementation:
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
textView.setJustificationMode(JUSTIFICATION_MODE_INTER_WORD);
}Direct configuration in XML layout files:
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:justificationMode="inter_word" />Alternative Solutions for Early Android Versions
For applications requiring support for Android versions prior to 8.0, developers need to adopt other technical approaches to achieve text justification.
WebView Approach
Using WebView combined with HTML/CSS represents a traditional method for achieving text justification. By setting the text-align: justify style in HTML content, justification effects can be easily implemented.
WebView view = new WebView(this);
view.setVerticalScrollBarEnabled(false);
((LinearLayout)findViewById(R.id.inset_web_view)).addView(view);
view.loadData(getString(R.string.hello), "text/html; charset=utf-8", "utf-8");Corresponding HTML content definition:
<string name="hello">
<![CDATA[
<html>
<head></head>
<body style="text-align:justify;color:gray;background-color:black;">
Lorem ipsum dolor sit amet, consectetur
adipiscing elit. Nunc pellentesque, urna
nec hendrerit pellentesque, risus massa
</body>
</html>
]]>
</string>Custom TextView Approach
Third-party libraries like TextJustify-Android provide custom TextView implementations that achieve justification by extending the native TextView class and overriding text drawing logic. This approach maintains all native TextView characteristics while adding justification functionality.
Implementation using custom TextViewEx:
<yourpackagename.TextViewEx
android:id="@+id/changed"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/lorum_ipsum" />Enabling justification in code:
TextViewEx changed = (TextViewEx) findViewById(R.id.changed);
changed.setText(getResources().getString(R.string.lorum_ipsum), true);Distinction Between Text Alignment and Layout Alignment
In Android development, it is essential to clearly distinguish between text alignment (gravity) and layout alignment (layout_gravity). Text alignment controls how text is arranged within the TextView, while layout alignment controls the TextView's position within its parent container.
Example of right-aligned text implementation:
<TextView
android:layout_gravity="center_vertical|end"
android:gravity="end" />This configuration aligns the TextView to the right within its parent container while also right-aligning the text content within the TextView.
Technical Selection Recommendations
When choosing a text justification solution, developers should consider the following factors:
Target API Level: If the application's minimum supported API level is 26 (Android 8.0), it is recommended to directly use the native justificationMode property for optimal performance and compatibility.
Performance Considerations: The native solution offers the best performance, while the WebView approach introduces additional memory overhead and rendering costs. Custom TextView solutions typically provide performance between these two extremes.
Maintenance Costs: The native solution is maintained by Google officially, ensuring the best long-term stability. Third-party libraries require attention to their update frequency and community activity.
Functional Requirements: Custom TextView solutions generally offer better flexibility if complex text styling (such as Spannable) support is required.
Implementation Details and Best Practices
In practical development, the following technical details should be considered when implementing text justification:
Version Compatibility Handling: Use version checks to ensure code runs correctly across different Android versions:
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
// Use native justification
textView.justificationMode = JUSTIFICATION_MODE_INTER_WORD
} else {
// Fallback to alternative solutions
applyLegacyJustification(textView)
}Text Measurement and Layout: Justification requires precise text measurement and layout calculations. In custom implementations, it is typically necessary to override the onDraw() method and text measurement logic to ensure accurate positioning of each character.
Multi-language Support: Text justification rules may vary across different languages. Special handling is particularly required for right-to-left (RTL) languages regarding alignment direction.
Performance Optimization: For scenarios involving large amounts of text or frequent updates, text caching implementations should be considered to avoid repeated justification position calculations.
Future Outlook
With the continuous development of the Android platform, text rendering and layout technologies are also advancing. Material Design 3 introduces richer text styles and layout options, and future updates may incorporate more advanced text alignment and typesetting functionalities into the Android framework.
Developers should continuously monitor developments in Android official documentation and modern UI frameworks like Jetpack Compose, as these new technologies may provide more concise and powerful text layout solutions.