Mise à l'Échelle Auto TextView Texte à l'intérieur de Limites

Mise à JOUR: code Suivant répond également à l'exigence d'un idéal AutoScaleTextView comme décrit ici : Ajustement automatique de la TextView pour Android et est marqué comme gagnant.

Mise à JOUR 2: Soutien de maxlines ajouté, maintenant fonctionne bien avant de l'API de niveau 16.

Mise à jour 3: Soutien pour android:drawableLeft, android:drawableRight, android:drawableTop et android:drawableBottom balises ajoutées, grâce à MartinH est simple correctif ici.

Mes besoins étaient un peu différentes. J'ai besoin d'un moyen efficace de régler la taille parce que j'étais l'animation d'un nombre entier à partir, peut être de 0 à ~4000 dans TextView en 2 secondes et j'ai voulu régler la taille en conséquence. Ma solution fonctionne à peu différemment. Voici ce résultat final ressemble:

et le code qui l'a produite:

<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.vj.widgets.AutoResizeTextView
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:ellipsize="none"
        android:maxLines="2"
        android:text="Auto Resized Text, max 2 lines"
        android:textSize="100sp" /> <!-- maximum size -->

    <com.vj.widgets.AutoResizeTextView
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:ellipsize="none"
        android:gravity="center"
        android:maxLines="1"
        android:text="Auto Resized Text, max 1 line"
        android:textSize="100sp" /> <!-- maximum size -->

    <com.vj.widgets.AutoResizeTextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Auto Resized Text"
        android:textSize="500sp" /> <!-- maximum size -->

</LinearLayout>

Et enfin le code java:

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();
}
}
}

J'ai commencé avec Chase solution, mais a dû s'adapter à deux choses avant qu'il travaillait comme prévu sur mon téléphone (Galaxy Nexus, Android 4.1):

1. à l'aide d'une copie de TextPaint pour la mesure de mise en page
   La documentation pour TextView.getPaint() déclare qu'il devrait être utilisé en lecture seule, donc j'ai fait une copie dans les deux endroits où l'on utilise la peinture à l'objet de mesure:

   //1. in resizeText()
   if (mAddEllipsis && targetTextSize == mMinTextSize && textHeight > height) {
   //Draw using a static layout
   //modified: use a copy of TextPaint for measuring
   TextPaint paint = new TextPaint(textPaint);
   //2. in getTextHeight()
   private int getTextHeight(CharSequence source, TextPaint originalPaint, int width, float textSize) {
   //modified: make a copy of the original TextPaint object for measuring
   //(apparently the object gets modified while measuring, see also the
   //docs for TextView.getPaint() (which states to access it read-only)
   TextPaint paint = new TextPaint(originalPaint);
   //Update the text paint object
   paint.setTextSize(textSize);
   ...

2. l'ajout d'une unité de réglage de la taille du texte

   //modified: setting text size via this.setTextSize (instead of textPaint.setTextSize(targetTextSize))
   setTextSize(TypedValue.COMPLEX_UNIT_PX, targetTextSize);
   setLineSpacing(mSpacingAdd, mSpacingMult);

Avec ces deux modifications, la solution fonctionne parfaitement pour moi, merci Chase! Je ne sais pas si c'est dû à Android 4.x que la solution d'origine ne fonctionnait pas. Dans le cas où vous voulez le voir en action ou de tester si ça marche vraiment sur votre appareil, vous pouvez jeter un oeil à mon flashcard application Flashcards ToGo où j'utilise cette solution à l'échelle le texte d'une carte mémoire. Le texte peut avoir une longueur arbitraire, et les cartes mémoire sont affichés dans les différentes activités, parfois petits, parfois, de plus grand, de plus dans le paysage + portrait mode, et je n'ai pas trouvé le coin de cas où la solution serait de ne pas fonctionner correctement...

Avertissement, bug sur Android Honeycomb et Ice Cream Sandwich

Androïdes versions: 3.1 - 4.04 avoir un bug, que setTextSize() à l'intérieur de TextView ne fonctionne que pour la 1ère fois (1er invocation).

Bug est décrit ici: http://code.google.com/p/android/issues/detail?id=22493 http://code.google.com/p/android/issues/detail?id=17343#c9

solution de contournement consiste à ajouter un caractère de nouvelle ligne de texte attribué à TextView avant de changer de taille:

final String DOUBLE_BYTE_SPACE = "\u3000";
textView.append(DOUBLE_BYTE_SPACE);

Je l'utilise dans mon code comme suit:

final String DOUBLE_BYTE_SPACE = "\u3000";
AutoResizeTextView textView = (AutoResizeTextView) view.findViewById(R.id.aTextView);
String fixString = "";
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.HONEYCOMB_MR1
&& android.os.Build.VERSION.SDK_INT <= android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {  
fixString = DOUBLE_BYTE_SPACE;
}
textView.setText(fixString + "The text" + fixString);

- Je ajouter cette "\u3000" le caractère à gauche et à droite de mon texte, de sorte qu'il reste centré. Si vous avez aligné à gauche, puis ajouter à la droite. Bien sûr, il peut être également intégré avec AutoResizeTextView widget, mais je voulais garder corriger le code de l'extérieur.

Mon besoin était de redimensionner le texte afin de s'adapter parfaitement à la vue de limites. Chase solution seulement de réduire la taille du texte, celui-ci élargit également le texte s'il y a assez d'espace.

À faire tous les rapide & précis j'ai utilisé une méthode de bissection au lieu d'un processus itératif, alors que, comme vous pouvez le voir dans resizeText() méthode. C'est pourquoi vous avez également un MAX_TEXT_SIZE option. J'ai aussi inclus onoelle conseils.

Testé sur Android 4.4

/**
*               DO WHAT YOU WANT TO PUBLIC LICENSE
*                    Version 2, December 2004
*
* Copyright (C) 2004 Sam Hocevar <[email protected]>
*
* Everyone is permitted to copy and distribute verbatim or modified
* copies of this license document, and changing it is allowed as long
* as the name is changed.
*
*            DO WHAT YOU WANT TO PUBLIC LICENSE
*   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
*
*  0. You just DO WHAT YOU WANT TO.
*/
import android.content.Context;
import android.text.Layout.Alignment;
import android.text.StaticLayout;
import android.text.TextPaint;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.widget.TextView;
/**
* Text view that auto adjusts text size to fit within the view.
* If the text size equals the minimum text size and still does not
* fit, append with an ellipsis.
*
* @author Chase Colburn
* @since Apr 4, 2011
*/
public class AutoResizeTextView extends TextView {
//Minimum text size for this text view
public static final float MIN_TEXT_SIZE = 26;
//Maximum text size for this text view
public static final float MAX_TEXT_SIZE = 128;
private static final int BISECTION_LOOP_WATCH_DOG = 30;
//Interface for resize notifications
public interface OnTextResizeListener {
public void onTextResize(TextView textView, float oldSize, float newSize);
}
//Our ellipse string
private static final String mEllipsis = "...";
//Registered resize listener
private OnTextResizeListener mTextResizeListener;
//Flag for text and/or size changes to force a resize
private boolean mNeedsResize = false;
//Text size that is set from code. This acts as a starting point for resizing
private float mTextSize;
//Temporary upper bounds on the starting text size
private float mMaxTextSize = MAX_TEXT_SIZE;
//Lower bounds for text size
private float mMinTextSize = MIN_TEXT_SIZE;
//Text view line spacing multiplier
private float mSpacingMult = 1.0f;
//Text view additional line spacing
private float mSpacingAdd = 0.0f;
//Add ellipsis to text that overflows at the smallest text size
private boolean mAddEllipsis = true;
//Default constructor override
public AutoResizeTextView(Context context) {
this(context, null);
}
//Default constructor when inflating from XML file
public AutoResizeTextView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
//Default constructor override
public AutoResizeTextView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
mTextSize = getTextSize();
}
/**
* When text changes, set the force resize flag to true and reset the text size.
*/
@Override
protected void onTextChanged(final CharSequence text, final int start, final int before, final int after) {
mNeedsResize = true;
//Since this view may be reused, it is good to reset the text size
resetTextSize();
}
/**
* If the text view size changed, set the force resize flag to true
*/
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
if (w != oldw || h != oldh) {
mNeedsResize = true;
}
}
/**
* Register listener to receive resize notifications
* @param listener
*/
public void setOnResizeListener(OnTextResizeListener listener) {
mTextResizeListener = listener;
}
/**
* Override the set text size to update our internal reference values
*/
@Override
public void setTextSize(float size) {
super.setTextSize(size);
mTextSize = getTextSize();
}
/**
* Override the set text size to update our internal reference values
*/
@Override
public void setTextSize(int unit, float size) {
super.setTextSize(unit, size);
mTextSize = getTextSize();
}
/**
* Override the set line spacing to update our internal reference values
*/
@Override
public void setLineSpacing(float add, float mult) {
super.setLineSpacing(add, mult);
mSpacingMult = mult;
mSpacingAdd = add;
}
/**
* Set the upper text size limit and invalidate the view
* @param maxTextSize
*/
public void setMaxTextSize(float maxTextSize) {
mMaxTextSize = maxTextSize;
requestLayout();
invalidate();
}
/**
* Return upper text size limit
* @return
*/
public float getMaxTextSize() {
return mMaxTextSize;
}
/**
* Set the lower text size limit and invalidate the view
* @param minTextSize
*/
public void setMinTextSize(float minTextSize) {
mMinTextSize = minTextSize;
requestLayout();
invalidate();
}
/**
* Return lower text size limit
* @return
*/
public float getMinTextSize() {
return mMinTextSize;
}
/**
* Set flag to add ellipsis to text that overflows at the smallest text size
* @param addEllipsis
*/
public void setAddEllipsis(boolean addEllipsis) {
mAddEllipsis = addEllipsis;
}
/**
* Return flag to add ellipsis to text that overflows at the smallest text size
* @return
*/
public boolean getAddEllipsis() {
return mAddEllipsis;
}
/**
* Reset the text to the original size
*/
public void resetTextSize() {
if(mTextSize > 0) {
super.setTextSize(TypedValue.COMPLEX_UNIT_PX, mTextSize);
//mMaxTextSize = mTextSize;
}
}
/**
* Resize text after measuring
*/
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
if(changed || mNeedsResize) {
int widthLimit = (right - left) - getCompoundPaddingLeft() - getCompoundPaddingRight();
int heightLimit = (bottom - top) - getCompoundPaddingBottom() - getCompoundPaddingTop();
resizeText(widthLimit, heightLimit);
}
super.onLayout(changed, left, top, right, bottom);
}
/**
* Resize the text size with default width and height
*/
public void resizeText() {
int heightLimit = getHeight() - getPaddingBottom() - getPaddingTop();
int widthLimit = getWidth() - getPaddingLeft() - getPaddingRight();
resizeText(widthLimit, heightLimit);
}
/**
* Resize the text size with specified width and height
* @param width
* @param height
*/
public void resizeText(int width, int height) {
CharSequence text = getText();
//Do not resize if the view does not have dimensions or there is no text
if(text == null || text.length() == 0 || height <= 0 || width <= 0 || mTextSize == 0) {
return;
}
//Get the text view's paint object
TextPaint textPaint = getPaint();
//Store the current text size
float oldTextSize = textPaint.getTextSize();
//Bisection method: fast & precise
float lower = mMinTextSize;
float upper = mMaxTextSize;
int loop_counter=1;
float targetTextSize = (lower+upper)/2;
int textHeight = getTextHeight(text, textPaint, width, targetTextSize);
while(loop_counter < BISECTION_LOOP_WATCH_DOG && upper - lower > 1) {
targetTextSize = (lower+upper)/2;
textHeight = getTextHeight(text, textPaint, width, targetTextSize);
if(textHeight > height)
upper = targetTextSize;
else
lower = targetTextSize;
loop_counter++;
}
targetTextSize = lower;
textHeight = getTextHeight(text, textPaint, width, targetTextSize);
//If we had reached our minimum text size and still don't fit, append an ellipsis
if(mAddEllipsis && targetTextSize == mMinTextSize && textHeight > height) {
//Draw using a static layout
//modified: use a copy of TextPaint for measuring
TextPaint paintCopy = new TextPaint(textPaint);
paintCopy.setTextSize(targetTextSize);
StaticLayout layout = new StaticLayout(text, paintCopy, width, Alignment.ALIGN_NORMAL, mSpacingMult, mSpacingAdd, false);
//Check that we have a least one line of rendered text
if(layout.getLineCount() > 0) {
//Since the line at the specific vertical position would be cut off,
//we must trim up to the previous line
int lastLine = layout.getLineForVertical(height) - 1;
//If the text would not even fit on a single line, clear it
if(lastLine < 0) {
setText("");
}
//Otherwise, trim to the previous line and add an ellipsis
else {
int start = layout.getLineStart(lastLine);
int end = layout.getLineEnd(lastLine);
float lineWidth = layout.getLineWidth(lastLine);
float ellipseWidth = paintCopy.measureText(mEllipsis);
//Trim characters off until we have enough room to draw the ellipsis
while(width < lineWidth + ellipseWidth) {
lineWidth = paintCopy.measureText(text.subSequence(start, --end + 1).toString());
}
setText(text.subSequence(0, end) + mEllipsis);
}
}
}
//Some devices try to auto adjust line spacing, so force default line spacing
//and invalidate the layout as a side effect
setTextSize(TypedValue.COMPLEX_UNIT_PX, targetTextSize);
setLineSpacing(mSpacingAdd, mSpacingMult);
//Notify the listener if registered
if(mTextResizeListener != null) {
mTextResizeListener.onTextResize(this, oldTextSize, targetTextSize);
}
//Reset force resize flag
mNeedsResize = false;
}
//Set the text size of the text paint object and use a static layout to render text off screen before measuring
private int getTextHeight(CharSequence source, TextPaint originalPaint, int width, float textSize) {
//modified: make a copy of the original TextPaint object for measuring
//(apparently the object gets modified while measuring, see also the
//docs for TextView.getPaint() (which states to access it read-only)
TextPaint paint = new TextPaint(originalPaint);
//Update the text paint object
paint.setTextSize(textSize);
//Measure using a static layout
StaticLayout layout = new StaticLayout(source, paint, width, Alignment.ALIGN_NORMAL, mSpacingMult, mSpacingAdd, true);
return layout.getHeight();
}
}

Depuis que j'ai été la recherche de ce pour toujours, et j'ai trouvé une solution il y a un moment qui manque ici, je vais l'écrire ici, pour la future référence.

Remarque: ce code a été prise directement à partir de Google, Android Lollipop dialer a quelques temps, je ne me souviens pas Si des modifications ont été apportées à l'époque. Aussi, je ne sais pas quelle licence est cette vertu, mais j'ai des raisons de penser qu'il est Apache 2.0.

Classe ResizeTextView, le View

public class ResizeTextView extends TextView {
private final int mOriginalTextSize;
private final int mMinTextSize;
private final static int sMinSize = 20;
public ResizeTextView(Context context, AttributeSet attrs) {
super(context, attrs);
mOriginalTextSize = (int) getTextSize();
mMinTextSize = (int) sMinSize;
}
@Override
protected void onTextChanged(CharSequence text, int start, int lengthBefore, int lengthAfter) {
super.onTextChanged(text, start, lengthBefore, lengthAfter);
ViewUtil.resizeText(this, mOriginalTextSize, mMinTextSize);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
ViewUtil.resizeText(this, mOriginalTextSize, mMinTextSize);
}

Ce ResizeTextView classe pourrait s'étendre TextView et tous ses enfants comme je le comprenons, donc EditText ainsi.

Classe ViewUtil avec la méthode resizeText(...)

/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import android.graphics.Paint;
import android.util.TypedValue;
import android.widget.TextView;
public class ViewUtil {
private ViewUtil() {}
public static void resizeText(TextView textView, int originalTextSize, int minTextSize) {
final Paint paint = textView.getPaint();
final int width = textView.getWidth();
if (width == 0) return;
textView.setTextSize(TypedValue.COMPLEX_UNIT_PX, originalTextSize);
float ratio = width / paint.measureText(textView.getText().toString());
if (ratio <= 1.0f) {
textView.setTextSize(TypedValue.COMPLEX_UNIT_PX,
Math.max(minTextSize, originalTextSize * ratio));
}
}
}

Vous devez définir votre point de vue en tant que

<yourpackage.yourapp.ResizeTextView
android:layout_width="match_parent"
android:layout_height="64dp"
android:gravity="center"
android:maxLines="1"/>

Espère que cela aide!

J'ai écrit un billet de blog à ce sujet.

J'ai créé un composant appelé ResizableButton basé sur Kirill Grouchnikov de post de blog sur les composants utilisés dans la nouvelle application android market. J'ai placé le code src ici.

D'autre part, mosabua lire mon post et m'a dit qu'il allait ouvrir la source de sa mise en œuvre qui a été plus rapide que le mien. J'espère qu'il le libérer assez tôt 🙂

Mon application est un peu plus complexe, mais est livré avec les éléments suivants goodies:

• prend la largeur et la hauteur disponible dans le compte
• fonctionne avec une seule ligne et multi-étiquettes
• utilise les points de suspension dans le cas où la taille minimale de la police est frappé
• depuis l'intérieur du texte de la représentation est changé, se souvient de l'origine de la définition du texte dans une variable distincte
• assure que la toile est toujours seulement aussi grand qu'il doit être, bien qu'il utilise toute la hauteur disponible de la mère

/**
* Text view that auto adjusts text size to fit within the view. If the text
* size equals the minimum text size and still does not fit, append with an
* ellipsis.
* 
* Based on the original work from Chase Colburn
* <http://stackoverflow.com/a/5535672/305532>
*
* @author Thomas Keller <[email protected]>
*/
public class AutoResizeTextView extends TextView {
//in dip
private static final int MIN_TEXT_SIZE = 20;
private static final boolean SHRINK_TEXT_SIZE = true;
private static final char ELLIPSIS = '\u2026';
private static final float LINE_SPACING_MULTIPLIER_MULTILINE = 0.8f;
private static final float LINE_SPACING_MULTIPLIER_SINGLELINE = 1f;
private static final float LINE_SPACING_EXTRA = 0.0f;
private CharSequence mOriginalText;
//temporary upper bounds on the starting text size
private float mMaxTextSize;
//lower bounds for text size
private float mMinTextSize;
//determines whether we're currently in the process of measuring ourselves,
//so we do not enter onMeasure recursively
private boolean mInMeasure = false;
//if the text size should be shrinked or if the text size should be kept
//constant and only characters should be removed to hit the boundaries
private boolean mShrinkTextSize;
public AutoResizeTextView(Context context) {
this(context, null);
init(context, null);
}
public AutoResizeTextView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
init(context, attrs);
}
public AutoResizeTextView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init(context, attrs);
}
private void init(Context context, AttributeSet attrs) {
//the current text size is used as maximum text size we can apply to
//our widget
mMaxTextSize = getTextSize();
if (attrs != null) {
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.AutoResizeTextView);
mMinTextSize = a.getFloat(R.styleable.AutoResizeTextView_minFontSize, MIN_TEXT_SIZE);
mShrinkTextSize = a.getBoolean(R.styleable.AutoResizeTextView_shrinkTextSize, SHRINK_TEXT_SIZE);
a.recycle();
}
}
@Override
public void setTextSize(float size) {
mMaxTextSize = size;
super.setTextSize(size);
}
/**
* Returns the original, unmodified text of this widget
* 
* @return
*/
public CharSequence getOriginalText() {
//text has not been resized yet
if (mOriginalText == null) {
return getText();
}
return mOriginalText;
}
@Override
public void setText(CharSequence text, BufferType type) {
if (!mInMeasure) {
mOriginalText = text.toString();
}
super.setText(text, type);
}
@SuppressLint("DrawAllocation")
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
mInMeasure = true;
try {
int availableWidth = MeasureSpec.getSize(widthMeasureSpec) - getCompoundPaddingLeft()
- getCompoundPaddingRight();
int availableHeight = MeasureSpec.getSize(heightMeasureSpec) - getCompoundPaddingTop()
- getCompoundPaddingBottom();
//Do not resize if the view does not have dimensions or there is no
//text
if (mOriginalText == null || mOriginalText.length() == 0 || availableWidth <= 0) {
return;
}
TextPaint textPaint = getPaint();
//start with the recorded max text size
float targetTextSize = mMaxTextSize;
String originalText = mOriginalText.toString();
String finalText = originalText;
Rect textSize = getTextSize(originalText, textPaint, targetTextSize);
boolean textExceedsBounds = textSize.height() > availableHeight || textSize.width() > availableWidth;
if (mShrinkTextSize && textExceedsBounds) {
//check whether all lines can be rendered in the available
//width /height without violating the bounds of the parent and
//without using a text size that is smaller than the minimum
//text size
float heightMultiplier = availableHeight / (float) textSize.height();
float widthMultiplier = availableWidth / (float) textSize.width();
float multiplier = Math.min(heightMultiplier, widthMultiplier);
targetTextSize = Math.max(targetTextSize * multiplier, mMinTextSize);
//measure again
textSize = getTextSize(finalText, textPaint, targetTextSize);
}
//we cannot shrink the height further when we hit the available
//height, but we can shrink the width by applying an ellipsis on
//each line
if (textSize.width() > availableWidth) {
StringBuilder modifiedText = new StringBuilder();
String lines[] = originalText.split(System.getProperty("line.separator"));
for (int i = 0; i < lines.length; i++) {
modifiedText.append(resizeLine(textPaint, lines[i], availableWidth));
//add the separator back to all but the last processed line
if (i != lines.length - 1) {
modifiedText.append(System.getProperty("line.separator"));
}
}
finalText = modifiedText.toString();
//measure again
textSize = getTextSize(finalText, textPaint, targetTextSize);
}
textPaint.setTextSize(targetTextSize);
boolean isMultiline = finalText.indexOf('\n') > -1;
//do not include extra font padding (for accents, ...) for
//multiline texts, this will prevent proper placement with
//Gravity.CENTER_VERTICAL
if (isMultiline) {
setLineSpacing(LINE_SPACING_EXTRA, LINE_SPACING_MULTIPLIER_MULTILINE);
setIncludeFontPadding(false);
} else {
setLineSpacing(LINE_SPACING_EXTRA, LINE_SPACING_MULTIPLIER_SINGLELINE);
setIncludeFontPadding(true);
}
//according to
//<http://code.google.com/p/android/issues/detail?id=22493>
//we have to add a unicode character to trigger the text centering
//in ICS. this particular character is known as "zero-width" and
//does no harm.
setText(finalText + "\u200B");
int measuredWidth = textSize.width() + getCompoundPaddingLeft() + getCompoundPaddingRight();
int measuredHeight = textSize.height() + getCompoundPaddingTop() + getCompoundPaddingBottom();
//expand the view to the parent's height in case it is smaller or
//to the minimum height that has been set
//FIXME: honor the vertical measure mode (EXACTLY vs AT_MOST) here
//somehow
measuredHeight = Math.max(measuredHeight, MeasureSpec.getSize(heightMeasureSpec));
setMeasuredDimension(measuredWidth, measuredHeight);
} finally {
mInMeasure = false;
}
}
private Rect getTextSize(String text, TextPaint textPaint, float textSize) {
textPaint.setTextSize(textSize);
//StaticLayout depends on a given width in which it should lay out the
//text (and optionally also split into separate lines).
//Therefor we calculate the current text width manually and start with
//a fake (read: maxmimum) width for the height calculation.
//We do _not_ use layout.getLineWidth() here since this returns
//slightly smaller numbers and therefor would lead to exceeded text box
//drawing.
StaticLayout layout = new StaticLayout(text, textPaint, Integer.MAX_VALUE, Alignment.ALIGN_NORMAL, 1f, 0f, true);
int textWidth = 0;
String lines[] = text.split(System.getProperty("line.separator"));
for (int i = 0; i < lines.length; ++i) {
textWidth = Math.max(textWidth, measureTextWidth(textPaint, lines[i]));
}
return new Rect(0, 0, textWidth, layout.getHeight());
}
private String resizeLine(TextPaint textPaint, String line, int availableWidth) {
checkArgument(line != null && line.length() > 0, "expected non-empty string");
int textWidth = measureTextWidth(textPaint, line);
int lastDeletePos = -1;
StringBuilder builder = new StringBuilder(line);
while (textWidth > availableWidth && builder.length() > 0) {
lastDeletePos = builder.length() / 2;
builder.deleteCharAt(builder.length() / 2);
//don't forget to measure the ellipsis character as well; it
//doesn't matter where it is located in the line, it just has to be
//there, since there are no (known) ligatures that use this glyph
String textToMeasure = builder.toString() + ELLIPSIS;
textWidth = measureTextWidth(textPaint, textToMeasure);
}
if (lastDeletePos > -1) {
builder.insert(lastDeletePos, ELLIPSIS);
}
return builder.toString();
}
//there are several methods in Android to determine the text width, namely
//getBounds() and measureText().
//The latter works for us the best as it gives us the best /nearest
//results without that our text canvas needs to wrap its text later on
//again.
private int measureTextWidth(TextPaint textPaint, String line) {
return Math.round(textPaint.measureText(line));
}
}

[révisé le 2012-11-21]

• fixe le placement des points de suspension (off-par-une erreur)
• texte retravaillé le calcul de la taille; maintenant toujours le texte complet, y compris les sauts de ligne est mesurée, pour résoudre les problèmes lors de l'ajout de la hauteur de deux mesuré les lignes juste ne pas aboutir au même résultat que la mesure de la hauteur de l'ensemble du texte
• au lieu de boucle pour trouver le plus petit texte disponible taille, il suffit de calculer d'après la première mesure

Voici une énumération de ce que j'ai trouvé pour ceux qui sont encore à la recherche:

1) Voici une solution que de manière récursive re-peint le textview jusqu'à ce qu'il s'adapte. Cela signifie littéralement regarder votre texte rétrécir en place, mais au moins il tient quand c'est fait. Le code a besoin de quelques ajustements à mettre en œuvre, mais il est surtout là.

2) Vous pouvez essayer de piratage ensemble une solution personnalisée comme cette, ou dunni classe dans cette, qui est ce que j'ai fait à l'aide de la getPaint().savoir measuretext(str) à la recherche de la bonne taille, mais il a eu beaucoup de messier car j'ai besoin d'elle pour l'envelopper seulement sur les espaces...

3) Vous pouvez continuer à chercher - j'ai essayé plus de solutions de rechange que je peux compter. Ted conseils sur StaticLayout n'a pas payé pour moi, mais peut-être il ya quelque chose là-bas; j'ai essayé d'utiliser le StaticLayout.getEllipsis(ligne) afin de déterminer si le texte a été d'aller hors de l'écran, pas d'effet. Voir mon (actuellement de l'onu-ont répondu) post à ce sujet ici.