• Latest Code...

    Featured Post

    Implementing Hilt in a Kotlin Android Jetpack Compose Project with MVVM Architecture

     In modern Android development, maintaining a scalable codebase can be challenging, especially when it comes to dependency management. Hilt,...

    Auto Realizable or Auto Fit TextView in android or android studio

    Displays text to the user and optionally allows them to edit it. A TextView is a complete text editor, however the basic class is configured to not allow editing; see EditText for a subclass that configures the text view for editing.

    Sometimes, we need auto fit textview, as required input value, Here is the simple tutorials for this.

    First method, you have to define layout file,

     <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
       android:layout_width="wrap_content"  
       android:layout_height="wrap_content"  
       android:orientation="vertical"  
       android:padding="16dp" >  
       <com.example.autoresizetextview.AutoResizeTextView  
         android:layout_width="match_parent"  
         android:layout_height="100dp"  
         android:ellipsize="none"  
         android:maxLines="2"  
         android:text="Auto Resized Text, maximum 2 lines"  
         android:textSize="100sp" />  
        <com.example.autoresizetextview.AutoResizeTextView  
         android:layout_width="match_parent"  
         android:layout_height="100dp"  
         android:ellipsize="none"  
         android:gravity="center"  
         android:maxLines="1"  
         android:text="Auto Resized Text, maximum 1 line"  
         android:textSize="100sp" />  
      <com.example.autoresizetextview.AutoResizeTextView  
         android:layout_width="match_parent"  
         android:layout_height="100dp"  
         android:ellipsize="none"  
         android:gravity="center"  
         android:maxLines="1"  
         android:text=" maximum 1 line maximum 1 line maximum 1 line maximum 1 line"  
         android:textSize="100sp" />  
       <com.example.autoresizetextview.AutoResizeTextView  
         android:layout_width="match_parent"  
         android:layout_height="wrap_content"  
         android:text="Test Auto Resized Text Any Line"  
         android:textSize="500sp" />  
     </LinearLayout>  
    


    Next Method, you have to create dynamically AutoResizeTextView and add text on that particular Textview .

    Now, we create class AutoResizeTextView and put these code

     import android.annotation.TargetApi;  
     import android.content.Context;  
     import android.content.res.Resources;  
     import android.graphics.RectF;  
     import android.os.Build;  
     import android.text.Layout.Alignment;  
     import android.text.StaticLayout;  
     import android.text.TextPaint;  
     import android.util.AttributeSet;  
     import android.util.SparseIntArray;  
     import android.util.TypedValue;  
     import android.widget.TextView;  
     public class AutoResizeTextView extends TextView {  
          private interface SizeTester {  
               /**  
                *   
                * @param suggestedSize  
                *      Size of text to be tested  
                * @param availableSpace  
                *      available space in which text must fit  
                * @return an integer < 0 if after applying {@code suggestedSize} to  
                *     text, it takes less space than {@code availableSpace}, > 0  
                *     otherwise  
                */  
               public int onTestSize(int suggestedSize, RectF availableSpace);  
          }  
          private RectF mTextRect = new RectF();  
          private RectF mAvailableSpaceRect;  
          private SparseIntArray mTextCachedSizes;  
          private TextPaint mPaint;  
          private float mMaxTextSize;  
          private float mSpacingMult = 1.0f;  
          private float mSpacingAdd = 0.0f;  
          private float mMinTextSize = 20;  
          private int mWidthLimit;  
          private static final int NO_LINE_LIMIT = -1;  
          private int mMaxLines;  
          private boolean mEnableSizeCache = true;  
          private boolean mInitiallized;  
          public AutoResizeTextView(Context context) {  
               super(context);  
               initialize();  
          }  
          public AutoResizeTextView(Context context, AttributeSet attrs) {  
               super(context, attrs);  
               initialize();  
          }  
          public AutoResizeTextView(Context context, AttributeSet attrs, int defStyle) {  
               super(context, attrs, defStyle);  
               initialize();  
          }  
          private void initialize() {  
               mPaint = new TextPaint(getPaint());  
               mMaxTextSize = getTextSize();  
               mAvailableSpaceRect = new RectF();  
               mTextCachedSizes = new SparseIntArray();  
               if (mMaxLines == 0) {  
                    // no value was assigned during construction  
                    mMaxLines = NO_LINE_LIMIT;  
               }  
               mInitiallized = true;  
          }  
          @Override  
          public void setText(final CharSequence text, BufferType type) {  
               super.setText(text, type);  
               adjustTextSize(text.toString());  
          }  
          @Override  
          public void setTextSize(float size) {  
               mMaxTextSize = size;  
               mTextCachedSizes.clear();  
               adjustTextSize(getText().toString());  
          }  
          @Override  
          public void setMaxLines(int maxlines) {  
               super.setMaxLines(maxlines);  
               mMaxLines = maxlines;  
               reAdjust();  
          }  
          public int getMaxLines() {  
               return mMaxLines;  
          }  
          @Override  
          public void setSingleLine() {  
               super.setSingleLine();  
               mMaxLines = 1;  
               reAdjust();  
          }  
          @Override  
          public void setSingleLine(boolean singleLine) {  
               super.setSingleLine(singleLine);  
               if (singleLine) {  
                    mMaxLines = 1;  
               } else {  
                    mMaxLines = NO_LINE_LIMIT;  
               }  
               reAdjust();  
          }  
          @Override  
          public void setLines(int lines) {  
               super.setLines(lines);  
               mMaxLines = lines;  
               reAdjust();  
          }  
          @Override  
          public void setTextSize(int unit, float size) {  
               Context c = getContext();  
               Resources r;  
               if (c == null)  
                    r = Resources.getSystem();  
               else  
                    r = c.getResources();  
               mMaxTextSize = TypedValue.applyDimension(unit, size, r.getDisplayMetrics());  
               mTextCachedSizes.clear();  
               adjustTextSize(getText().toString());  
          }  
          @Override  
          public void setLineSpacing(float add, float mult) {  
               super.setLineSpacing(add, mult);  
               mSpacingMult = mult;  
               mSpacingAdd = add;  
          }  
          /**  
           * Set the lower text size limit and invalidate the view  
           *   
           * @param minTextSize  
           */  
          public void setMinTextSize(float minTextSize) {  
               mMinTextSize = minTextSize;  
               reAdjust();  
          }  
          private void reAdjust() {  
               adjustTextSize(getText().toString());  
          }  
          private void adjustTextSize(String string) {  
               if (!mInitiallized) {  
                    return;  
               }  
               int startSize = (int) mMinTextSize;  
               int heightLimit = getMeasuredHeight() - getCompoundPaddingBottom() - getCompoundPaddingTop();  
               mWidthLimit = getMeasuredWidth() - getCompoundPaddingLeft() - getCompoundPaddingRight();  
               mAvailableSpaceRect.right = mWidthLimit;  
               mAvailableSpaceRect.bottom = heightLimit;  
               super.setTextSize(TypedValue.COMPLEX_UNIT_PX, efficientTextSizeSearch(startSize, (int) mMaxTextSize, mSizeTester, mAvailableSpaceRect));  
          }  
          private final SizeTester mSizeTester = new SizeTester() {  
               @TargetApi(Build.VERSION_CODES.JELLY_BEAN)  
               @Override  
               public int onTestSize(int suggestedSize, RectF availableSPace) {  
                    mPaint.setTextSize(suggestedSize);  
                    String text = getText().toString();  
                    boolean singleline = getMaxLines() == 1;  
                    if (singleline) {  
                         mTextRect.bottom = mPaint.getFontSpacing();  
                         mTextRect.right = mPaint.measureText(text);  
                    } else {  
                         StaticLayout layout = new StaticLayout(text, mPaint, mWidthLimit, Alignment.ALIGN_NORMAL, mSpacingMult, mSpacingAdd, true);  
                         // return early if we have more lines  
                         if (getMaxLines() != NO_LINE_LIMIT && layout.getLineCount() > getMaxLines()) {  
                              return 1;  
                         }  
                         mTextRect.bottom = layout.getHeight();  
                         int maxWidth = -1;  
                         for (int i = 0; i < layout.getLineCount(); i++) {  
                              if (maxWidth < layout.getLineWidth(i)) {  
                                   maxWidth = (int) layout.getLineWidth(i);  
                              }  
                         }  
                         mTextRect.right = maxWidth;  
                    }  
                    mTextRect.offsetTo(0, 0);  
                    if (availableSPace.contains(mTextRect)) {  
                         // may be too small, don't worry we will find the best match  
                         return -1;  
                    } else {  
                         // too big  
                         return 1;  
                    }  
               }  
          };  
          /**  
           * Enables or disables size caching, enabling it will improve performance  
           * where you are animating a value inside TextView. This stores the font  
           * size against getText().length() Be careful though while enabling it as 0  
           * takes more space than 1 on some fonts and so on.  
           *   
           * @param enable  
           *      enable font size caching  
           */  
          public void enableSizeCache(boolean enable) {  
               mEnableSizeCache = enable;  
               mTextCachedSizes.clear();  
               adjustTextSize(getText().toString());  
          }  
          private int efficientTextSizeSearch(int start, int end, SizeTester sizeTester, RectF availableSpace) {  
               if (!mEnableSizeCache) {  
                    return binarySearch(start, end, sizeTester, availableSpace);  
               }  
               String text = getText().toString();  
               int key = text == null ? 0 : text.length();  
               int size = mTextCachedSizes.get(key);  
               if (size != 0) {  
                    return size;  
               }  
               size = binarySearch(start, end, sizeTester, availableSpace);  
               mTextCachedSizes.put(key, size);  
               return size;  
          }  
          private static int binarySearch(int start, int end, SizeTester sizeTester, RectF availableSpace) {  
               int lastBest = start;  
               int lo = start;  
               int hi = end - 1;  
               int mid = 0;  
               while (lo <= hi) {  
                    mid = (lo + hi) >>> 1;  
                    int midValCmp = sizeTester.onTestSize(mid, availableSpace);  
                    if (midValCmp < 0) {  
                         lastBest = lo;  
                         lo = mid + 1;  
                    } else if (midValCmp > 0) {  
                         hi = mid - 1;  
                         lastBest = hi;  
                    } else {  
                         return mid;  
                    }  
               }  
               // make sure to return last best  
               // this is what should always be returned  
               return lastBest;  
          }  
          @Override  
          protected void onTextChanged(final CharSequence text, final int start, final int before, final int after) {  
               super.onTextChanged(text, start, before, after);  
               reAdjust();  
          }  
          @Override  
          protected void onSizeChanged(int width, int height, int oldwidth, int oldheight) {  
               mTextCachedSizes.clear();  
               super.onSizeChanged(width, height, oldwidth, oldheight);  
               if (width != oldwidth || height != oldheight) {  
                    reAdjust();  
               }  
          }  
     }  
    


    If you create layout only, then you don;t need any more, just call xml file, but if you want dynamically text then set which line and string on textview.

    Output looks like:



    Happy Coding !!!


    Contact Form

    Name

    Email *

    Message *