java - एंड्रॉइड:पक्ष अनुपात को बनाए रखते हुए स्क्रीन चौड़ाई में एक छवि को कैसे फैलाएं?




android layout (15)

मैंने बस ImageView के लिए स्रोत कोड पढ़ा है और यह मूल रूप से इस धागे में उप-वर्गीकरण समाधानों का उपयोग किए बिना असंभव है। ImageView.onMeasure हम इन पंक्तियों में आते हैं:

        // Get the max possible width given our constraints
        widthSize = resolveAdjustedSize(w + pleft + pright, mMaxWidth, widthMeasureSpec);

        // Get the max possible height given our constraints
        heightSize = resolveAdjustedSize(h + ptop + pbottom, mMaxHeight, heightMeasureSpec);

जहां h और w छवि के आयाम हैं, और p* पैडिंग है।

और तब:

private int resolveAdjustedSize(int desiredSize, int maxSize,
                               int measureSpec) {
    ...
    switch (specMode) {
        case MeasureSpec.UNSPECIFIED:
            /* Parent says we can be as big as we want. Just don't be larger
               than max size imposed on ourselves.
            */
            result = Math.min(desiredSize, maxSize);

तो यदि आपके पास layout_height="wrap_content" यह widthSize = w + pleft + pright सेट करेगा, या दूसरे शब्दों में, अधिकतम चौड़ाई छवि चौड़ाई के बराबर होगी।

इसका मतलब यह है कि जब तक आप एक सटीक आकार निर्धारित नहीं करते हैं, तब तक छवियों को कभी भी बढ़ाया नहीं जाता है । मैं इसे एक बग मानता हूं, लेकिन Google को नोटिस लेने या इसे ठीक करने के लिए Google को शुभकामनाएं मिलती हैं। संपादित करें: अपने स्वयं के शब्दों को खाकर, मैंने एक बग रिपोर्ट जमा की और कहा कि यह भविष्य की रिलीज में तय किया गया है!

एक और समाधान

यहां एक और सबक्लेस्ड वर्कअराउंड है, लेकिन आपको (सिद्धांत रूप में, मैंने वास्तव में इसका परीक्षण नहीं किया है!) कहीं भी आप ImageView का उपयोग करने में सक्षम हो। इसका उपयोग करने के लिए layout_width="match_parent" , और layout_height="wrap_content" । स्वीकार्य समाधान से भी यह काफी सामान्य है। जैसे आप फिट-टू-ऊंचाई के साथ-साथ फिट-टू-चौड़ाई भी कर सकते हैं।

import android.content.Context;
import android.util.AttributeSet;
import android.widget.ImageView;

// This works around the issue described here: http://stackoverflow.com/a/12675430/265521
public class StretchyImageView extends ImageView
{

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

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

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

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
    {
        // Call super() so that resolveUri() is called.
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        // If there's no drawable we can just use the result from super.
        if (getDrawable() == null)
            return;

        final int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
        final int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);

        int w = getDrawable().getIntrinsicWidth();
        int h = getDrawable().getIntrinsicHeight();
        if (w <= 0)
            w = 1;
        if (h <= 0)
            h = 1;

        // Desired aspect ratio of the view's contents (not including padding)
        float desiredAspect = (float) w / (float) h;

        // We are allowed to change the view's width
        boolean resizeWidth = widthSpecMode != MeasureSpec.EXACTLY;

        // We are allowed to change the view's height
        boolean resizeHeight = heightSpecMode != MeasureSpec.EXACTLY;

        int pleft = getPaddingLeft();
        int pright = getPaddingRight();
        int ptop = getPaddingTop();
        int pbottom = getPaddingBottom();

        // Get the sizes that ImageView decided on.
        int widthSize = getMeasuredWidth();
        int heightSize = getMeasuredHeight();

        if (resizeWidth && !resizeHeight)
        {
            // Resize the width to the height, maintaining aspect ratio.
            int newWidth = (int) (desiredAspect * (heightSize - ptop - pbottom)) + pleft + pright;
            setMeasuredDimension(newWidth, heightSize);
        }
        else if (resizeHeight && !resizeWidth)
        {
            int newHeight = (int) ((widthSize - pleft - pright) / desiredAspect) + ptop + pbottom;
            setMeasuredDimension(widthSize, newHeight);
        }
    }
}

मैं एक छवि (अज्ञात आकार का, लेकिन जो हमेशा मोटे तौर पर वर्ग होता है) डाउनलोड करना चाहता हूं और इसे प्रदर्शित करता है ताकि यह स्क्रीन को क्षैतिज रूप से भर सके, और किसी भी स्क्रीन आकार पर छवि के पहलू अनुपात को बनाए रखने के लिए लंबवत रूप से फैला हुआ हो। यहां मेरा (गैर-कामकाजी) कोड है। यह क्षैतिज छवि को फैलाता है, लेकिन लंबवत नहीं है, इसलिए यह squashed है ...

ImageView mainImageView = new ImageView(context);
    mainImageView.setImageBitmap(mainImage); //downloaded from server
    mainImageView.setScaleType(ScaleType.FIT_XY);
    //mainImageView.setAdjustViewBounds(true); 
    //with this line enabled, just scales image down
    addView(mainImageView,new LinearLayout.LayoutParams( 
            LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));

कुछ मामलों में यह जादू सूत्र खूबसूरती से समस्या हल करता है।

किसी अन्य प्लेटफ़ॉर्म से आने वाले किसी भी व्यक्ति के लिए, "आकार और आकार फिट करने के लिए" विकल्प को एंड्रॉइड में खूबसूरती से संभाला जाता है, लेकिन यह खोजना मुश्किल है।

आप आमतौर पर यह संयोजन चाहते हैं:

  • चौड़ाई मैच माता पिता,
  • ऊंचाई लपेटो सामग्री,
  • समायोजित दृश्यवृत्त चालू (एसआईसी)
  • स्केल फिट सेंटर
  • फसल टोपिंग ऑफ (एसआईसी)

फिर यह स्वचालित और अद्भुत है।

यदि आप आईओएस देव हैं, तो यह बिल्कुल आश्चर्यजनक है कि आप तालिका दृश्य में "पूरी तरह से गतिशील सेल हाइट्स" कैसे कर सकते हैं .. गलती, मेरा मतलब ListView है। का आनंद लें।

<com.parse.ParseImageView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:id="@+id/post_image"
    android:src="@drawable/icon_192"
    android:layout_margin="0dp"
    android:cropToPadding="false"
    android:adjustViewBounds="true"
    android:scaleType="fitCenter"
    android:background="#eff2eb"/>


मैंने इसे कस्टम व्यू के साथ पूरा किया। Layout_width = "fill_parent" और layout_height = "wrap_content" सेट करें, और उचित ड्रॉइंग पर इंगित करें:

public class Banner extends View {

  private final Drawable logo;

  public Banner(Context context) {
    super(context);
    logo = context.getResources().getDrawable(R.drawable.banner);
    setBackgroundDrawable(logo);
  }

  public Banner(Context context, AttributeSet attrs) {
    super(context, attrs);
    logo = context.getResources().getDrawable(R.drawable.banner);
    setBackgroundDrawable(logo);
  }

  public Banner(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    logo = context.getResources().getDrawable(R.drawable.banner);
    setBackgroundDrawable(logo);
  }

  @Override protected void onMeasure(int widthMeasureSpec,
      int heightMeasureSpec) {
    int width = MeasureSpec.getSize(widthMeasureSpec);
    int height = width * logo.getIntrinsicHeight() / logo.getIntrinsicWidth();
    setMeasuredDimension(width, height);
  }
}

हर कोई इस प्रोग्रामिंग कर रहा है इसलिए मैंने सोचा कि यह जवाब पूरी तरह फिट होगा। यह कोड मेरे लिए एक्सएमएल में काम करता है। मैं अभी तक अनुपात के बारे में सोच नहीं रहा हूं, लेकिन फिर भी यह जवाब देना चाहता था अगर यह किसी की मदद करेगा।

android:adjustViewBounds="true"

चीयर्स ..


मैं एजीईएस के लिए एक या दूसरे रूप में इस समस्या से जूझ रहा हूं, धन्यवाद, धन्यवाद, धन्यवाद .... :)

मैं बस यह इंगित करना चाहता था कि बॉब ली ने केवल व्यय को ओवरराइड करके और ओवरराइड करके क्या किया है, उससे एक सामान्य समाधान प्राप्त कर सकते हैं। इस तरह आप इसका उपयोग किसी भी ड्रायबल के साथ कर सकते हैं, और यदि कोई छवि नहीं है तो यह तोड़ नहीं जाएगी:

    public class CardImageView extends View {
        public CardImageView(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
        }

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

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

        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            Drawable bg = getBackground();
            if (bg != null) {
                int width = MeasureSpec.getSize(widthMeasureSpec);
                int height = width * bg.getIntrinsicHeight() / bg.getIntrinsicWidth();
                setMeasuredDimension(width,height);
            }
            else {
                super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            }
        }
    }

मेरे लिए एंड्रॉइड: scaleType = "centerCrop" ने मेरी समस्या का समाधान नहीं किया। यह वास्तव में छवि के तरीके का विस्तार किया। तो मैंने एंड्रॉइड के साथ प्रयास किया: स्केल टाइप = "fitXY" और यह उत्कृष्ट काम किया।


आप खींचने योग्य की चौड़ाई और ऊंचाई के आधार पर पहलू अनुपात (चौड़ाई या ऊंचाई से) को संरक्षित करने के लिए मेरे StretchableImageView का उपयोग कर सकते हैं:

import android.content.Context;
import android.util.AttributeSet;
import android.widget.ImageView;

public class StretchableImageView extends ImageView{

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

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

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

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if(getDrawable()!=null){
            if(getDrawable().getIntrinsicWidth()>=getDrawable().getIntrinsicHeight()){
                int width = MeasureSpec.getSize(widthMeasureSpec);
                int height = width * getDrawable().getIntrinsicHeight()
                            / getDrawable().getIntrinsicWidth();
                setMeasuredDimension(width, height);
            }else{
                int height = MeasureSpec.getSize(heightMeasureSpec);
                int width = height * getDrawable().getIntrinsicWidth()
                            / getDrawable().getIntrinsicHeight();
                setMeasuredDimension(width, height);
            }
        }
    }
}

मैंने केवल इस एक्सएमएल कोड का उपयोग करके इसे हासिल करने में कामयाब रहा है। यह मामला हो सकता है कि ग्रहण ऊंचाई को विस्तारित करने के लिए ऊंचाई प्रदान नहीं करता है; हालांकि, जब आप वास्तव में किसी डिवाइस पर इसे चलाते हैं, तो यह वांछित परिणाम प्रदान करता है और प्रदान करता है। (कम से कम मेरे लिए)

<FrameLayout
     android:layout_width="match_parent"
     android:layout_height="wrap_content">

     <ImageView
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:adjustViewBounds="true"
          android:scaleType="centerCrop"
          android:src="@drawable/whatever" />
</FrameLayout>

अंत में, मैंने मैन्युअल रूप से आयाम उत्पन्न किए, जो बहुत अच्छा काम करता है:

DisplayMetrics dm = new DisplayMetrics();
context.getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels;
int height = width * mainImage.getHeight() / mainImage.getWidth(); //mainImage is the Bitmap I'm drawing
addView(mainImageView,new LinearLayout.LayoutParams( 
        width, height));

आप ScaleType को ScaleType.FIT_XY पर सेट कर रहे हैं। javadocs अनुसार, यह आवश्यक होने पर पहलू अनुपात को बदलने, पूरे क्षेत्र में फिट होने के लिए छवि को फैलाएगा। इससे आप जो व्यवहार देख रहे हैं उसे समझाएंगे।

जिस व्यवहार को आप चाहते हैं उसे प्राप्त करने के लिए ... FIT_CENTER, FIT_START, या FIT_END नज़दीक हैं, लेकिन यदि छवि लंबा है, तो यह चौड़ाई भरने शुरू नहीं होगी। आप देख सकते हैं कि उन्हें कैसे लागू किया गया है, और आपको शायद यह समझने में सक्षम होना चाहिए कि इसे अपने उद्देश्य के लिए कैसे समायोजित किया जाए।


ImageView के लिए XML फ़ाइल में adjustViewBounds="true" और scaleType="fitCenter" को सेट करने का यह आसान मामला है!

<ImageView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:src="@drawable/image"

        android:adjustViewBounds="true"
        android:scaleType="fitCenter"
        />

नोट: match_parent सेट है


यह मेरी आवश्यकता के अनुसार ठीक काम कर रहा है

<ImageView android:id="@+id/imgIssue" android:layout_width="fill_parent" android:layout_height="wrap_content" android:adjustViewBounds="true" android:scaleType="fitXY"/>


RelativeLayout द्वारा प्रदान की गई सुविधाओं का उपयोग करना एक बहुत ही सरल समाधान है।

यहां एक्सएमएल है जो मानक एंड्रॉइड Views साथ इसे संभव बनाता है:

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:fillViewport="true">

    <RelativeLayout 
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        >
        <LinearLayout
            android:id="@+id/button_container"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical"
            android:layout_alignParentBottom="true"
            >
            <Button
                android:text="button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"/>
            <Button
                android:text="button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"/>
            <Button
                android:text="button"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"/>
        </LinearLayout>
        <ImageView 
            android:src="@drawable/cat"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:adjustViewBounds="true"
            android:scaleType="centerCrop"
            android:layout_above="@id/button_container"/>
    </RelativeLayout>
</ScrollView>

चाल यह है कि आप स्क्रीन को भरने के लिए ImageView सेट करते हैं लेकिन इसे अन्य लेआउट से ऊपर होना चाहिए। इस तरह आप जो कुछ भी चाहते हैं उसे प्राप्त करते हैं।


मैंने इसे लाइनरलायआउट के भीतर इन मानों के साथ किया है:

Scale type: fitStart
Layout gravity: fill_horizontal
Layout height: wrap_content
Layout weight: 1
Layout width: fill_parent

कम से कम, आप निम्न की तरह कुछ करने के द्वारा प्रेषण के कार्यान्वयन में एक छोटा सा सुधार कर सकते हैं:

public class TwoTypesConsumer implements Consumer<Fruit> {

फल टमाटर और ऐप्पल का पूर्वज है।







java android layout