गोल कोनों के साथ एक दृश्य कैसे बनाएं?


94

मैं एंड्रॉइड में गोल किनारों के साथ एक दृश्य बनाने की कोशिश कर रहा हूं। अब तक मैंने जो समाधान पाया, वह गोल कोनों के साथ एक आकृति को परिभाषित करना और उस दृश्य की पृष्ठभूमि के रूप में उपयोग करना है।

यहाँ मैंने जो किया है, उसे नीचे दिए गए अनुसार परिभाषित करें:

<padding
android:top="2dp"
android:bottom="2dp"/>
<corners android:bottomRightRadius="20dp"
android:bottomLeftRadius="20dp"
android:topLeftRadius="20dp"
android:topRightRadius="20dp"/>

अब मैंने इसे नीचे दिए गए लेआउट के लिए पृष्ठभूमि के रूप में उपयोग किया:

<LinearLayout
        android:orientation="vertical"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginLeft="10dp"
        android:layout_marginRight="10dp"
        android:layout_marginBottom="10dp"
        android:clipChildren="true"
        android:background="@drawable/rounded_corner">

यह पूरी तरह से ठीक काम करता है, मैं देख सकता हूं कि दृश्य के किनारों को गोल किया गया है।

लेकिन मेरे लेआउट को इसमें कई अन्य बच्चे के विचार मिले हैं, एक ImageView या ए MapView। जब मैं ImageViewउपरोक्त लेआउट के अंदर जगह देता हूं , तो छवि के कोनों को क्लिप / क्रॉप नहीं किया जाता है, इसके बजाय यह पूर्ण दिखाई देता है।

मैं यह काम की तरह एक समझाया बनाने के लिए अन्य समाधान देखा है यहाँ

लेकिन क्या एक दृश्य के लिए गोल कोनों को सेट करने की एक विधि है और उसके सभी बच्चे के विचार उस मुख्य दृश्य के भीतर समाहित हैं, जिसमें गोल कोनों हैं?


क्या होगा यदि आप LinearLayout तक फैली हुई कस्टम लेआउट का उपयोग करते हैं, और जब उसका ऑब्जेक्ट बनाया जाता है, तो उस लेआउट के सभी बच्चों को पुनरावृत्त करें और उनके लिए गोल बॉर्डर पृष्ठभूमि लागू करें?
मिस्टिकमैजिक Myst

3
android.support.v7.widget.CardView इसके लिए समाधान प्रतीत होता है
रॉकेट्सपेसर

यह समाधान मेरे लिए यह हल है, लेकिन उपवर्गीकरण की आवश्यकता है: /programming/5574212/android-view-clipping
हारून

क्या इससे आपके सवाल का जवाब मिलता है? छवि गोल छवि के लिए सीमाओं को जोड़ना Android
user4157124

Google के पास नई रूपरेखा है, नई प्रौद्योगिकियां बेहतर हैं [Jetpack Compose] [1] [1]: stackoverflow.com/questions/6054562/…
Ucdemir

जवाबों:


128

एक अन्य दृष्टिकोण नीचे की तरह एक कस्टम लेआउट क्लास बनाना है। यह लेआउट पहले अपनी सामग्री को एक ऑफ़स्क्रीन बिटमैप में ले जाता है, ऑफ़स्क्रीन बिटमैप को एक गोल आयताकार के साथ मास्क करता है और फिर वास्तविक कैनवास पर ऑफ़स्क्रीन बिटमैप को खींचता है।

मैंने इसकी कोशिश की और यह काम करने लगता है (कम से कम मेरे सरल टेस्टकेस के लिए)। यह निश्चित रूप से एक नियमित लेआउट की तुलना में प्रदर्शन को प्रभावित करेगा।

package com.example;

import android.content.Context;
import android.graphics.*;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import android.widget.FrameLayout;

public class RoundedCornerLayout extends FrameLayout {
    private final static float CORNER_RADIUS = 40.0f;

    private Bitmap maskBitmap;
    private Paint paint, maskPaint;
    private float cornerRadius;

    public RoundedCornerLayout(Context context) {
        super(context);
        init(context, null, 0);
    }

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

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

    private void init(Context context, AttributeSet attrs, int defStyle) {
        DisplayMetrics metrics = context.getResources().getDisplayMetrics();
        cornerRadius = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, CORNER_RADIUS, metrics);

        paint = new Paint(Paint.ANTI_ALIAS_FLAG);

        maskPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
        maskPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));

        setWillNotDraw(false);
    }

    @Override
    public void draw(Canvas canvas) {
        Bitmap offscreenBitmap = Bitmap.createBitmap(canvas.getWidth(), canvas.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas offscreenCanvas = new Canvas(offscreenBitmap);

        super.draw(offscreenCanvas);

        if (maskBitmap == null) {
            maskBitmap = createMask(canvas.getWidth(), canvas.getHeight());
        }

        offscreenCanvas.drawBitmap(maskBitmap, 0f, 0f, maskPaint);
        canvas.drawBitmap(offscreenBitmap, 0f, 0f, paint);
    }

    private Bitmap createMask(int width, int height) {
        Bitmap mask = Bitmap.createBitmap(width, height, Bitmap.Config.ALPHA_8);
        Canvas canvas = new Canvas(mask);

        Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(Color.WHITE);

        canvas.drawRect(0, 0, width, height, paint);

        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
        canvas.drawRoundRect(new RectF(0, 0, width, height), cornerRadius, cornerRadius, paint);

        return mask;
    }
}

इसे सामान्य लेआउट की तरह उपयोग करें:

<com.example.RoundedCornerLayout
    android:layout_width="200dp"
    android:layout_height="200dp">

    <ImageView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:src="@drawable/test"/>

    <View
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:background="#ff0000"
        />

</com.example.RoundedCornerLayout>

1
मैं इस लेआउट का उपयोग जूम फंक्शन के अंदर इमेजव्यू के लिए कर रहा हूं, लेकिन जब मैं ज़ूम करने की कोशिश करता हूं तो यह लेआउट कैंट टच श्रोता का पता लगाता है, इस लेआउट में टच श्रोता फ़ंक्शन कैसे जोड़ें?
मुहम्मद नफ़ियान विल्डाना

2
मैंने इस पद्धति का उपयोग किया और ठीक काम करता है। लेकिन जब मैं लेआउट में एक EditText डालता हूं, तो जब मैं टाइप करता हूं तो स्क्रीन अपडेट नहीं होती है। जब मैं विंडो बंद करता हूं, तो टेक्स्ट डिस्प्ले पर आता है। एक बार कीबोर्ड बंद करने के बाद स्क्रीन अपडेट हो रही है। इस पर कोई फिक्स?
साजिब आचार्य

1
इसके साथ केवल एक समस्या है जब आप इसे रिसाइकलर दृश्य के साथ उपयोग करते हैं, तो यह है कि इसके आइटम के पूर्ण सेट के लिए इंतजार नहीं किया जाएगा। और कुछ ही वस्तुओं के चक्कर लगाता है। क्या ऐसा होने का कोई कारण है?
अहमद

2
यह ग्लाइड लाइब्रेरी से लोड की गई छवियों के साथ काम नहीं करता है जो प्लेसहोल्डर संक्रमण (या वास्तव में किसी भी अन्य एनिमेटेड बच्चे) का उपयोग करते हैं। मेरे पास एक वैकल्पिक समाधान है, लेकिन इसके लिए आपकी पृष्ठभूमि का रंग एक ठोस रंग होना चाहिए। Gist.github.com/grennis/da9f86870c45f3b8ae00912edb72e868
ग्रेग

2
ठीक और उपयोगी समाधान लेकिन बहुत महंगा है। RecyclerView सिर्फ छह तत्वों के साथ जिसमें एक तस्वीर होती है वह आसानी से स्क्रॉल नहीं कर सकता है। और यह डिवाइस पावर (सैमसंग S9 या विलेफ़ॉक्स स्विफ्ट 2) पर निर्भर नहीं है। stackoverflow.com/a/41098690/4399323 बेहतर उत्तर है!
वेलेन्टाइन युरेव

73

या आप ऐसा उपयोग कर सकते हैं android.support.v7.widget.CardView:

<android.support.v7.widget.CardView
    xmlns:card_view="http://schemas.android.com/apk/res-auto"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    card_view:cardBackgroundColor="@color/white"
    card_view:cardCornerRadius="4dp">

    <!--YOUR CONTENT-->
</android.support.v7.widget.CardView>

मैंने कई तरह से कोशिश की है, आपकी समस्या का सबसे अच्छा समाधान है। धन्यवाद!
विझेन

ऊंचाई नहीं निकाल पा रहे हैं। ठीक काम करता है अगर डिजाइन को ऊंचाई की आवश्यकता होती है।
अब्दाल्रहमान शतो

1
@AbdalrahmanShatou डेवलपर. android.com/reference/android/support/v7/widget/… उसके गुण हैं। क्या आपने उन्हें "0" पर सेट करने का प्रयास किया है?
रॉकेट्सपेसर

5
एक कमी यह है कि इसका समर्थन नहीं करता है <21 android api
Itai Spector

52

shape.xml

<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle">

    <solid android:color="#f6eef1" />

    <stroke
        android:width="2dp"
        android:color="#000000" />

    <padding
        android:bottom="5dp"
        android:left="5dp"
        android:right="5dp"
        android:top="5dp" />

    <corners android:radius="5dp" />

</shape>

और आपके अंदर लेआउट

<LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginLeft="10dp"
        android:layout_marginRight="10dp"
        android:layout_marginBottom="10dp"
        android:clipChildren="true"
        android:background="@drawable/shape">

        <ImageView
             android:layout_width="match_parent"
             android:layout_height="match_parent"
             android:src="@drawable/your image"
             android:background="@drawable/shape">

</LinearLayout>

3
@Zach: किस तरह से यह काम करने में विफल रहा? जब आप मूल प्रश्न पूछते हैं तो आपका ऐप कैसे काम कर रहा था?
लार्श डे

2
क्लिपचाइल्ड बेकार है और छवि दृश्य अभी भी दृश्य के बाहर फैली हुई है।
अब्दाल्रहमान शतो

1
काश मैं तुम्हें इसके लिए एक इनाम दे सकता। धन्यवाद
Odys

3
मुझे नहीं लगता कि यदि छवि आयताकार है तो यह दृष्टिकोण काम करेगा, क्योंकि पृष्ठभूमि छवि की सामग्री के पीछे खींची जाएगी। यह केवल उन छवियों के साथ काम कर सकता है जिनमें पारदर्शिता है और स्वयं गोल कोनों हैं।
हर्षवर्धन

22

जाप वैन हेंगस्टम का जवाब काम करता है लेकिन मुझे लगता है कि यह महंगा है और अगर हम इस विधि को एक बटन पर उदाहरण के लिए लागू करते हैं, तो दृश्य प्रभाव एक बिटमैप के रूप में प्रदान किए जाने के बाद से खो जाता है।

मेरे लिए सबसे अच्छी विधि और सरलतम दृश्य पर एक मुखौटा लगाने में शामिल हैं, जैसे:

@Override
protected void onSizeChanged(int width, int height, int oldWidth, int oldHeight) {
    super.onSizeChanged(width, height, oldWidth, oldHeight);

    float cornerRadius = <whatever_you_want>;
    this.path = new Path();
    this.path.addRoundRect(new RectF(0, 0, width, height), cornerRadius, cornerRadius, Path.Direction.CW);
}

@Override
protected void dispatchDraw(Canvas canvas) {
    if (this.path != null) {
        canvas.clipPath(this.path);
    }
    super.dispatchDraw(canvas);
}

इसका उपयोग कैसे करें?
मक्सिम नियाज़ेव

@MaksimKniazev आपको इच्छित लेआउट का एक उपवर्ग बनाएं (उदाहरण के लिए: FrameLayout), फिर इन दो विधियों को इस उपवर्ग में पेस्ट करें और अपने इच्छित कोने के प्रतिमान मान (उदाहरण के लिए संसाधनों से) के साथ '<जो कुछ_यौवंत> बदलें। बस। क्या यह आपके लिए पर्याप्त स्पष्ट है या आपको एक उदाहरण की आवश्यकता है?
गधा

बहुत बहुत धन्यवाद, यह वास्तव में RecyclerView के लिए बेहतर काम करता है!
वैलेंटाइन यूरीव

18

यदि आपको लेआउट में टच श्रोताओं को जोड़ते समय समस्या हो रही है। अभिभावक लेआउट के रूप में इस लेआउट का उपयोग करें।

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.RectF;
import android.graphics.Region;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import android.view.View;
import android.widget.FrameLayout;

public class RoundedCornerLayout extends FrameLayout {
    private final static float CORNER_RADIUS = 6.0f;
    private float cornerRadius;

    public RoundedCornerLayout(Context context) {
        super(context);
        init(context, null, 0);
    }

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

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

    private void init(Context context, AttributeSet attrs, int defStyle) {
        DisplayMetrics metrics = context.getResources().getDisplayMetrics();
        cornerRadius = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, CORNER_RADIUS, metrics);
        setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    }


    @Override
    protected void dispatchDraw(Canvas canvas) {
        int count = canvas.save();

        final Path path = new Path();
        path.addRoundRect(new RectF(0, 0, canvas.getWidth(), canvas.getHeight()), cornerRadius, cornerRadius, Path.Direction.CW);
        canvas.clipPath(path, Region.Op.REPLACE);

        canvas.clipPath(path);
        super.dispatchDraw(canvas);
        canvas.restoreToCount(count);
    }


}

जैसा

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

    <RelativeLayout
        android:id="@+id/patentItem"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:paddingRight="20dp">
        ... your child goes here
    </RelativeLayout>
</com.example.view.RoundedCornerLayout>

2
यह अच्छी तरह से काम करता है अगर स्क्रीन पर कई एनीमेशन नहीं हैं, जो स्क्रीन ड्रॉ को बार-बार बनाते हैं; चूंकि, यह गंभीर रूप से प्रदर्शन को धीमा कर देगा। कार्डव्यू की कोशिश करनी चाहिए, जिसमें एक कुशल गोल कोने की विधि है (क्लिपिंग पथ या कैनवस का उपयोग न करें। धनराशि खंड - नीचे एपीआई 17 में खराब है, लेकिन पोर्टरफिल्टरडफ़रकोलर का उपयोग करें)
गुयेन टैन डाट

18

फ़ोल्डर round.xmlमें कॉल की गई एक xml फ़ाइल बनाएँ drawableऔर इस सामग्री को चिपकाएँ:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
  <solid android:color="#FFFFFF" />
  <stroke android:width=".05dp" android:color="#d2d2d2" />
  <corners android:topLeftRadius="5dp" android:topRightRadius="5dp" android:bottomRightRadius="5dp" android:bottomLeftRadius="5dp"/>
</shape>

तो किसी भी आइटम के round.xmlरूप में उपयोग करें background। फिर यह आपको गोल कोनों देगा।


9

Android L में आप केवल View.setClipToOutline का उपयोग कर पाएंगे उस प्रभाव को प्राप्त करने के लिए का । पिछले संस्करणों में एक निश्चित व्यूग्रुप की सामग्री को एक निश्चित आकार में क्लिप करने का कोई तरीका नहीं है।

आपको कुछ ऐसा सोचना होगा जो आपको एक समान प्रभाव दे:

  • यदि आपको केवल ImageView में गोल कोनों की आवश्यकता है, तो आप शेप का उपयोग उस आकृति पर छवि को 'पेंट' करने के लिए कर सकते हैं जिसका आप पृष्ठभूमि के रूप में उपयोग कर रहे हैं। इस पुस्तकालय पर एक नज़र डालें एक उदाहरण के लिए।

  • यदि आपको वास्तव में प्रत्येक बच्चों को क्लिप करने की आवश्यकता है, तो शायद आप अपने लेआउट पर एक और दृश्य देख सकते हैं? आप जो भी रंग इस्तेमाल कर रहे हैं उसकी पृष्ठभूमि के साथ एक, और बीच में एक गोल 'छेद'? आप वास्तव में एक कस्टम व्यूग्रुप बना सकते हैं जो ऑनड्राइव विधि से आगे निकलते हुए हर बच्चे पर उस आकृति को खींचता है।


4

निम्नलिखित कोड के साथ अपने ड्रा करने योग्य फ़ोल्डर के तहत एक xml फ़ाइल बनाएं। (मेरे द्वारा बनाई गई फ़ाइल का नाम राउंड_कोर्नर। Xml है)

rounded_corner.xml

    <?xml version="1.0" encoding="utf-8"?>
    <shape
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:shape="rectangle">

        <!-- view background color -->
        <solid
            android:color="#a9c5ac" >
        </solid>

        <!-- view border color and width -->
        <stroke
            android:width="3dp"
            android:color="#1c1b20" >
        </stroke>

        <!-- If you want to add some padding -->
        <padding
            android:left="4dp"
            android:top="4dp"
            android:right="4dp"
            android:bottom="4dp"    >
        </padding>

        <!-- Here is the corner radius -->
        <corners
            android:radius="10dp"   >
        </corners>
    </shape>

और यह रखने drawableके रूप में backgroundदेखने के लिए जो करने के लिए आप गोल कोने सीमा रखना चाहते हैं के लिए। चलो इसे रखने के लिए एकLinearLayout

    <LinearLayout android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:background="@drawable/rounded_corner"
            android:layout_centerInParent="true">

            <TextView android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:text="Hi, This layout has rounded corner borders ..."
                android:gravity="center"
                android:padding="5dp"/>

    </LinearLayout>

3

इस ट्यूटोरियल का अनुसरण करें और इसके नीचे की सभी चर्चाएँ - http://www.curious-creature.org/2012/12/11/android-recipe-1-image-with-rounded-corners/

पूरे एंड्रॉइड यूआई टूलकिट के प्रमुख डेवलपर्स में से एक, गाइ रोमैन द्वारा लिखे गए इस पोस्ट के अनुसार, गोल कोनों के साथ एक कंटेनर (और उसके सभी बच्चे के विचार) बनाना संभव है, लेकिन उन्होंने समझाया कि यह बहुत महंगा है (प्रदर्शन से) मुद्दों का प्रतिपादन)।

मैं आपको उसकी पोस्ट के अनुसार जाने की सलाह दूंगा, और यदि आप गोल कोनों चाहते हैं, तो ImageViewइस पोस्ट के अनुसार गोल कोनों को लागू करें। फिर, आप इसे किसी भी पृष्ठभूमि के साथ एक कंटेनर के अंदर रख सकते हैं, और आप अपनी इच्छा के अनुसार प्रभाव प्राप्त करेंगे।

यही मैंने आखिरकार किया भी।


3

आप एक androidx.cardview.widget.CardViewतरह का उपयोग कर सकते हैं :

<androidx.cardview.widget.CardView
xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"       
        app:cardCornerRadius="@dimen/dimen_4"
        app:cardElevation="@dimen/dimen_4"
        app:contentPadding="@dimen/dimen_10">

       ...

</androidx.cardview.widget.CardView>

या

shape.xml

<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="rectangle">

    <solid android:color="#f6eef1" />

    <stroke
        android:width="2dp"
        android:color="#000000" />

    <padding
        android:bottom="5dp"
        android:left="5dp"
        android:right="5dp"
        android:top="5dp" />

    <corners android:radius="5dp" />

</shape>

और आपके अंदर लेआउट

<LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@drawable/shape">

        ...

</LinearLayout>

3

CardViewएंड्रॉयड स्टूडियो 3.0.1 में एपीआई 27 में मेरे लिए काम किया। colorPrimaryसंदर्भित किया गया है res/values/colors.xmlफ़ाइल और सिर्फ एक उदाहरण है। लेआउट_ के लिए 0dpयह माता-पिता की चौड़ाई तक फैल जाएगा। आपको अपनी आवश्यकताओं के लिए बाधाओं और चौड़ाई / ऊँचाई को कॉन्फ़िगर करना होगा।

<android.support.v7.widget.CardView
    android:id="@+id/cardView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:cardCornerRadius="4dp"
    app:cardBackgroundColor="@color/colorPrimary">

    <!-- put your content here -->

</android.support.v7.widget.CardView>

3

सामग्री अवयव पुस्तकालय के Viewसाथ गोल कोनों के साथ बनाने का सबसे अच्छा तरीका सामग्री का उपयोग करना हैMaterialShapeDrawable

कस्टम गोल कोनों के साथ एक शेपएपैरेंसमॉडल बनाएं:

ShapeAppearanceModel shapeAppearanceModelLL1 = new ShapeAppearanceModel()
        .toBuilder()
        .setAllCorners(CornerFamily.ROUNDED,radius16)
        .build();

एक बनाएँ MaterialShapeDrawable:

MaterialShapeDrawable shapeDrawableLL1 = new MaterialShapeDrawable(shapeAppearanceModeLL1);

यदि आप भी इस विषय का उपयोग करने के लिए एक उत्थान के लिए आवेदन करना चाहते हैं:

MaterialShapeDrawable shapeDrawableLL1 = MaterialShapeDrawable.createWithElevationOverlay(this, 4.0f);
shapeDrawableLL1.setShapeAppearanceModel(shapeAppearanceModelLL1);

वैकल्पिक: एक पृष्ठभूमि रंग और एक स्ट्रोक के आकार के लिए लागू होते हैं

shapeDrawableLL1.setFillColor(
       ContextCompat.getColorStateList(this,R.color...));
 shapeDrawableLL1.setStrokeWidth(2.0f);
 shapeDrawableLL1.setStrokeColor(
       ContextCompat.getColorStateList(this,R.color...));

अंत में अपने LinearLayout(या अन्य दृश्य में) पृष्ठभूमि के रूप में आकार लागू करें :

LinearLayout linearLayout1= findViewById(R.id.ll_1);
ViewCompat.setBackground(linearLayout1,shapeDrawableLL1);

यहाँ छवि विवरण दर्ज करें


2

जाप वैन हेंगस्टम के उत्तर से अंतर:

  1. मास्क बिटमैप के बजाय बिटमैपशेयर का उपयोग करें ।
  2. बिटमैप केवल एक बार बनाएं।
public class RoundedFrameLayout extends FrameLayout {
    private Bitmap mOffscreenBitmap;
    private Canvas mOffscreenCanvas;
    private BitmapShader mBitmapShader;
    private Paint mPaint;
    private RectF mRectF;

    public RoundedFrameLayout(Context context) {
        super(context);
        init();
    }

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

    public RoundedFrameLayout(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        setWillNotDraw(false);
    }

    @Override
    public void draw(Canvas canvas) {
        if (mOffscreenBitmap == null) {
            mOffscreenBitmap = Bitmap.createBitmap(canvas.getWidth(), canvas.getHeight(), Bitmap.Config.ARGB_8888);
            mOffscreenCanvas = new Canvas(mOffscreenBitmap);
            mBitmapShader = new BitmapShader(mOffscreenBitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
            mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
            mPaint.setShader(mBitmapShader);
            mRectF = new RectF(0f, 0f, canvas.getWidth(), canvas.getHeight());
        }
        super.draw(mOffscreenCanvas);

        canvas.drawRoundRect(mRectF, 8, 8, mPaint);
    }
}

2
public class RoundedCornerLayout extends FrameLayout {
    private double mCornerRadius;

    public RoundedCornerLayout(Context context) {
        this(context, null, 0);
    }

    public RoundedCornerLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

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

    private void init(Context context, AttributeSet attrs, int defStyle) {
        DisplayMetrics metrics = context.getResources().getDisplayMetrics();
        setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    }

    public double getCornerRadius() {
        return mCornerRadius;
    }

    public void setCornerRadius(double cornerRadius) {
        mCornerRadius = cornerRadius;
    }

    @Override
    public void draw(Canvas canvas) {
        int count = canvas.save();

        final Path path = new Path();
        path.addRoundRect(new RectF(0, 0, canvas.getWidth(), canvas.getHeight()), (float) mCornerRadius, (float) mCornerRadius, Path.Direction.CW);
        canvas.clipPath(path, Region.Op.REPLACE);

        canvas.clipPath(path);
        super.draw(canvas);
        canvas.restoreToCount(count);
    }
}

1

आपके द्वारा प्रदान किया गया ट्यूटोरियल लिंक आपको यह सुझाव देता है कि आपको अपने बच्चे के तत्वों के लेआउट_आकर्षक और लेआउट_हाइट गुण सेट करने की आवश्यकता है, मिलान करने के लिए।

<ImageView
    android:layout_width="match_parent"
    android:layout_height="match_parent">

1

Com.google.android.material: सामग्री: 1.2.0-beta01 का उपयोग करके गोल कोने की छवि बनाने के लिए

 float radius = context.getResources().getDimension(R.dimen.border_radius_hug);
    shapeAppearanceModel = new ShapeAppearanceModel()
            .toBuilder()
            .setAllCorners(CornerFamily.ROUNDED,radius)
            .build();

imageView.setShapeAppearanceModel(shapeAppearanceModel)

या यदि आप इसे xml फ़ाइल में उपयोग करना चाहते हैं:

  <com.google.android.material.imageview.ShapeableImageView
            android:id="@+id/thumb"
            android:layout_width="80dp"
            android:layout_height="60dp"
            app:shapeAppearanceOverlay="@style/circleImageView"
            />

style.xml में इसे जोड़ें:

<style name="circleImageView" parent="">
      <item name="cornerFamily">rounded</item>
      <item name="cornerSize">10%</item>
</style>

0

अपने रैखिक लेआउट के साथ इस संपत्ति का प्रयास करें यह
उपकरण में मदद करेगा : संदर्भ = "। अव्यवस्था"


0
public static Bitmap getRoundedCornerBitmap(Bitmap bitmap, int pixels) {

        Bitmap roundedBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap
                .getHeight(), Config.ARGB_8888);
        Canvas canvas = new Canvas(roundedBitmap);

        final int color = 0xff424242;
        final Paint paint = new Paint();
        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        final RectF rectF = new RectF(rect);
        final float roundPx = pixels;

        paint.setAntiAlias(true);
        canvas.drawARGB(0, 0, 0, 0);
        paint.setColor(color);
        canvas.drawRoundRect(rectF, roundPx, roundPx, paint);

        paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);

        return roundedBitmap;
    }

0

मामले में आप कुछ विशिष्ट कोने को गोल करना चाहते हैं।

fun setCorners() {
        
        val mOutlineProvider = object : ViewOutlineProvider() {
            override fun getOutline(view: View, outline: Outline) {

                val left = 0
                val top = 0;
                val right = view.width
                val bottom = view.height
                val cornerRadiusDP = 16f
                val cornerRadius = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, cornerRadiusDP, resources.displayMetrics).toInt()

                // all corners
                outline.setRoundRect(left, top, right, bottom, cornerRadius.toFloat())

                /* top corners
                outline.setRoundRect(left, top, right, bottom+cornerRadius, cornerRadius.toFloat())*/

                /* bottom corners
                outline.setRoundRect(left, top - cornerRadius, right, bottom, cornerRadius.toFloat())*/

                /* left corners
                outline.setRoundRect(left, top, right + cornerRadius, bottom, cornerRadius.toFloat())*/

                /* right corners
                outline.setRoundRect(left - cornerRadius, top, right, bottom, cornerRadius.toFloat())*/

                /* top left corner
                outline.setRoundRect(left , top, right+ cornerRadius, bottom + cornerRadius, cornerRadius.toFloat())*/

                /* top right corner
                outline.setRoundRect(left - cornerRadius , top, right, bottom + cornerRadius, cornerRadius.toFloat())*/

                /* bottom left corner
                outline.setRoundRect(left, top - cornerRadius, right + cornerRadius, bottom, cornerRadius.toFloat())*/

                /* bottom right corner
                outline.setRoundRect(left - cornerRadius, top - cornerRadius, right, bottom, cornerRadius.toFloat())*/

            }
        }

        myView.apply {
            outlineProvider = mOutlineProvider
            clipToOutline = true
        }
    }

-1

आयत के साथ xml में आकृति का उपयोग करें। जैसा कि नीचे या ऊपरी त्रिज्या की संपत्ति चाहते हैं। तब उस url को पृष्ठभूमि के रूप में उर दृश्य पर लागू करें .... या ... कोड से इसे करने के लिए ढ़ाल का उपयोग करें।


मैं पहले से ही काम कर चुका हूं, लेकिन जानना चाहता हूं कि क्या बेहतर तरीका है?
Zach

अनुरोधकर्ता ने पहले ही अपने प्रश्न में इस दृष्टिकोण की कोशिश करने का उल्लेख किया है।
माइकल क्रूस
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.