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




android layout (12)

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

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 सेट है


RescueViewBounds को सही पर सेट करना और लाइनरलाउट व्यू समूह का उपयोग करना मेरे लिए बहुत अच्छा काम करता है। डिवाइस मेट्रिक्स के लिए उपclass या पूछने की कोई ज़रूरत नहीं है:

//NOTE: "this" is a subclass of LinearLayout
ImageView splashImageView = new ImageView(context);
splashImageView.setImageResource(R.drawable.splash);
splashImageView.setAdjustViewBounds(true);
addView(splashImageView);

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

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

आप खींचने योग्य की चौड़ाई और ऊंचाई के आधार पर पहलू अनुपात (चौड़ाई या ऊंचाई से) को संरक्षित करने के लिए मेरे 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);
            }
        }
    }
}

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

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

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

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

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

यदि आप आईओएस देव हैं, तो यह बिल्कुल आश्चर्यजनक है कि आप तालिका दृश्य में "पूरी तरह से गतिशील सेल हाइट्स" कैसे कर सकते हैं .. गलती, मेरा मतलब 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"/>


देखो आपकी समस्या का एक आसान समाधान है:

ImageView imageView;

protected void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    setContentView(R.layout.your_layout);
    imageView =(ImageView)findViewById(R.id.your_imageView);
    Bitmap imageBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.your_image);
    Point screenSize = new Point();
    getWindowManager().getDefaultDisplay().getSize(screenSize);
    Bitmap temp = Bitmap.createBitmap(screenSize.x, screenSize.x, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(temp);
    canvas.drawBitmap(imageBitmap,null, new Rect(0,0,screenSize.x,screenSize.x), null);
    imageView.setImageBitmap(temp);
}

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

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

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

मैंने इसे कस्टम व्यू के साथ पूरा किया। 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);
  }
}

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

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

मैंने बस 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://.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);
        }
    }
}

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

android:adjustViewBounds="true"

चीयर्स ..


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 सेट करते हैं लेकिन इसे अन्य लेआउट से ऊपर होना चाहिए। इस तरह आप जो कुछ भी चाहते हैं उसे प्राप्त करते हैं।





layout