Angoli arrotondati antialias su Android ImageView

Question

Sono nuovo di Android Dev, e ho cercato per un paio d'ore ora di aggiungere angoli arrotondati piacevole e liscia a un ImageView, senza successo.

prima cosa che ho provato è semplicemente per arrotondare gli angoli di direttamente le mie immagini, ma questo implica cambiare la bitmap, e dal momento che ho bisogno di mantenere quelle prime, e quelli sono abbastanza grande, questo non è davvero la memoria amichevole. Ciò causerebbe anche altre difficoltà dal momento che il mio ImageView è fluido.

La seconda cosa che ho provato ad usare è il metodo clipPath dopo la sottoclasse della vista. Funziona, ma gli angoli sono alias. Ho quindi provato ad aggiungere un PaintFlagsDrawFilter per implementare l'aliasing, ma questo non ha funzionato. Sto usando monodroid, e mi chiedevo che questo avrebbe dovuto funzionare in Java.

Ecco il mio codice (C#):

public class MyImageView : ImageView 
{ 
    private float[] roundedCorner; 

    /** 
    * Contains the rounded corners for the view. 
    * You can define one, four or height values. 
    * This behaves as the css border-radius property 
    * 
    * @see http://developer.android.com/reference/android/graphics/Path.html#addRoundRect(android.graphics.RectF, float[], android.graphics.Path.Direction) 
    */ 
    public float[] RoundedCorners{ 
     get{ 
      return roundedCorner; 
     } 
     set{ 
      float[] finalValue = new float[8]; 
      int i=0; 
      if(value.Length == 1){ 
       for(i=0; i<8;i++){ 
        finalValue[i] = value[0]; 
       } 
      }else if(value.Length == 4){ 
       for(i=0; i<4;i++){ 
        finalValue[2*i] = value[i]; 
        finalValue[2*i+1] = value[i]; 
       } 
      } 

      roundedCorner = finalValue; 
     } 
    } 

    public SquareImageView (Context context) : 
     base (context) 
    { 
     Initialize(); 
    } 

    public SquareImageView (Context context, IAttributeSet attrs) : 
     base (context, attrs) 
    { 
     Initialize(); 
    } 

    private void Initialize() 
    { 
     RoundedCorners = new float[]{0,0,0,0}; 
    } 

    public override void Draw (Android.Graphics.Canvas canvas) 
    { 
     Path path = new Path(); 
     path.AddRoundRect(new RectF(0,0, Width,Height),RoundedCorners, Path.Direction.Cw); 

     canvas.ClipPath(path); 

     base.Draw (canvas); 
    } 

    /** 
    * try to add antialiasing. 
      */ 
    protected override void DispatchDraw (Canvas canvas) 
    { 

     canvas.DrawFilter = new PaintFlagsDrawFilter((PaintFlags)1, PaintFlags.AntiAlias); 
     base.DispatchDraw (canvas); 
    } 

} 

Grazie per il vostro aiuto!

Answer 1

uso sottostante Codice

public Bitmap getRoundedCornerBitmap(Bitmap bitmap, int pixels) 
    { 
     Bitmap output = null; 

     if(bitmap != null) 
     { 
      output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888); 
      Canvas canvas = new Canvas(output); 

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

e chiamare questo metodo come

imageView.setImageBitmap(getRoundedCornerBitmap(bitmap, 10)); 

Answer 2

Ho creato un RoundedImageView in base al largo di example code Romain Guy che avvolge questa logica in un ImageView che si dovrebbe essere in grado di basta usare Supporta i bordi e l'antialiasing out of the box.

È più efficiente degli altri esempi di angoli arrotondati perché non crea un'altra copia della bitmap, né usa clipPath che disegna due volte sul canvas.