অ্যান্ড্রয়েডের জন্য অটো-ফিট টেক্সটভিউ


231

পটভূমি

অনেক সময় আমাদের দেওয়া সীমানায় টেক্সটভিউয়ের ফন্টটি স্বয়ংক্রিয়ভাবে ফিট করতে হবে।

সমস্যাটি

দুঃখিতভাবে, যদিও অনেক থ্রেড এবং পোস্ট (এবং প্রস্তাবিত সমাধান) (উদাহরণ এই সমস্যা সম্পর্কে কথা বলা হয় এখানে , এখানে এবং এখানে ), তাদের কেউ আসলে ভাল কাজ।

এ কারণেই, আমি আসল চুক্তি না পাওয়া পর্যন্ত আমি তাদের প্রত্যেকটি পরীক্ষা করার সিদ্ধান্ত নিয়েছি।

আমি মনে করি যে এই জাতীয় পাঠ্য ভিউয়ের প্রয়োজনীয়তাগুলি হ'ল:

  1. কোনও ফন্ট, টাইপফেস, স্টাইল এবং অক্ষরের সেট ব্যবহার করার অনুমতি দেওয়া উচিত।

  2. প্রস্থ এবং উচ্চতা উভয়ই পরিচালনা করা উচিত

  3. সীমাবদ্ধতার কারণে পাঠ্য মাপসই না করা যায় না কোনও ছাঁটাই, আমরা এটি দিয়েছি (উদাহরণ: খুব দীর্ঘ পাঠ্য, খুব ছোট উপলব্ধ আকার)। তবে আমরা চাইলে অনুভূমিক / উল্লম্ব স্ক্রোলবারের জন্য অনুরোধ করতে পারি, কেবল সেই ক্ষেত্রে cases

  4. মাল্টি-লাইন বা একক-লাইনের অনুমতি দেওয়া উচিত। একাধিক-লাইনের ক্ষেত্রে, সর্বাধিক ও মিনিট লাইনের অনুমতি দিন allow

  5. গণনায় ধীর হওয়া উচিত নয়। সেরা আকার সন্ধানের জন্য একটি লুপ ব্যবহার করছেন? কমপক্ষে এটি অপ্টিমাইজ করুন এবং প্রতিবার আপনার নমুনাটিকে 1 দ্বারা বাড়িয়ে তুলবেন না।

  6. মাল্টি-লাইনের ক্ষেত্রে, পুনরায় আকার দেওয়ার বা আরও বেশি লাইন ব্যবহার করার অনুমতি দেওয়া উচিত এবং / অথবা "\ n" অক্ষরটি ব্যবহার করে লাইনগুলি নিজেরাই বেছে নেওয়ার অনুমতি দেওয়া উচিত।

আমি কি চেষ্টা করেছি

আমি অনেকগুলি নমুনা চেষ্টা করেছি (লিঙ্কগুলি সহ, আমি লিখেছি) এবং আমি কেসগুলি পরিচালনা করার জন্য সেগুলি সংশোধন করার চেষ্টা করেছি, যার বিষয়ে আমি কথা বলেছি, তবে বাস্তবে কোনওটিই কাজ করে না।

আমি একটি নমুনা প্রকল্প তৈরি করেছি যা আমাকে টেক্সটভিউ স্বয়ংক্রিয়ভাবে ফিট করে কিনা তা চাক্ষুষভাবে দেখার অনুমতি দেয়।

বর্তমানে, আমার নমুনা প্রকল্পটি কেবলমাত্র পাঠ্যটি (ইংরেজী বর্ণমালা প্লাস অঙ্কগুলি) এবং পাঠ্য ভিউয়ের আকারটিকে এলোমেলো করে তোলে এবং এটি একক লাইনের সাথে থাকতে দেয়, তবে আমি যে নমুনা চেষ্টা করেছি তার কোনওটিতে এটি ভাল কাজ করে না।

এখানে কোড (এছাড়াও উপলব্ধ এখানে ):

ফাইল res/layout/activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
  android:layout_height="match_parent" tools:context=".MainActivity">
  <Button android:id="@+id/button1" android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_alignParentBottom="true"
    android:layout_centerHorizontal="true" android:text="Button" />
  <FrameLayout android:layout_width="match_parent"
    android:layout_height="wrap_content" android:layout_above="@+id/button1"
    android:layout_alignParentLeft="true" android:background="#ffff0000"
    android:layout_alignParentRight="true" android:id="@+id/container"
    android:layout_alignParentTop="true" />

</RelativeLayout>

ফাইল src/.../MainActivity.java

public class MainActivity extends Activity
  {
  private final Random        _random            =new Random();
  private static final String ALLOWED_CHARACTERS ="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";

  @Override
  protected void onCreate(final Bundle savedInstanceState)
    {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    final ViewGroup container=(ViewGroup)findViewById(R.id.container);
    findViewById(R.id.button1).setOnClickListener(new OnClickListener()
      {
        @Override
        public void onClick(final View v)
          {
          container.removeAllViews();
          final int maxWidth=container.getWidth();
          final int maxHeight=container.getHeight();
          final FontFitTextView fontFitTextView=new FontFitTextView(MainActivity.this);
          final int width=_random.nextInt(maxWidth)+1;
          final int height=_random.nextInt(maxHeight)+1;
          fontFitTextView.setLayoutParams(new LayoutParams(width,height));
          fontFitTextView.setSingleLine();
          fontFitTextView.setBackgroundColor(0xff00ff00);
          final String text=getRandomText();
          fontFitTextView.setText(text);
          container.addView(fontFitTextView);
          Log.d("DEBUG","width:"+width+" height:"+height+" text:"+text);
          }
      });
    }

  private String getRandomText()
    {
    final int textLength=_random.nextInt(20)+1;
    final StringBuilder builder=new StringBuilder();
    for(int i=0;i<textLength;++i)
      builder.append(ALLOWED_CHARACTERS.charAt(_random.nextInt(ALLOWED_CHARACTERS.length())));
    return builder.toString();
    }
  }

প্রশ্নটি

আসলে কাজ করে এমন সাধারণ সমস্যাটির সমাধান সম্পর্কে কি কেউ জানেন?

এমনকি এমন একটি সমাধানে যা আমি কম লিখেছি তার বৈশিষ্ট্যগুলি উদাহরণস্বরূপ এমন একটি যা কেবলমাত্র ধ্রুবক পাঠ্য রেখা থাকে এবং তার ফন্টটিকে তার আকার অনুসারে সামঞ্জস্য করে, তবুও কখনও অদ্ভুত বিভ্রান্তি থাকে না এবং পাঠ্যটি খুব বেশি পাওয়া যায় না বৃহত / ছোট তার উপলব্ধ স্থানের তুলনায়।


গিটহাব প্রকল্প

যেহেতু এটি একটি গুরুত্বপূর্ণ টেক্সটভিউ, তাই আমি একটি লাইব্রেরি প্রকাশের সিদ্ধান্ত নিয়েছি, যাতে প্রত্যেকে সহজেই এটি ব্যবহার করতে এবং এখানে অবদান রাখতে পারে ।


আপনি এই এক চেষ্টা করছেন? androidviews.net/2012/12/autoscale-textview
Thrakbad

@ থ্রাকবাদ এটি লিঙ্কগুলির মধ্যে একটি উল্লেখ করেছি। এটি পরীক্ষায়ও পাস করে না।
অ্যান্ড্রয়েড বিকাশকারী

আহ দুঃখিত, আমি শেষ উদাহরণটি কোনওভাবেই মিস করেছি
থ্রাকবাদ

হ্যাঁ, দয়া করে বিশ্বাস করুন, আমি প্রচুর নমুনা চেষ্টা করেছি এবং আমি যে সমস্যাগুলি পেয়েছি তা ঠিক করার জন্য সেগুলি সংশোধন করার চেষ্টা করেছি, তবে কখনও সফল হয়নি। যদি আপনি এমন কোনও কিছু খুঁজে পান যা আপনার মনে হয় কাজ করে তবে দয়া করে এটি পরীক্ষা করে দেখুন। আমি ঠিক এই জন্য একটি নমুনা কোড পোস্ট করেছি।
অ্যান্ড্রয়েড বিকাশকারী

1
@ অরুল এটি পোস্টগুলির মধ্যে একটি যা আমি ইতিমধ্যে পড়েছি এবং আমি কোডের সমস্ত নমুনা পরীক্ষা করেছি। এছাড়াও আমি মনে করি আপনি ডাবল পোস্ট করেছেন।
অ্যান্ড্রয়েড বিকাশকারী 18

উত্তর:


147

MartinH সরল ফিক্স ধন্যবাদ এখানে , এই কোড এছাড়াও যত্ন নেয় android:drawableLeft, android:drawableRight, android:drawableTopএবং android:drawableBottomট্যাগ।


এখানে আমার উত্তর আপনাকে বাউন্ডের মধ্যে ফিট করতে অটো স্কেল টেক্সটভিউ পাঠ্যকে খুশি করতে হবে

আমি আপনার পরীক্ষার কেসটি পরিবর্তন করেছি:

@Override
protected void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    final ViewGroup container = (ViewGroup) findViewById(R.id.container);
    findViewById(R.id.button1).setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(final View v) {
            container.removeAllViews();
            final int maxWidth = container.getWidth();
            final int maxHeight = container.getHeight();
            final AutoResizeTextView fontFitTextView = new AutoResizeTextView(MainActivity.this);
            final int width = _random.nextInt(maxWidth) + 1;
            final int height = _random.nextInt(maxHeight) + 1;
            fontFitTextView.setLayoutParams(new FrameLayout.LayoutParams(
                    width, height));
            int maxLines = _random.nextInt(4) + 1;
            fontFitTextView.setMaxLines(maxLines);
            fontFitTextView.setTextSize(500);// max size
            fontFitTextView.enableSizeCache(false);
            fontFitTextView.setBackgroundColor(0xff00ff00);
            final String text = getRandomText();
            fontFitTextView.setText(text);
            container.addView(fontFitTextView);
            Log.d("DEBUG", "width:" + width + " height:" + height
                    + " text:" + text + " maxLines:" + maxLines);
        }
    });
}

আমি প্রতি অ্যান্ড্রয়েড বিকাশকারীর অনুরোধে কোড পোস্ট করছি :

চূড়ান্ত প্রভাব:

এখানে চিত্র বিবরণ লিখুন

নমুনা বিন্যাস ফাইল:

<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>

এবং জাভা কোড:

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 mInitializedDimens;

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

    @Override
    public void setTextSize(float size) {
        mMaxTextSize = size;
        mTextCachedSizes.clear();
        adjustTextSize();
    }

    @Override
    public void setMaxLines(int maxlines) {
        super.setMaxLines(maxlines);
        mMaxLines = maxlines;
        adjustTextSize();
    }

    public int getMaxLines() {
        return mMaxLines;
    }

    @Override
    public void setSingleLine() {
        super.setSingleLine();
        mMaxLines = 1;
        adjustTextSize();
    }

    @Override
    public void setSingleLine(boolean singleLine) {
        super.setSingleLine(singleLine);
        if (singleLine) {
            mMaxLines = 1;
        } else {
            mMaxLines = NO_LINE_LIMIT;
        }
        adjustTextSize();
    }

    @Override
    public void setLines(int lines) {
        super.setLines(lines);
        mMaxLines = lines;
        adjustTextSize();
    }

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

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

    private void adjustTextSize() {
        if (!mInitializedDimens) {
            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);
        }
        int key = getText().toString().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 the 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);
        adjustTextSize();
    }

    @Override
    protected void onSizeChanged(int width, int height, int oldwidth,
            int oldheight) {
        mInitializedDimens = true;
        mTextCachedSizes.clear();
        super.onSizeChanged(width, height, oldwidth, oldheight);
        if (width != oldwidth || height != oldheight) {
            adjustTextSize();
        }
    }
}

সতর্কতা:

যদিও অ্যান্ড্রয়েড ৩.১ (মধুযন্ত্র) এর সমাধান হওয়া বাগটি থেকে সাবধান থাকুন ।


ঠিক আছে, আমি কোডটি পরীক্ষা করে দেখেছি এবং এটি ঠিক আছে। তবে, আপনি getMaxLines () ব্যবহার করেছেন, যা এপিআই 16 এর জন্য, তবে আপনি ম্যাক্সলাইনগুলি সঞ্চয় করতে পারেন এবং সেটম্যাক্সলাইনকে ওভাররাইড করে এটির মানটি সংরক্ষণ করতে পারেন i এটি পরিবর্তন করেছে এবং এখন এটি দুর্দান্ত কাজ করে। এছাড়াও, যেহেতু কখনও কখনও পাঠ্যটি ক্ষুদ্রতম আকারের জন্য আরও দীর্ঘ হয়, তাই আমি সেটলিপসাইজ ব্যবহার করার চেষ্টা করেছি এবং এটিও কার্যকর হয়েছে! আমি মনে করি আমাদের বিজয়ী আছে। আপনার কোডটি এখানে পোস্ট করুন যাতে আমি এটিকে সঠিক হিসাবে চিহ্নিত করতে পারি।
অ্যান্ড্রয়েড বিকাশকারী

আপনি getMaxLines () সরান নি এবং নিজের ব্যবহার করেছেন। এটি এখনও কেবল API16 থেকে কাজ করবে ... দয়া করে এটিকে পরিবর্তন করুন যাতে প্রত্যেকে এটি ব্যবহার করতে পারে। আমি ক্ষেত্রের প্যারামিটারটি সঞ্চয় করতে সেটম্যাক্সলাইনগুলি ওভাররাইড করার পরামর্শ দিই এবং পরে getMaxLines ব্যবহার না করে ফিল্ডটি অ্যাক্সেস করতে পারি।
অ্যান্ড্রয়েড বিকাশকারী

এখনই পরীক্ষা করুন, সর্বাধিক লাইনের জন্য সমর্থন যুক্ত করুন।
এম ওয়াজেই

ভাল লাগছে। অন্টেষ্টাইজ () পদ্ধতিতে আপনার "@ টার্গেটএপি (বিল্ড.ভর্জন_কোডেস.জেল্লি_বিইএন)" যুক্ত করা উচিত যাতে লিন্ট এটি সম্পর্কে কোনও ত্রুটি / সতর্কতা না দেয় এবং পরিবর্তে এটি সিটিওআর-এ সূচনা করে। বাইনারি অনুসন্ধান স্থিতিশীল সেট করা একটি ভাল জিনিস, এবং আপনি বৃহত্তম সিটিওআর থেকে সূচনা করতে এবং অন্যান্য সিটিওআর থেকে কল করতে পারেন। তবে এটি সত্যই সেরা উত্তর এবং আপনি একটি ভি এর প্রাপ্য। এই পুরানো প্রশ্নের জন্য শেষ পর্যন্ত এটি একটি ভাল উত্তর। ভাল করেছ!
অ্যান্ড্রয়েড বিকাশকারী

@ এম-ওয়াজেইহ এই থ্রেডে নতুন পোস্টটি পরীক্ষা করুন। "মার্টিনএইচ" নামে পরিচিত একজন ব্যবহারকারী বলেছেন যে আপনার কোডের জন্য তার একটি ঠিক আছে।
অ্যান্ড্রয়েড বিকাশকারী

14

আমি এম-ওয়াজেইএইচ এর উত্তরকে কিছুটা সংশোধন করে পাশের দিকের যৌগিক ড্রয়াবলগুলি গ্রহণ করতে পারি।

getCompoundPaddingXXXX()পদ্ধতি ফিরে আসতে padding of the view + drawable space। উদাহরণস্বরূপ দেখুন: টেক্সটভিউ.জেটকম্পাউন্ডপ্যাডিং লেফ্ট ()

সমস্যা: এটি পাঠ্যের জন্য উপলব্ধ টেক্সটভিউ জায়গার প্রস্থ এবং উচ্চতার পরিমাপ স্থির করে। আমরা যদি অঙ্কনযোগ্য আকারটি অ্যাকাউন্টে না নিই তবে এটিকে উপেক্ষা করা হবে এবং পাঠ্যটি আঁকুনযোগ্যকে ওভারল্যাপ করে শেষ করবে।


আপডেট বিভাগ adjustTextSize(String):

private void adjustTextSize(final String text) {
  if (!mInitialized) {
    return;
  }
  int heightLimit = getMeasuredHeight() - getCompoundPaddingBottom() - getCompoundPaddingTop();
  mWidthLimit = getMeasuredWidth() - getCompoundPaddingLeft() - getCompoundPaddingRight();

  mAvailableSpaceRect.right = mWidthLimit;
  mAvailableSpaceRect.bottom = heightLimit;

  int maxTextSplits = text.split(" ").length;
  AutoResizeTextView.super.setMaxLines(Math.min(maxTextSplits, mMaxLines));

  super.setTextSize(
      TypedValue.COMPLEX_UNIT_PX,
      binarySearch((int) mMinTextSize, (int) mMaxTextSize,
                   mSizeTester, mAvailableSpaceRect));
}

আপনি এম-ওয়াজেইএইচ এর উত্স আপডেট করেছেন। কেন আপনি এটি একটি নতুন উত্তর হিসাবে রাখা? আমি জানি আপনার ভাল ইচ্ছা আছে, তবে এটি উত্তর হিসাবে রাখা ভাল জিনিস? আমি নিশ্চিত না যে সে আপনার উত্তরটি লক্ষ্য করতে পারে ...
অ্যান্ড্রয়েড বিকাশকারী

1
আমি আপডেটটি সরবরাহ করতে সক্ষম হতে সাইন আপ করেছি। আমার খ্যাতি গণনা কেবল 1 এর যা আমার নয় এমন পোস্টগুলিতে মন্তব্য করতে বাধা দেয় (সর্বনিম্ন 15)।
মার্টিন এইচ

কোনও উদ্বেগ নেই, সম্ভবত আপনি আমার উত্তর এম-ওয়াজেইহে প্রেরণ করতে চান কারণ আমি এই মুহুর্তে তার সাথে যোগাযোগ করতেও পারি না: /
মার্টিন এইচ

আপনি কি দয়া করে আরও ভাল করে বর্ণনা করার চেষ্টা করতে পারেন? আপনি কি একটি বাগ ঠিক করেছেন? আপনি বাগ প্রদর্শন করতে একটি স্ক্রিনশট প্রদর্শন করতে পারেন?
অ্যান্ড্রয়েড বিকাশকারী

1
হাই @ মার্টিন এইচ, তাই আপনাকে স্বাগতম আমি এটিকে গুরুত্ব সহকারে দেখব এবং পরীক্ষার পরে আপনার নাম উল্লেখ করে এবং আপনার পোস্টে লিঙ্কটি পোস্ট করে আমার উত্তর আপডেট করব । দয়া করে আমাকে কিছু দিন দিন। আমি আজকাল অন্য কোথাও আটকে আছি।
এম-ওয়াজেইহ

7

ঠিক আছে আমি শেষ সপ্তাহে আপনার কোডটি সঠিকভাবে আপনার পরীক্ষায় ফিট করতে আমার কোডটি পুনরায় লেখার জন্য ব্যবহার করেছি । আপনি এখন এটি 1: 1 অনুলিপি করতে পারেন এবং এটি অবিলম্বে কাজ করবে - সহ setSingleLine()। দয়া করে মনে রাখবেন সামঞ্জস্য করতে MIN_TEXT_SIZEএবং MAX_TEXT_SIZEযদি আপনি চূড়ান্ত মানগুলির জন্য যাচ্ছেন।

রূপান্তরকরণ অ্যালগরিদম এর মতো দেখাচ্ছে:

for (float testSize; (upperTextSize - lowerTextSize) > mThreshold;) {

    // Go to the mean value...
    testSize = (upperTextSize + lowerTextSize) / 2;

    // ... inflate the dummy TextView by setting a scaled textSize and the text...
    mTestView.setTextSize(TypedValue.COMPLEX_UNIT_SP, testSize / mScaledDensityFactor);
    mTestView.setText(text);

    // ... call measure to find the current values that the text WANTS to occupy
    mTestView.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
    int tempHeight = mTestView.getMeasuredHeight();

    // ... decide whether those values are appropriate.
    if (tempHeight >= targetFieldHeight) {
        upperTextSize = testSize; // Font is too big, decrease upperSize
    }
    else {
        lowerTextSize = testSize; // Font is too small, increase lowerSize
    }
}

এবং পুরো ক্লাস এখানে পাওয়া যাবে।

ফলাফলটি এখন খুব নমনীয়। এটি যেমন xML তে ঘোষিত একইরকম কাজ করে:

<com.example.myProject.AutoFitText
    android:id="@+id/textView"
    android:layout_width="match_parent"
    android:layout_height="0dp"
    android:layout_weight="4"
    android:text="@string/LoremIpsum" />

... পাশাপাশি প্রোগ্রাম হিসাবে আপনার পরীক্ষা হিসাবে নির্মিত।

আমি সত্যিই আপনি এখন এটি ব্যবহার করতে পারেন আশা করি। setText(CharSequence text)উপায় দ্বারা এটি ব্যবহার করার জন্য আপনি এখন কল করতে পারেন। বর্গ stupendously বিরল ব্যতিক্রম যত্ন নেয় এবং রক-কঠিন হওয়া উচিত। অ্যালগরিদম এখনও সমর্থন করে না যে একমাত্র জিনিস :

  • কল setMaxLines(x)যেখানেx >= 2

তবে আপনি যদি এটি করতে চান তবে আপনাকে এটি তৈরিতে সহায়তা করতে আমি বিস্তৃত মন্তব্য যুক্ত করেছি!


দয়া করে নোট করুন:

আপনি যদি এটি কেবলমাত্র একটি লাইনে সীমাবদ্ধ না রেখে সাধারণভাবে এটি ব্যবহার করেন তবে আপনার আগে যেমন উল্লেখ করা হয়েছে তেমন শব্দ-বিরতি থাকতে পারে। এটি একটি অ্যান্ড্রয়েড বৈশিষ্ট্য , এর ত্রুটি নয়AutoFitText । অ্যান্ড্রয়েড সবসময় এমন শব্দগুলি ভাঙবে যা কোনও পাঠ্য দর্শনের জন্য খুব দীর্ঘ এবং এটি আসলে বেশ সুবিধা quite আপনি যদি এখানে হস্তক্ষেপ করতে চান তবে আমার মন্তব্যগুলি এবং কোডটি 203 লাইন থেকে শুরু করে দেখুন I ।

উপসংহারে: স্পেস চরগুলি সমর্থন করার জন্য আপনার পরীক্ষার পুনর্লিখনকে আপনার অত্যন্ত বিবেচনা করা উচিত, যেমন:

final Random _random = new Random();
final String ALLOWED_CHARACTERS = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
final int textLength = _random.nextInt(80) + 20;
final StringBuilder builder = new StringBuilder();
for (int i = 0; i < textLength; ++i) {
    if (i % 7 == 0 && i != 0) {
        builder.append(" ");
    }
    builder.append(ALLOWED_CHARACTERS.charAt(_random.nextInt(ALLOWED_CHARACTERS.length())));
}
((AutoFitText) findViewById(R.id.textViewMessage)).setText(builder.toString());

এটি খুব সুন্দর (এবং আরও বাস্তবসম্মত) ফলাফল আনবে।
আপনি এই বিষয়ে পাশাপাশি শুরু করতে মন্তব্য করতে পাবেন।

শুভকামনা এবং শুভেচ্ছা


কিছু সমস্যা আছে, কিন্তু সামগ্রিকভাবে এটি এত ভাল কাজ করে। সমস্যাগুলি: মাল্টি লাইন সমর্থন করে না (যেমনটি আপনি লিখেছেন) এবং শব্দটি আপনি যদি এটি করার চেষ্টা করেন তবে এটি ভেঙে দেবে, API16 ফাংশন (addOnGlobalLayoutListener) অন্তর্ভুক্ত করুন যা আমি মনে করি সম্পূর্ণরূপে এড়ানো যেতে পারে (বা কমপক্ষে অনপ্রেড্র্রলিস্টার ব্যবহার করুন), ব্যবহার বাইনারি অনুসন্ধান যাতে এটি আকারগুলি পরীক্ষা করতে পারে যা এটি একেবারেই ফিট হয় না (এবং অকারণে আরও বেশি মেমরি ব্যবহার করুন, যা খুব বড় হলে ব্যতিক্রম ঘটায়), যখন কোনও পরিবর্তন হয় তখন হ্যান্ডলিং সমর্থন করে না (যেমন পাঠ্য নিজেই)।
অ্যান্ড্রয়েড বিকাশকারী

বিটিডাব্লু, আপনাকে এমটেষ্টভিউ ভেরিয়েবলটি ব্যবহার করতে হবে না এবং সরাসরি বর্তমান ভিউতে পরীক্ষা করতে হবে এবং এইভাবে আপনাকে বিশেষ সমস্ত বিষয় বিবেচনা করতে হবে না। এছাড়াও, আমি মনে করি যে MAX_TEXT_SIZE এর পরিবর্তে আপনি লক্ষ্যফিল্ডহাইটটি ব্যবহার করতে পারেন।
অ্যান্ড্রয়েড বিকাশকারী

আমি মনে করি যে খাঁটি বাইনারি অনুসন্ধানের পরিবর্তে (বিশেষত এর মধ্যে ২) পরিবর্তিত আকারের বিপরীতে লক্ষ্য অনুপাতে আপনি আরও ভাল অনুমান করতে পারেন। এছাড়াও অন্যান্য পদ্ধতি রয়েছে (নিউটন এবং অন্য কিছু যা আমি মনে করি না) তবে আমি মনে করি না তারা এখানে ফিট করে। আমি এখন প্রস্তাবিতটি আরও ভাল, যেহেতু আপনি সর্বোচ্চ আকার পরীক্ষা করার পরিবর্তে ন্যূনতম আকার থেকে শুরু করতে পারেন act ফ্যাক্টটি হ'ল আপনি আরও ভাল অনুমান করা চালিয়ে যাওয়ার কারণে আপনার সর্বোচ্চ আকারের প্রয়োজন হবে না।
অ্যান্ড্রয়েড বিকাশকারী

আমি আরও মনে করি যে 2 বাইনারি অনুসন্ধানগুলি একক লাইনে একত্রিত হতে পারে যখন শর্তটি সহজভাবে হতে পারে: যদি (getMeasuredWidth ()> = টার্গেটফিল্ড উইথ) getMeasuredHeight ()> = লক্ষ্যফিল্ডহাইট)
অ্যান্ড্রয়েড বিকাশকারী

1
আর একটি সমস্যা যা আমি পেয়েছি তা হ'ল পাঠ্য মাধ্যাকর্ষণ। আমি মনে করি এটি উল্লম্বভাবে কেন্দ্রীভূত করা যায় না।
অ্যান্ড্রয়েড বিকাশকারী

4

আমার প্রয়োজন হয়

  • স্কেলেবলটেক্সটভিউতে ক্লিক করুন
  • একটি তালিকা খুলুন কার্যকলাপ এবং দৈর্ঘ্যের বিভিন্ন স্ট্রিং আইটেম প্রদর্শন করুন।
  • তালিকা থেকে একটি পাঠ্য নির্বাচন করুন।
  • অন্য ক্রিয়াকলাপটিতে পাঠ্যটিকে স্কেলবেটেক্সটভিউতে ফিরে সেট করুন।

আমি লিঙ্কটি উল্লেখ করেছি: স্বতঃ স্কেল টেক্সটভিউ পাঠ্যটিকে সীমানাগুলির মধ্যে ফিট করার জন্য (মন্তব্যগুলি সহ) এবং ডায়ালগটিটেল.জভা

আমি দেখতে পেয়েছি যে প্রদত্ত সমাধানটি দুর্দান্ত এবং সহজ তবে এটি পাঠ্য বাক্সের আকার পরিবর্তন করে না। তালিকাটি থেকে নির্বাচিত পাঠ্যের দৈর্ঘ্যটি বিদ্যমান পাঠ্য দৈর্ঘ্যের চেয়ে আকারে বড় হলে এটি দুর্দান্ত কাজ করেScalableTextView । পাঠ্যটিতে বিদ্যমান পাঠ্যের চেয়ে দৈর্ঘ্য ছোট হওয়া নির্বাচন করা হলে এটি পাঠ্যের ScalableTextViewআকারকে বাড়িয়ে দেয় না, পাঠ্যকে ছোট আকারে দেখায়।

আমি পাঠ্যের দৈর্ঘ্যের উপর ভিত্তি করে পাঠ্যের আকারটিকে সামঞ্জস্য করতে স্কেলবেটেক্সটভিউ.জভা পরিবর্তন করেছি। এখানে আমারScalableTextView.java

public class ScalableTextView extends TextView
{
float defaultTextSize = 0.0f;

public ScalableTextView(Context context, AttributeSet attrs, int defStyle)
{
    super(context, attrs, defStyle);
    setSingleLine();
    setEllipsize(TruncateAt.END);
    defaultTextSize = getTextSize();
}

public ScalableTextView(Context context, AttributeSet attrs)
{
    super(context, attrs);
    setSingleLine();
    setEllipsize(TruncateAt.END);
    defaultTextSize = getTextSize();
}

public ScalableTextView(Context context)
{
    super(context);
    setSingleLine();
    setEllipsize(TruncateAt.END);
    defaultTextSize = getTextSize();
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
    setTextSize(TypedValue.COMPLEX_UNIT_PX, defaultTextSize);
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);

    final Layout layout = getLayout();
    if (layout != null)
    {
        final int lineCount = layout.getLineCount();
        if (lineCount > 0)
        {
            int ellipsisCount = layout.getEllipsisCount(lineCount - 1);
            while (ellipsisCount > 0)
            {
                final float textSize = getTextSize();

                // textSize is already expressed in pixels
                setTextSize(TypedValue.COMPLEX_UNIT_PX, (textSize - 1));

                super.onMeasure(widthMeasureSpec, heightMeasureSpec);
                ellipsisCount = layout.getEllipsisCount(lineCount - 1);
            }
        }
    }
}
}

শুভ কোডিং ....


আপনার প্রতিটি পুনরাবৃত্তির জন্য একটি করে কমানোর পরিবর্তে বাইনারি অনুসন্ধান ব্যবহার করে করা উচিত নয়? এছাড়াও, মনে হয় যে এই কোডটি একাধিক লাইন রাখার পরিবর্তে টেক্সটভিউকে একক পাঠ্য পাঠের সাথে থাকতে বাধ্য করে।
অ্যান্ড্রয়েড বিকাশকারী

এটি আমার জন্য কাজ করা একমাত্র সমাধান ছিল। আমার সমস্যা সম্পর্কিত ছিল টেক্সটভিউয়ের সাথে কেবল 4.1-এ দৃশ্যটি মানানসই নয়
ফলিভিরা

দেখে মনে হচ্ছে এটি 100% এর সাথে পিতামাতার সাথে মেলে না। স্ক্রিনশটটি দেখুন: s14.postimg.org/93c2xgs75/Screenshot_2.png
ব্যবহারকারী 25

4

আমি ব্যাখ্যা করব কীভাবে এই অ্যাট্রিবিউটটি অ্যান্ড্রয়েড সংস্করণগুলি ধাপে ধাপে কাজ করে:

1- আপনার প্রকল্প গ্রেড ফাইলটিতে অ্যান্ড্রয়েড সমর্থন লাইব্রেরি 26.xx আমদানি করুন। আইডিইতে কোনও সমর্থন লাইব্রেরি না থাকলে সেগুলি স্বয়ংক্রিয়ভাবে ডাউনলোড হবে।

dependencies {
    compile 'com.android.support:support-v4:26.1.0'
    compile 'com.android.support:appcompat-v7:26.1.0'
    compile 'com.android.support:support-v13:26.1.0' }

allprojects {
    repositories {
        jcenter()
        maven {
            url "https://maven.google.com"
        }
    } }

2- আপনার লেআউটটি এক্সএমএল ফাইলটি খুলুন এবং এই ট্যাবটিকে আপনার পাঠ্যদর্শন মত রিফ্যাক্টর করুন। এই দৃশ্যটি হ'ল: সিস্টেমে যখন ফন্টের আকার অন্তর্ভুক্ত থাকে তখন শুল্কের মোড়কে নয়, প্রাপ্য প্রস্থের সাথে পাঠ্যকে ফিট করে।

<android.support.v7.widget.AppCompatTextView
            android:id="@+id/textViewAutoSize"
            android:layout_width="match_parent"
            android:layout_height="25dp"
            android:ellipsize="none"
            android:text="Auto size text with compatible lower android versions."
            android:textSize="12sp"
            app:autoSizeMaxTextSize="14sp"
            app:autoSizeMinTextSize="4sp"
            app:autoSizeStepGranularity="0.5sp"
            app:autoSizeTextType="uniform" />

তাদের স্বতঃ-ফিট টেক্সটভিউ বাস্তবায়ন যদিও ভাল কাজ করে না। অনেক সময় আছে যে ফন্টের আকারের আকার পরিবর্তনের পরিবর্তে, পাঠ্যটি কেবলমাত্র পরবর্তী লাইনে আবৃত হয়, খারাপভাবে ... এমনকি এটি তাদের ভিডিওতে দেখানো হয়, যেমন এটি একটি ভাল জিনিস: youtu.be/fjUdJ2aVqE4?t=14 । লক্ষ্য করুন "টেক্সটভিউ" এর "ডাব্লু" কীভাবে পরের লাইনে চলে যায় ... যাইহোক, এটি সম্পর্কে এখানে একটি নতুন অনুরোধ তৈরি করা হয়েছে: ইস্যুজেট্রেকার জিওলাইজি / সিসি / 68787108 । এটি অভিনীত দয়া করে বিবেচনা করুন।
অ্যান্ড্রয়েড বিকাশকারী

পছন্দ করুন আমি এই ট্যাগটি প্রয়োগ একক লাইন কাজ করে ব্যাখ্যা না। আপনার যদি মোড়ানো লাইনগুলির প্রয়োজন হয় তবে আপনাকে এই বৈশিষ্ট্যটি পরিবর্তন করতে হবে: অ্যান্ড্রয়েড: লেআউট_হাইট = "র‌্যাপ_কন্টেন্ট"। তবে android.support.v7.widget.appCompatTextView এবং গ্রেড বাস্তবায়ন গ্যারান্টি এই বৈশিষ্ট্যটির সাথে কাজ করে।
সিনান আর্গিন

আমি বুঝতে পারি না আপনি বুঝতে পেরেছেন। আমি চাই না যে পার্ট-ওয়ার্ডগুলি পরের লাইনে মোড়ানো হোক, যদি না এটি সমাধানের কোনও উপায় না থাকে। ভিডিওতে, আপনি সহজেই দেখতে পারবেন হরফগুলির পরিবর্তে ফন্টগুলি আরও ছোট হয়ে উঠতে পারে। এটাই সমস্যা। আপনি কি বলছেন যে আপনি এটি ঠিক করতে জানেন? অর্থ এখানে শব্দ মোড়ানো হবে না, এবং শুধুমাত্র ফন্টের আকার পরিবর্তন হবে?
অ্যান্ড্রয়েড বিকাশকারী

@ অ্যান্ড্রয়েড ডেভেলপার অনেকগুলি দৃশ্য রয়েছে। আমার পরিস্থিতিটি হ'ল শব্দ মোড়কের সাথে না করে অটোফিট পাঠ্য স্থির করা। সিস্টেম হরফ আকারটি বিপর্যস্ত করার সময়, পাঠ্যকে পাঠ্যদর্শনটিতে শব্দ র‌্যাপ নয় show যদি শব্দ মোড়ানো আপনার পক্ষে গুরুত্বপূর্ণ না হয় তবে নির্দিষ্ট উচ্চতা নির্ধারণ করবেন না। এই সম্পত্তিটি কেবল শব্দ মোড়ানো ব্যবহার করে না, আপনি পাঠ্যের স্বতঃসংশোধন পাঠ্যদর্শনকে স্বতঃপাদন করতে পারেন।
সিনান আর্গিন

আমার পরীক্ষাগুলি অনুসারে, ফন্টের আকারগুলি সঠিকভাবে পরিবর্তিত হয় না, এবং মোড়ক শব্দটি ঘটতে পারে।
অ্যান্ড্রয়েড বিকাশকারী

3

সতর্কতা, অ্যান্ড্রয়েড 3 (হানিকম্ব) এবং অ্যান্ড্রয়েড 4.0 (আইসক্রিম স্যান্ডউইচ) এ বাগ

অ্যান্ড্রয়েড সংস্করণ: 3.1 - 4.04 এর মধ্যে একটি বাগ রয়েছে যা টেক্সটভিউয়ের অভ্যন্তরে সেটটেক্সট সাইজ () কেবলমাত্র প্রথমবারের জন্য (প্রথম অনুরোধ) কাজ করে।

বাগ বর্ণনা করা হয় ইস্যু 22493: Android এর 4.0 মধ্যে TextView উচ্চতা বাগ এবং ইস্যু 17343: বোতাম উচ্চতা এবং টেক্সট বৃদ্ধি পরে এটির আসল অবস্থায় ফেরত দেয় না এবং Honeycomb টেক্সট আকার হ্রাস

কাজের পরিবর্তনটি আকার পরিবর্তন করার আগে টেক্সটভিউতে নির্ধারিত পাঠ্যে একটি নতুন লাইন চরিত্র যুক্ত করা হয়:

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

আমি নিম্নলিখিত হিসাবে এটি আমার কোড এ ব্যবহার:

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

এটি কেন্দ্রিক রাখতে আমি এই লেখার বাম এবং ডানদিকে এই "\ u3000" অক্ষরটি যুক্ত করছি। যদি আপনার এটি বামে সারিবদ্ধ থাকে তবে কেবল ডানদিকে যুক্ত করুন। অবশ্যই এটি অটোরেজিটেক্সটভিউ উইজেটের সাথে এম্বেড করা যেতে পারে, তবে আমি স্থির কোডটি বাইরে রাখতে চেয়েছিলাম।


আপনি দয়া করে কোন লাইনে (কোন লাইনের আগে / পরে) এবং কোন কার্যক্রমে হুবহু দেখাতে পারেন?
অ্যান্ড্রয়েড বিকাশকারী

ঠিক আছে ধন্যবাদ. আমি আশা করি এটি সবকিছু ঠিক করে দেয় এবং যে কেউ এটি পড়বে এটি সহায়ক হবে। বর্তমানে আমি এটি পরীক্ষা করতে পারছি না সম্ভবত পরবর্তী সময় যে আমি এটি ব্যবহার করব।
অ্যান্ড্রয়েড বিকাশকারী

এই কোডটি ভিউ কোডের বাইরে থেকে কল করা হয়েছে। পরিবর্তে ভিউ কোডের অভ্যন্তরে এটি হ্যান্ডেল করার কোনও ভাল বিকল্প উপায় আপনি কি জানেন?
অ্যান্ড্রয়েড বিকাশকারী

আপনি টেক্সটভিউ.সেটটেক্সট () টি ওভাররাইড করতে পারেন এবং এই কোডটি টেক্সটভিউ ক্লাসের ভিতরে রেখেছিলেন
মালাচিয়াজ

এটির অর্থ কি এই নয় যে "getText ()" অতিরিক্ত অক্ষর দিয়ে পাঠ্যটি ফেরত দেবে?
অ্যান্ড্রয়েড বিকাশকারী

3

এই সমস্যার সরকারী সমাধান এখন আছে। অ্যান্ড্রয়েড ও এর সাথে প্রবর্তিত অটোসাইজিং টেক্সটভিউগুলি সাপোর্ট লাইব্রেরি 26 এ উপলব্ধ এবং অ্যান্ড্রয়েড 4.0.০ এ সমস্ত দিক থেকে সামঞ্জস্যপূর্ণ।

https://developer.android.com/preview/features/autosizing-textview.html

আমি নিশ্চিত নই কেন https://stackoverflow.com/a/42940171/47680 যা এই তথ্য অন্তর্ভুক্ত করেছে একজন প্রশাসক দ্বারা মুছে ফেলা হয়েছে।


1
হ্যাঁ, আমি এটি সম্পর্কে শুনেছি, তবে এটি কতটা ভাল? এটি ব্যবহারের কোনও নমুনা আছে? এমনকি তাদের ভিডিওতেও আমি একটি ত্রুটি লক্ষ্য করেছি: এক শব্দের একটি চিঠি লাইনের পরে এসে গেছে (মোড়ানো): youtu.be/1N9 কেভেজে- FU8?t=781 ("ডাব্লু" লক্ষ্য করুন)
অ্যান্ড্রয়েড বিকাশকারী

3

জুন 2018 থেকে অ্যান্ড্রয়েড আনুষ্ঠানিকভাবে অ্যান্ড্রয়েড 4.0 (এপিআই স্তর 14) এবং উচ্চতরগুলির জন্য এই বৈশিষ্ট্যটি সমর্থন করে
অ্যান্ড্রয়েড 8.0 (এপিআই স্তর 26) এবং উচ্চতর সহ:

setAutoSizeTextTypeUniformWithConfiguration(int autoSizeMinTextSize, int autoSizeMaxTextSize, 
        int autoSizeStepGranularity, int unit);

অ্যান্ড্রয়েড 8.0 এর আগে অ্যান্ড্রয়েড সংস্করণগুলি (এপিআই স্তর 26):

TextViewCompat.setAutoSizeTextTypeUniformWithConfiguration(TextView textView,
int autoSizeMinTextSize, int autoSizeMaxTextSize, int autoSizeStepGranularity, int unit)

আমার বিস্তারিত উত্তর দেখুন


1

পাঠ্য দর্শনটিকে কোনও চিত্রে রূপান্তর করুন এবং সীমানার মধ্যে চিত্রকে স্কেল করুন।

এখানে একটি চিত্রকে কীভাবে একটি চিত্রে রূপান্তর করা যায় তার একটি উদাহরণ: অ্যান্ড্রয়েডে প্রদর্শন না করে কোনও দৃশ্যকে বিটম্যাপে রূপান্তর করা?

সমস্যাটি হচ্ছে, আপনার পাঠ্যটি নির্বাচনযোগ্য হবে না, তবে এটি কৌশলটি করা উচিত। আমি এটি চেষ্টা করে দেখিনি, সুতরাং এটি কীভাবে দেখাবে তা আমি নিশ্চিত নই (স্কেলিংয়ের কারণে)।


এটি একটি দুর্দান্ত ধারণা, তবে এটি পাঠ্যকে পিক্সিলিয়েটেড করে তুলবে এবং পাঠ্য ভিউয়ের সাহায্যে যে কোনও বৈশিষ্ট্য আমি ব্যবহার করতে পারি তা সরিয়ে ফেলবে।
অ্যান্ড্রয়েড বিকাশকারী

0

নীচে কাস্টম ফন্টের জন্য যুক্ত কার্যকারিতা সহ অবলঞ্চ পাঠ্য ভিউ রয়েছে।

ব্যবহার:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:foo="http://schemas.android.com/apk/res-auto"
    android:layout_width="wrap_content"
    android:layout_height="match_parent" >

                <de.meinprospekt.androidhd.view.AutoFitText
                android:layout_width="wrap_content"
                android:layout_height="10dp"
                android:text="Small Text"
                android:textColor="#FFFFFF"
                android:textSize="100sp"
                foo:customFont="fonts/Roboto-Light.ttf" />

</FrameLayout>

যুক্ত করতে ভুলবেন না: xmlns: foo = "http://schemas.android.com/apk/res-auto"। ফন্ট সম্পদ আগুনে রাখতে হবে

import java.util.ArrayList;
import java.util.List;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.View;
import android.view.ViewGroup.LayoutParams;
import android.view.ViewTreeObserver;
import android.view.ViewTreeObserver.OnGlobalLayoutListener;
import android.widget.TextView;
import de.meinprospekt.androidhd.R;
import de.meinprospekt.androidhd.adapter.BrochuresHorizontalAdapter;
import de.meinprospekt.androidhd.util.LOG;

/**
 * https://stackoverflow.com/a/16174468/2075875 This class builds a new android Widget named AutoFitText which can be used instead of a TextView to
 * have the text font size in it automatically fit to match the screen width. Credits go largely to Dunni, gjpc, gregm and speedplane from
 * Stackoverflow, method has been (style-) optimized and rewritten to match android coding standards and our MBC. This version upgrades the original
 * "AutoFitTextView" to now also be adaptable to height and to accept the different TextView types (Button, TextClock etc.)
 * 
 * @author pheuschk
 * @createDate: 18.04.2013
 * 
 * combined with: https://stackoverflow.com/a/7197867/2075875
 */
@SuppressWarnings("unused")
public class AutoFitText extends TextView {

    private static final String TAG = AutoFitText.class.getSimpleName();

    /** Global min and max for text size. Remember: values are in pixels! */
    private final int MIN_TEXT_SIZE = 10;
    private final int MAX_TEXT_SIZE = 400;

    /** Flag for singleLine */
    private boolean mSingleLine = false;

    /**
     * A dummy {@link TextView} to test the text size without actually showing anything to the user
     */
    private TextView mTestView;

    /**
     * A dummy {@link Paint} to test the text size without actually showing anything to the user
     */
    private Paint mTestPaint;

    /**
     * Scaling factor for fonts. It's a method of calculating independently (!) from the actual density of the screen that is used so users have the
     * same experience on different devices. We will use DisplayMetrics in the Constructor to get the value of the factor and then calculate SP from
     * pixel values
     */
    private float mScaledDensityFactor;

    /**
     * Defines how close we want to be to the factual size of the Text-field. Lower values mean higher precision but also exponentially higher
     * computing cost (more loop runs)
     */
    private final float mThreshold = 0.5f;

    /**
     * Constructor for call without attributes --> invoke constructor with AttributeSet null
     * 
     * @param context
     */
    public AutoFitText(Context context) {
        this(context, null);
    }

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

    public AutoFitText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context, attrs);
    }

    private void init(Context context, AttributeSet attrs) {
        //TextViewPlus part https://stackoverflow.com/a/7197867/2075875
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.AutoFitText);
        String customFont = a.getString(R.styleable.AutoFitText_customFont);
        setCustomFont(context, customFont);
        a.recycle();

        // AutoFitText part
        mScaledDensityFactor = context.getResources().getDisplayMetrics().scaledDensity;
        mTestView = new TextView(context);

        mTestPaint = new Paint();
        mTestPaint.set(this.getPaint());

        this.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {

            @Override
            public void onGlobalLayout() {
                // make an initial call to onSizeChanged to make sure that refitText is triggered
                onSizeChanged(AutoFitText.this.getWidth(), AutoFitText.this.getHeight(), 0, 0);
                // Remove the LayoutListener immediately so we don't run into an infinite loop
                //AutoFitText.this.getViewTreeObserver().removeOnGlobalLayoutListener(this);
                removeOnGlobalLayoutListener(AutoFitText.this, this);
            }
        });
    }

    public boolean setCustomFont(Context ctx, String asset) {
        Typeface tf = null;
        try {
        tf = Typeface.createFromAsset(ctx.getAssets(), asset);  
        } catch (Exception e) {
            LOG.e(TAG, "Could not get typeface: "+e.getMessage());
            return false;
        }

        setTypeface(tf);  
        return true;
    }

    @SuppressLint("NewApi")
    public static void removeOnGlobalLayoutListener(View v, ViewTreeObserver.OnGlobalLayoutListener listener){
        if (Build.VERSION.SDK_INT < 16) {
            v.getViewTreeObserver().removeGlobalOnLayoutListener(listener);
        } else {
            v.getViewTreeObserver().removeOnGlobalLayoutListener(listener);
        }
    }

    /**
     * Main method of this widget. Resizes the font so the specified text fits in the text box assuming the text box has the specified width. This is
     * done via a dummy text view that is refit until it matches the real target width and height up to a certain threshold factor
     * 
     * @param targetFieldWidth The width that the TextView currently has and wants filled
     * @param targetFieldHeight The width that the TextView currently has and wants filled
     */
    private void refitText(String text, int targetFieldWidth, int targetFieldHeight) {

        // Variables need to be visible outside the loops for later use. Remember size is in pixels
        float lowerTextSize = MIN_TEXT_SIZE;
        float upperTextSize = MAX_TEXT_SIZE;

        // Force the text to wrap. In principle this is not necessary since the dummy TextView
        // already does this for us but in rare cases adding this line can prevent flickering
        this.setMaxWidth(targetFieldWidth);

        // Padding should not be an issue since we never define it programmatically in this app
        // but just to to be sure we cut it off here
        targetFieldWidth = targetFieldWidth - this.getPaddingLeft() - this.getPaddingRight();
        targetFieldHeight = targetFieldHeight - this.getPaddingTop() - this.getPaddingBottom();

        // Initialize the dummy with some params (that are largely ignored anyway, but this is
        // mandatory to not get a NullPointerException)
        mTestView.setLayoutParams(new LayoutParams(targetFieldWidth, targetFieldHeight));

        // maxWidth is crucial! Otherwise the text would never line wrap but blow up the width
        mTestView.setMaxWidth(targetFieldWidth);

        if (mSingleLine) {
            // the user requested a single line. This is very easy to do since we primarily need to
            // respect the width, don't have to break, don't have to measure...

            /*************************** Converging algorithm 1 ***********************************/
            for (float testSize; (upperTextSize - lowerTextSize) > mThreshold;) {

                // Go to the mean value...
                testSize = (upperTextSize + lowerTextSize) / 2;

                mTestView.setTextSize(TypedValue.COMPLEX_UNIT_SP, testSize / mScaledDensityFactor);
                mTestView.setText(text);
                mTestView.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);

                if (mTestView.getMeasuredWidth() >= targetFieldWidth) {
                    upperTextSize = testSize; // Font is too big, decrease upperSize
                } else {
                    lowerTextSize = testSize; // Font is too small, increase lowerSize
                }
            }
            /**************************************************************************************/

            // In rare cases with very little letters and width > height we have vertical overlap!
            mTestView.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);

            if (mTestView.getMeasuredHeight() > targetFieldHeight) {
                upperTextSize = lowerTextSize;
                lowerTextSize = MIN_TEXT_SIZE;

                /*************************** Converging algorithm 1.5 *****************************/
                for (float testSize; (upperTextSize - lowerTextSize) > mThreshold;) {

                    // Go to the mean value...
                    testSize = (upperTextSize + lowerTextSize) / 2;

                    mTestView.setTextSize(TypedValue.COMPLEX_UNIT_SP, testSize / mScaledDensityFactor);
                    mTestView.setText(text);
                    mTestView.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);

                    if (mTestView.getMeasuredHeight() >= targetFieldHeight) {
                        upperTextSize = testSize; // Font is too big, decrease upperSize
                    } else {
                        lowerTextSize = testSize; // Font is too small, increase lowerSize
                    }
                }
                /**********************************************************************************/
            }
        } else {

            /*********************** Converging algorithm 2 ***************************************/
            // Upper and lower size converge over time. As soon as they're close enough the loop
            // stops
            // TODO probe the algorithm for cost (ATM possibly O(n^2)) and optimize if possible
            for (float testSize; (upperTextSize - lowerTextSize) > mThreshold;) {

                // Go to the mean value...
                testSize = (upperTextSize + lowerTextSize) / 2;

                // ... inflate the dummy TextView by setting a scaled textSize and the text...
                mTestView.setTextSize(TypedValue.COMPLEX_UNIT_SP, testSize / mScaledDensityFactor);
                mTestView.setText(text);

                // ... call measure to find the current values that the text WANTS to occupy
                mTestView.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
                int tempHeight = mTestView.getMeasuredHeight();
                // int tempWidth = mTestView.getMeasuredWidth();

                // LOG.debug("Measured: " + tempWidth + "x" + tempHeight);
                // LOG.debug("TextSize: " + testSize / mScaledDensityFactor);

                // ... decide whether those values are appropriate.
                if (tempHeight >= targetFieldHeight) {
                    upperTextSize = testSize; // Font is too big, decrease upperSize
                } else {
                    lowerTextSize = testSize; // Font is too small, increase lowerSize
                }
            }
            /**************************************************************************************/

            // It is possible that a single word is wider than the box. The Android system would
            // wrap this for us. But if you want to decide fo yourself where exactly to break or to
            // add a hyphen or something than you're going to want to implement something like this:
            mTestPaint.setTextSize(lowerTextSize);
            List<String> words = new ArrayList<String>();

            for (String s : text.split(" ")) {
                Log.i("tag", "Word: " + s);
                words.add(s);
            }
            for (String word : words) {
                if (mTestPaint.measureText(word) >= targetFieldWidth) {
                    List<String> pieces = new ArrayList<String>();
                    // pieces = breakWord(word, mTestPaint.measureText(word), targetFieldWidth);

                    // Add code to handle the pieces here...
                }
            }
        }

        /**
         * We are now at most the value of threshold away from the actual size. To rather undershoot than overshoot use the lower value. To match
         * different screens convert to SP first. See {@link http://developer.android.com/guide/topics/resources/more-resources.html#Dimension} for
         * more details
         */
        this.setTextSize(TypedValue.COMPLEX_UNIT_SP, lowerTextSize / mScaledDensityFactor);
        return;
    }

    /**
     * This method receives a call upon a change in text content of the TextView. Unfortunately it is also called - among others - upon text size
     * change which means that we MUST NEVER CALL {@link #refitText(String)} from this method! Doing so would result in an endless loop that would
     * ultimately result in a stack overflow and termination of the application
     * 
     * So for the time being this method does absolutely nothing. If you want to notify the view of a changed text call {@link #setText(CharSequence)}
     */
    @Override
    protected void onTextChanged(CharSequence text, int start, int lengthBefore, int lengthAfter) {
        // Super implementation is also intentionally empty so for now we do absolutely nothing here
        super.onTextChanged(text, start, lengthBefore, lengthAfter);
    }

    @Override
    protected void onSizeChanged(int width, int height, int oldWidth, int oldHeight) {
        if (width != oldWidth && height != oldHeight) {
            refitText(this.getText().toString(), width, height);
        }
    }

    /**
     * This method is guaranteed to be called by {@link TextView#setText(CharSequence)} immediately. Therefore we can safely add our modifications
     * here and then have the parent class resume its work. So if text has changed you should always call {@link TextView#setText(CharSequence)} or
     * {@link TextView#setText(CharSequence, BufferType)} if you know whether the {@link BufferType} is normal, editable or spannable. Note: the
     * method will default to {@link BufferType#NORMAL} if you don't pass an argument.
     */
    @Override
    public void setText(CharSequence text, BufferType type) {

        int targetFieldWidth = this.getWidth();
        int targetFieldHeight = this.getHeight();

        if (targetFieldWidth <= 0 || targetFieldHeight <= 0 || text.equals("")) {
            // Log.v("tag", "Some values are empty, AutoFitText was not able to construct properly");
        } else {
            refitText(text.toString(), targetFieldWidth, targetFieldHeight);
        }
        super.setText(text, type);
    }

    /**
     * TODO add sensibility for {@link #setMaxLines(int)} invocations
     */
    @Override
    public void setMaxLines(int maxLines) {
        // TODO Implement support for this. This could be relatively easy. The idea would probably
        // be to manipulate the targetHeight in the refitText-method and then have the algorithm do
        // its job business as usual. Nonetheless, remember the height will have to be lowered
        // dynamically as the font size shrinks so it won't be a walk in the park still
        if (maxLines == 1) {
            this.setSingleLine(true);
        } else {
            throw new UnsupportedOperationException("MaxLines != 1 are not implemented in AutoFitText yet, use TextView instead");
        }
    }

    @Override
    public void setSingleLine(boolean singleLine) {
        // save the requested value in an instance variable to be able to decide later
        mSingleLine = singleLine;
        super.setSingleLine(singleLine);
    }
}

পরিচিত বাগগুলি: অ্যান্ড্রয়েড 4.0.০৩ এর সাথে কাজ করে না - ফন্টগুলি অদৃশ্য বা খুব ছোট (মূল অবলাঞ্চা খুব বেশি কাজ করে না) নীচে সেই বাগের জন্য কাজ করা হয়: https://stackoverflow.com/a/21851239/2075875


0

এটা চেষ্টা কর

TextWatcher changeText = new TextWatcher() {
     @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                tv3.setText(et.getText().toString());
                tv3.post(new Runnable() {           
                    @Override
                    public void run() {
                    while(tv3.getLineCount() >= 3){                     
                            tv3.setTextSize((tv3.getTextSize())-1);                     
                        }
                    }
                });
            }

            @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

            @Override public void afterTextChanged(Editable s) { }
        };

আমি মনে করি না এটি কার্যকর হবে, প্রতিবার আপনি যখন পাঠ্যের আকার পরিবর্তন করবেন, এটি ব্লকটি শেষ করার পরেই অঙ্কনের কারণ হবে (যার অর্থ এটি ইভেন্ট-সারিতে যুক্ত হবে)। এর অর্থ হ'ল লুপটি প্রতিবার পাঠ্য পরিবর্তনের সময় একবারে কেবলমাত্র কাজ করবে, এবং এটি গ্যারান্টি দেয় না যে পাঠ্যটির 3 লাইন অতিক্রম করবে না of
অ্যান্ড্রয়েড বিকাশকারী

0

যদি আপনি আরও সহজ কিছু খুঁজছেন:

 public MyTextView extends TextView{

    public void resize(String text, float textViewWidth, float textViewHeight) {
       Paint p = new Paint();
       Rect bounds = new Rect();
       p.setTextSize(1);
       p.getTextBounds(text, 0, text.length(), bounds);
       float widthDifference = (textViewWidth)/bounds.width();
       float heightDifference = (textViewHeight);
       textSize = Math.min(widthDifference, heightDifference);
       setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize);
}

এটি খুব সংক্ষিপ্ত বলে মনে হচ্ছে, তবে এটি কি আমি প্রস্তুত পরীক্ষায় উত্তীর্ণ হতে পারি? এছাড়াও, যখন এই ফাংশনটি কল হয়ে যায় তখন আমি পাই না।
অ্যান্ড্রয়েড বিকাশকারী

না, এটি আরও বেশি পরামর্শ। আমি এটির উন্নতি করব যাতে এটি আপনার পরীক্ষার মতোই পাস করতে পারে।
স্যান্ডার

আচ্ছা, যদি এটি কোনও পরামর্শ হয় তবে আপনি কি দয়া করে এটি সরাসরি গিথুবে পোস্ট করতে পারেন?
অ্যান্ড্রয়েড বিকাশকারী

0

@ মালাচিয়াজ দ্বারা বর্ণিত সমস্যাটির জন্য দ্রুত সমাধান

আমি স্বয়ংক্রিয় পুনরায় আকারের ক্লাসে এটির জন্য কাস্টম সহায়তা যুক্ত করে সমস্যার সমাধান করেছি:

public void setTextCompat(final CharSequence text) {
    setTextCompat(text, BufferType.NORMAL);
}

public void setTextCompat(final CharSequence text, BufferType type) {
    // Quick fix for Android Honeycomb and Ice Cream Sandwich which sets the text only on the first call
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1 &&
        Build.VERSION.SDK_INT <= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
        super.setText(DOUBLE_BYTE_WORDJOINER + text + DOUBLE_BYTE_WORDJOINER, type);
    } else {
        super.setText(text, type);
    }
}

@Override
public CharSequence getText() {
    String originalText = super.getText().toString();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1 &&
        Build.VERSION.SDK_INT <= Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1) {
        // We try to remove the word joiners we added using compat method - if none found - this will do nothing.
        return originalText.replaceAll(DOUBLE_BYTE_WORDJOINER, "");
    } else {
        return originalText;
    }
}

এর yourView.setTextCompat(newTextValue)পরিবর্তে কেবল কল করুনyourView.setText(newTextValue)


সেটটেক্সটকে ওভাররাইড করার পরিবর্তে কেন সেটটেক্সটকম্প্যাটটির একটি নতুন ফাংশন তৈরি করবেন? এছাড়াও, কোন ইস্যু?
অ্যান্ড্রয়েড বিকাশকারী

সেটটেক্সট () টেক্সটভিউয়ের একটি চূড়ান্ত পদ্ধতি, সুতরাং আপনি এটিকে ওভাররাইড করতে পারবেন না। আর একটি বিকল্প হ'ল কাস্টম টেক্সটভিউয়ের বাইরে এটি করা, তবে এই সমাধানটি টেক্সটভিউয়ের অভ্যন্তরে ব্যবহার করার জন্য।
আয়নুত নেগ্রু

বেপারটা এমন না. কিছু "সেটটেক্সট" বেসরকারী, কিছু পাবলিক এবং কিছু জনসাধারণ চূড়ান্ত নয়। দেখে মনে হয় বেশিরভাগগুলি হ'ল পাবলিক শূন্য সেট সেটটেক্সট (চারসেকেন্স টেক্সট, বাফারটাইপ প্রকার) ওভাররাইড করে পরিচালনা করা যায়। এখানে একটি চূড়ান্ত ফাংশন রয়েছে যা আমি এর উদ্দেশ্যটি যদিও জানি না: সর্বজনীন চূড়ান্ত শূন্য সেট সেটটেক্সট (চর [] পাঠ্য, ইনট স্টার্ট, ইন লেন)। কোডটি আরও গভীরভাবে দেখুন।
অ্যান্ড্রয়েড বিকাশকারী

সেট টেক্সট () এর সেই সমস্ত রূপগুলিই আসলে শেষে সেটটেক্সট (চারসেক্সেন্স পাঠ্য) পদ্ধতিটি কল করবে। আপনি যদি একই আচরণটি নিশ্চিত করতে চান তবে আপনাকে সেই পদ্ধতিটি ওভাররাইড করতে হবে, অন্যথায় এটি কেবল নিজের নিজস্ব কাস্টম সেটটেক্সট () পদ্ধতি যুক্ত করা আরও ভাল।
আয়নুত নেগ্রু

হ্যাঁ, তবে বেশিরভাগ ক্ষেত্রে এটি ঠিক আছে।
অ্যান্ড্রয়েড বিকাশকারী

0

যুক্ত করার চেষ্টা করুন LayoutParamsএবং MaxWidthএবং MaxHeightকরতে TextView। এটি বিন্যাসটিকে পাতলা পাত্রে শ্রদ্ধার জন্য বাধ্য করবে ওভারফ্লো নয়।

textview.setLayoutParams(new LayoutParams(LinearLayout.MATCH_PARENT,LinearLayout.WRAP_CONTENT));

int GeneralApproxWidthOfContainer = 400;
int GeneralApproxHeightOfContainer = 600;
textview.setMaxWidth(400);
textview.setMaxHeight(600);` 

আমি নিশ্চিত নই যে আপনি এটির বিষয়ে কী কথা বলছেন। আপনি কি টেক্সটভিউ নমুনায় এটি যুক্ত করার পরামর্শ দিচ্ছেন, যাতে এর মাঝে মাঝে মাঝে দেখা ছোট সমস্যাটি না ঘটে? যদি তা হয় তবে আপনি গিথুব ওয়েবসাইটে এটি পোস্ট করেন নি কেন?
অ্যান্ড্রয়েড বিকাশকারী 13

0

অ্যান্ড্রয়েড ও যেহেতু, এক্সএমএলে পাঠ্যকে স্বয়ংক্রিয় আকার দেওয়া সম্ভব:

https://developer.android.com/preview/features/autosizing-textview.html

  <TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:autoSizeTextType="uniform"
    app:autoSizeMinTextSize="12sp"
    app:autoSizeMaxTextSize="100sp"
    app:autoSizeStepGranularity="2sp"
  />

অ্যান্ড্রয়েড ও আপনাকে টেক্সটভিউয়ের বৈশিষ্ট্য এবং সীমানার উপর ভিত্তি করে পাঠ্য আকারটি প্রসারিত করতে বা স্বয়ংক্রিয়ভাবে চুক্তিটি সঙ্কুচিত করতে একটি টেক্সটভিউকে নির্দেশ দেওয়ার অনুমতি দেয়। এই সেটিংটি গতিশীল সামগ্রী সহ বিভিন্ন স্ক্রিনে পাঠ্যের আকারকে অনুকূল করা সহজ করে।

সাপোর্ট লাইব্রেরি 26.0 বিটা অ্যান্ড্রয়েড ও এর পূর্বে অ্যান্ড্রয়েড সংস্করণগুলি চালিত ডিভাইসগুলিতে অটোসাইজিং টেক্সটভিউ বৈশিষ্ট্যটিকে সম্পূর্ণ সমর্থন সরবরাহ করে The Android.support.v4.widget প্যাকেজটিতে একটি পশ্চাদপটে সামঞ্জস্যপূর্ণ ফ্যাশনে বৈশিষ্ট্যগুলি অ্যাক্সেস করার জন্য টেক্সটভিউকম্প্যাট শ্রেণি রয়েছে।


দুঃখের বিষয়, আমার পরীক্ষাগুলি এবং এমনকি গুগল আইওর ভিডিওতেও আমি লক্ষ্য করেছি যে এটিতে ফন্টের আকার পরিবর্তন না করে পার্ট-ওয়ার্ডকে ভুলভাবে মোড়ানো করার মতো সমস্যা রয়েছে। আমি এই সম্পর্কে এখানে রিপোর্ট করেছি: ইস্যুজেট্রেকের.কম.স.আই.এস.এস. / 84৮৮68৮৯964 , এবং এই কারণেই আমি এখনও এটি ব্যবহার করি না।
অ্যান্ড্রয়েড বিকাশকারী

0

আমি অ্যান্ড্রয়েড অফিসিয়াল অটোসাইজিং টেক্সটভিউ চেষ্টা করার পরে , আমি জানতে পেরেছি যে আপনার অ্যান্ড্রয়েড সংস্করণটি অ্যান্ড্রয়েড 8.0 (এপিআই স্তর 26) এর আগে রয়েছে তবে আপনার ব্যবহারের দরকার আছে android.support.v7.widget.AppCompatTextViewএবং আপনার সমর্থন লাইব্রেরি সংস্করণটি 26.0.0 এর উপরে রয়েছে কিনা তা নিশ্চিত করে নিন। উদাহরণ:

<android.support.v7.widget.AppCompatTextView
    android:layout_width="130dp"
    android:layout_height="32dp"
    android:maxLines="1"
    app:autoSizeMaxTextSize="22sp"
    app:autoSizeMinTextSize="12sp"
    app:autoSizeStepGranularity="2sp"
    app:autoSizeTextType="uniform" />

আপডেট :

@ অ্যান্ড্রয়েড-বিকাশকারী এর জবাব অনুসারে, আমি AppCompatActivityউত্স কোডটি যাচাই করেছিলাম এবং এই দুটি লাইন খুঁজে পেয়েছিonCreate

final AppCompatDelegate delegate = getDelegate(); delegate.installViewFactory();

এবং AppCompatDelegateImplএরcreateView

    if (mAppCompatViewInflater == null) {
        mAppCompatViewInflater = new AppCompatViewInflater();
    }

এটি স্ফীত ভিউটি ব্যবহার করে AppCompatViewInflater, যখন AppCompatViewInflaterক্রিয়েভ ভিউ এটি "টেক্সটভিউ" এর জন্য অ্যাপকম্প্যাটটেক্সটভিউ ব্যবহার করবে।

public final View createView(){
    ...
    View view = null;
    switch (name) {
        case "TextView":
            view = new AppCompatTextView(context, attrs);
            break;
        case "ImageView":
            view = new AppCompatImageView(context, attrs);
            break;
        case "Button":
            view = new AppCompatButton(context, attrs);
            break;
    ...
}

আমার প্রকল্পে আমি ব্যবহার করি না AppCompatActivity, তাই আমার <android.support.v7.widget.AppCompatTextView>এক্সএমএল ব্যবহার করা দরকার ।


1
বেশিরভাগ ক্ষেত্রে, যখন আপনি কেবল "টেক্সটভিউ" লিখেন তখন ইনফ্ল্যাটারটি অ্যাপকম্প্যাটটিেক্সটভিউ ব্যবহার করে, তাই আপনাকে এটি করতে হবে না।
অ্যান্ড্রয়েড বিকাশকারী

@ অ্যান্ড্রয়েড ডেভেলপার তবে যখন আমি টেক্সটভিউ ব্যবহার করি তখন অটোসাইজিং কাজ করে না।
সপ্তাহে। Z

@ অ্যান্ড্রয়েড ডেভেলপার ধন্যবাদ, কারণটি আমি ব্যবহার করছি না AppCompatActivity। অ্যাপকম্প্যাটএটিভিটি অ্যাপকম্প্যাটভিউআইএনফ্লেটার ইনফ্লেটার লেআউট ব্যবহার করে।
.26

আমি বুঝতে পারি না
অ্যান্ড্রয়েড বিকাশকারী
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.