Draw Circle on Image Android

When you need to brandish static images in your app, you can employ the Drawable course and its subclasses to draw shapes and images. A Drawable is a full general abstraction for something that can be drawn. The various subclasses help with specific image scenarios, and you can extend them to define your own drawable objects that carry in unique ways.

In that location are two means to define and instantiate a Drawable likewise using the class constructors:

• Inflate an prototype resource (a bitmap file) saved in your project.
• Inflate an XML resources that defines the drawable properties.

Annotation: Yous might instead adopt using a vector drawable, which defines an image with a set of points, lines, and curves, along with associated colour information. This allows vector drawables to be scaled for different sizes without a loss of quality. For more information, meet Vector drawables overview.

Create drawables from resource images

You tin add graphics to your app by referencing an epitome file from your projection resources. Supported file types are PNG (preferred), JPG (acceptable), and GIF (discouraged). App icons, logos, and other graphics, such equally those used in games, are well suited for this technique.

To utilise an paradigm resources, add your file to the res/drawable/ directory of your projection. Once in your project, you can reference the image resource from your code or your XML layout. Either way, information technology's referred to using a resource ID, which is the file name without the file blazon extension. For example, refer to my_image.png every bit my_image.

Note: Paradigm resources placed in the res/drawable/ directory may exist automatically optimized with lossless epitome compression past the aapt tool during the build procedure. For case, a true-colour PNG that doesn't crave more than 256 colors may be converted to an eight-bit PNG with a color palette. This results in an paradigm of equal quality but which requires less retention. As a outcome, the image binaries placed in this directory can alter at build fourth dimension. If you lot programme on reading an prototype equally a bitstream in club to convert it to a bitmap, put your images in the res/raw/ folder instead, where the aapt tool doesn't modify them.

The following code snippet demonstrates how to build an ImageView that uses an prototype created from a drawable resource and adds it to the layout:

Kotlin

individual lateinit var constraintLayout: ConstraintLayout  override fun onCreate(savedInstanceState: Packet?) {     super.onCreate(savedInstanceState)      // Instantiate an ImageView and define its properties     val i = ImageView(this).apply {         setImageResource(R.drawable.my_image)         contentDescription = resources.getString(R.string.my_image_desc)          // set the ImageView bounds to match the Drawable's dimensions         adjustViewBounds = truthful         layoutParams = ViewGroup.LayoutParams(                 ViewGroup.LayoutParams.WRAP_CONTENT,                 ViewGroup.LayoutParams.WRAP_CONTENT)     }      // Create a ConstraintLayout in which to add the ImageView     constraintLayout = ConstraintLayout(this).apply {          // Add together the ImageView to the layout.         addView(i)     }      // Ready the layout as the content view.     setContentView(constraintLayout) }            

Java

ConstraintLayout constraintLayout;  protected void onCreate(Bundle savedInstanceState) {   super.onCreate(savedInstanceState);    // Create a ConstraintLayout in which to add together the ImageView   constraintLayout = new ConstraintLayout(this);    // Instantiate an ImageView and define its properties   ImageView i = new ImageView(this);   i.setImageResource(R.drawable.my_image);   i.setContentDescription(getResources().getString(R.string.my_image_desc));    // set the ImageView bounds to match the Drawable's dimensions   i.setAdjustViewBounds(true);   i.setLayoutParams(new ViewGroup.LayoutParams(           ViewGroup.LayoutParams.WRAP_CONTENT,           ViewGroup.LayoutParams.WRAP_CONTENT));    // Add the ImageView to the layout and set the layout as the content view.   constraintLayout.addView(i);   setContentView(constraintLayout); }            

In other cases, you may want to handle your image resources every bit a Drawable object, equally shown in the following case:

Kotlin

val myImage: Drawable = ResourcesCompat.getDrawable(context.resources, R.drawable.my_image, null)            

Java

Resources res = context.getResources(); Drawable myImage = ResourcesCompat.getDrawable(res, R.drawable.my_image, zippo);            

Warning: Each unique resources in your project tin can maintain only one state, no matter how many dissimilar objects you instantiate for it. For case, if you instantiate two Drawable objects from the same image resource and change a holding (such every bit the alpha) for one object, so it also affects the other. When dealing with multiple instances of an image resource, instead of straight transforming the Drawable object yous should perform a tween animation.

The XML snippet below shows how to add a drawable resource to an ImageView in the XML layout:

<ImageView         android:layout_width="wrap_content"         android:layout_height="wrap_content"         android:src="@drawable/my_image"         android:contentDescription="@cord/my_image_desc" />        

For more than data about using project resources, see Resources and assets.

Note: When using image resource every bit the source of your drawables, be certain the images are the appropriate size for various pixel densities. If the images are not right they will be scaled up to fit, which can cause artifacting in your drawables. For more data, read Back up different pixel densities.

Create drawables from XML resources

If in that location is a Drawable object that you'd similar to create, which isn't initially dependent on variables defined by your lawmaking or user interaction, and so defining the Drawable in XML is a skilful option. Even if you expect your Drawable to modify its backdrop during the user'due south interaction with your app, you should consider defining the object in XML, as you can modify properties after the object has been instantiated.

After you've defined your Drawable in XML, save the file in the res/drawable/ directory of your projection. The following instance shows the XML that defines a TransitionDrawable resources, which inherits from Drawable:

<!-- res/drawable/expand_collapse.xml --> <transition xmlns:android="http://schemas.android.com/apk/res/android">     <item android:drawable="@drawable/image_expand"/>     <item android:drawable="@drawable/image_collapse"/> </transition>        

Then, retrieve and instantiate the object by calling Resources#getDrawable() and passing the resources ID of your XML file. Whatever Drawable bracket that supports the inflate() method can be defined in XML and instantiated by your app.

Each drawable class that supports XML inflation utilizes specific XML attributes that help define the object properties. The post-obit lawmaking instantiates the TransitionDrawable and sets it as the content of an ImageView object:

Kotlin

val transition= ResourcesCompat.getDrawable(         context.resources,         R.drawable.expand_collapse,         null ) as TransitionDrawable  val epitome: ImageView = findViewById(R.id.toggle_image) prototype.setImageDrawable(transition)  // Description of the initial state that the drawable represents. paradigm.contentDescription = resources.getString(R.string.complanate)  // Then yous can telephone call the TransitionDrawable object'due south methods. transition.startTransition(1000)  // Afterward the transition is complete, change the paradigm'south content description // to reverberate the new state.            

Coffee

Resource res = context.getResources(); TransitionDrawable transition =     (TransitionDrawable) ResourcesCompat.getDrawable(res, R.drawable.expand_collapse, nix);  ImageView image = (ImageView) findViewById(R.id.toggle_image); image.setImageDrawable(transition);  // Description of the initial land that the drawable represents. image.setContentDescription(getResources().getString(R.string.collapsed));  // Then you can phone call the TransitionDrawable object'due south methods. transition.startTransition(1000);  // Afterward the transition is complete, change the image'south content clarification // to reverberate the new state.            

For more than information most the XML attributes supported, refer to the classes listed above.

Shape drawables

A ShapeDrawable object can be a good pick when you want to dynamically draw a two-dimensional graphic. You lot can programmatically draw primitive shapes on a ShapeDrawable object and utilize the styles that your app needs.

ShapeDrawable is a bracket of Drawable. For this reason, you tin use a ShapeDrawable wherever a Drawable is expected. For example, you tin can use a ShapeDrawable object to ready the background of a view past passing it to the setBackgroundDrawable() method of the view. Yous tin likewise draw your shape equally its own custom view and add it to a layout in your app.

Because ShapeDrawable has its own draw() method, you tin create a subclass of View that draws the ShapeDrawable object during the onDraw() result, as shown in the post-obit code example:

Kotlin

class CustomDrawableView(context: Context) : View(context) {     individual val drawable: ShapeDrawable = run {         val ten = 10         val y = x         val width = 300         val height = 50         contentDescription = context.resources.getString(R.string.my_view_desc)          ShapeDrawable(OvalShape()).apply {             // If the colour isn't set, the shape uses black as the default.             paint.color = 0xff74AC23.toInt()             // If the premises aren't set up, the shape can't be drawn.             setBounds(x, y, x + width, y + superlative)         }     }      override fun onDraw(sheet: Canvas) {         drawable.draw(canvas)     } }            

Java

public class CustomDrawableView extends View {   private ShapeDrawable drawable;    public CustomDrawableView(Context context) {     super(context);      int x = 10;     int y = 10;     int width = 300;     int height = fifty;     setContentDescription(context.getResources().getString(             R.string.my_view_desc));      drawable = new ShapeDrawable(new OvalShape());     // If the color isn't ready, the shape uses black every bit the default.     drawable.getPaint().setColor(0xff74AC23);     // If the bounds aren't set, the shape can't be drawn.     drawable.setBounds(ten, y, ten + width, y + tiptop);   }    protected void onDraw(Canvas canvas) {     drawable.draw(canvass);   } }            

You can apply the CustomDrawableView class in the code sample above as you would use whatever other custom view. For example, you tin can programmatically add it to an activity in your app, equally shown in the following example:

Kotlin

individual lateinit var customDrawableView: CustomDrawableView  override fun onCreate(savedInstanceState: Bundle?) {     super.onCreate(savedInstanceState)     customDrawableView = CustomDrawableView(this)      setContentView(customDrawableView) }            

Java

CustomDrawableView customDrawableView;  protected void onCreate(Parcel savedInstanceState) {   super.onCreate(savedInstanceState);   customDrawableView = new CustomDrawableView(this);    setContentView(customDrawableView); }            

If you want to employ the custom view in the XML layout instead, so the CustomDrawableView grade must override the View(Context, AttributeSet) constructor, which is called when the grade is inflated from XML. The following example shows how to declare the CustomDrawableView in the XML layout:

<com.example.shapedrawable.CustomDrawableView         android:layout_width="fill_parent"         android:layout_height="wrap_content"         />        

The ShapeDrawable class, like many other drawable types in the android.graphics.drawable packet, allows yous to define various properties of the object by using public methods. Some instance properties you might want to conform include alpha transparency, colour filter, dither, opacity, and color.

You can also define primitive drawable shapes using XML resources. For more data, see Shape drawable in Drawable resource types.

NinePatch drawables

A NinePatchDrawable graphic is a stretchable bitmap prototype that yous can use equally the groundwork of a view. Android automatically resizes the graphic to accommodate the contents of the view. An instance use of a NinePatch image is the groundwork used by standard Android buttons—buttons must stretch to accommodate strings of various lengths. A NinePatch graphic is a standard PNG image that includes an actress ane-pixel border. It must be saved with the 9.png extension in the res/drawable/ directory of your projection.

Employ the border to define the stretchable and static areas of the image. You signal a stretchable department by drawing one (or more) 1-pixel wide black line(s) in the left and pinnacle part of the border (the other border pixels should be fully transparent or white). You lot can have as many stretchable sections every bit you want. The relative size of the stretchable sections stays the same, so the largest section always remains the largest.

You can also define an optional drawable section of the prototype (effectively, the padding lines) by drawing a line on the right and a line on the lesser. If a View object sets the NinePatch graphic as its groundwork and so specifies the view'due south text, it stretches itself so that all the text occupies only the surface area designated past the right and bottom lines (if included). If the padding lines aren't included, Android uses the left and pinnacle lines to define this drawable area.

To analyze the difference between the lines, the left and meridian lines define which pixels of the image are allowed to exist replicated in order to stretch the image. The lesser and right lines define the relative expanse within the image that the contents of the view are immune to occupy.

Figure 1 shows an case of a NinePatch graphic used to define a button:

Figure 1: Example of a NinePatch graphic that defines a button

This NinePatch graphic defines i stretchable area with the left and top lines, and the drawable surface area with the bottom and right lines. In the summit paradigm, the dotted grey lines identify the regions of the image that are replicated in order to stretch the image. The pink rectangle in the bottom image identifies the region in which the contents of the view are allowed. If the contents don't fit in this region, then the image is stretched to make them fit.

The Draw 9-patch tool offers an extremely handy way to create your NinePatch images, using a WYSIWYG graphics editor. It fifty-fifty raises warnings if the region yous've defined for the stretchable area is at hazard of producing cartoon artifacts as a result of the pixel replication.

The following sample layout XML demonstrates how to add a NinePatch graphic to a couple of buttons. The NinePatch image is saved to res/drawable/my_button_background.ix.png.

<Push android:id="@+id/tiny"         android:layout_width="wrap_content"         android:layout_height="wrap_content"         android:layout_alignParentTop="true"         android:layout_centerInParent="true"         android:text="Tiny"         android:textSize="8sp"         android:background="@drawable/my_button_background"/>  <Push android:id="@+id/big"         android:layout_width="wrap_content"         android:layout_height="wrap_content"         android:layout_alignParentBottom="true"         android:layout_centerInParent="true"         android:text="Biiiiiiig text!"         android:textSize="30sp"         android:background="@drawable/my_button_background"/>        

Notation that the layout_width and layout_height attributes are fix to wrap_content to make the button fit neatly around the text.

Figure 2 shows the two buttons rendered from the XML and NinePatch image shown in a higher place. Notice how the width and height of the button varies with the text, and the background epitome stretches to accommodate it.

Figure ii: Buttons rendered using an XML resource and a NinePatch graphic

Custom drawables

When yous want to create some custom drawings, you tin do and then by extending the Drawable course (or any of its subclasses).

The nigh important method to implement is depict(Canvas) because this provides the Canvas object you must utilize to provide your drawing instructions.

The following code shows a uncomplicated bracket of Drawable that draws a circumvolve:

Kotlin

course MyDrawable : Drawable() {     private val redPaint: Pigment = Paint().utilise { setARGB(255, 255, 0, 0) }      override fun describe(canvas: Sail) {         // Get the drawable's bounds         val width: Int = bounds.width()         val height: Int = bounds.top()         val radius: Float = Math.min(width, top).toFloat() / 2f          // Describe a reddish circle in the center         canvas.drawCircle((width / ii).toFloat(), (elevation / 2).toFloat(), radius, redPaint)     }      override fun setAlpha(alpha: Int) {         // This method is required     }      override fun setColorFilter(colorFilter: ColorFilter?) {         // This method is required     }      override fun getOpacity(): Int =         // Must be PixelFormat.UNKNOWN, TRANSLUCENT, TRANSPARENT, or OPAQUE         PixelFormat.OPAQUE }            

Coffee

public form MyDrawable extends Drawable {     private final Paint redPaint;      public MyDrawable() {         // Ready color and text size         redPaint = new Pigment();         redPaint.setARGB(255, 255, 0, 0);     }      @Override     public void draw(Canvas canvas) {         // Get the drawable's premises         int width = getBounds().width();         int height = getBounds().height();         float radius = Math.min(width, acme) / 2;          // Draw a cherry-red circle in the center         sheet.drawCircle(width/2, height/2, radius, redPaint);     }      @Override     public void setAlpha(int alpha) {         // This method is required     }      @Override     public void setColorFilter(ColorFilter colorFilter) {         // This method is required     }      @Override     public int getOpacity() {         // Must be PixelFormat.UNKNOWN, TRANSLUCENT, TRANSPARENT, or OPAQUE         return PixelFormat.OPAQUE;     } }            

Then you lot can add your drawable wherever you'd like, such as to an ImageView as shown here:

Kotlin

val myDrawing = MyDrawable() val image: ImageView = findViewById(R.id.imageView) prototype.setImageDrawable(myDrawing) image.contentDescription = resources.getString(R.string.my_image_desc)            

Java

MyDrawable mydrawing = new MyDrawable(); ImageView prototype = findViewById(R.id.imageView); image.setImageDrawable(mydrawing); prototype.setContentDescription(getResources().getString(R.string.my_image_desc));            

On Android 7.0 (API level 24) and higher, you tin can also ascertain instances of your custom drawable with XML in the following ways:

• Using the fully-qualified class name every bit the XML element name. For this approach, the custom drawable class must be a public top-level class:

  <com.myapp.MyDrawable xmlns:android="http://schemas.android.com/apk/res/android"     android:color="#ffff0000" />            

• Using drawable as the XML tag proper noun and specifying the fully-qualified grade name from the course attribute. This approach may be used for both public summit-level classes and public static inner classes:

  <drawable xmlns:android="http://schemas.android.com/apk/res/android"     grade="com.myapp.MyTopLevelClass$MyDrawable"     android:color="#ffff0000" />            

Add tint to drawables

With Android 5.0 (API level 21) and above, y'all can tint bitmaps and ix-patches defined as alpha masks. You lot can tint them with color resources or theme attributes that resolve to colour resources (for example, ?android:attr/colorPrimary). Usually, you create these assets just once and colour them automatically to lucifer your theme.

You can apply a tint to BitmapDrawable, NinePatchDrawable or VectorDrawable objects with the setTint() method. You can besides set the tint color and manner in your layouts with the android:tint and android:tintMode attributes.

The Android Support Library includes the Palette class, which lets you lot extract prominent colors from an image. You tin can load your drawables every bit a Bitmap and laissez passer it to Palette to access its colors. For more data, read Selecting colors with the Palette API.

tuttlewhichisatur.blogspot.com

Source: https://developer.android.com/guide/topics/graphics/drawables

Share this post