How to use Picasso image loader library

Example :
1) Create a new project in Eclipse or Android Studio. While doing so, choose a blank activity.
2) Open the layout file for main activity and add following ImageView to the layout.

<ImageView
    android:layout_width="@dimen/img_width"
    android:layout_height="@dimen/img_height"
    android:id="@+id/imageView"
    android:layout_alignParentTop="true"
    android:layout_centerHorizontal="true" />

3) Navigate to MainActivity file and add following lines of code in onCreate method.

     ImageView imageView = (ImageView) findViewById(R.id.imageView);
     Picasso.with(context)
                 .load(url")
                 .into(imageView);

In the first line, we get a reference to the ImageView instance in the layout file. We then load an image into the image view using the Picasso library. We first specify the context by calling with() and passing in the context. We then call the load() method and supply in it with the location of the image. Finally, we tell Picasso where it should display the image when it’s fetched by calling into() and pass in the image view object.

Load() method support resources, URL, and files as image sources

       Picasso.with(context).load(R.drawable.carImage).into(imageView);
       Picasso.with(context).load(Web URL).into(imageView);
       Picasso.with(context).load(new File(image_path)).into(imageView);

Placeholder and Error Fallback:
For any real-time application, we must think of all possible cases. Picasso provides placeholder and error fallback for ImageView. Placeholder is an image that will be shown before the image is loaded. Error fallback will be shown if, there is an error while downloading/loading image. Both fallback and placeholder are optional.

           Picasso.with(this)
                       .load(URL)
                       .placeholder(R.drawable.placeholder_image); // optional
                       .error(R.drawable.fallback_image)         // optional
                       .into(imageView);

Image Resize and rotating:
Picasso offers resizeDimen() and rotate() for resizing image to the size of ImageView while maintaining aspect ratio and rotating.

          Picasso.with(this)
                      .load(URL)
                      .placeholder(R.drawable.placeholder_image) 			// optional
                      .error(R.drawable.fallback_image)        				 // optional
                      .resizeDimen(R.dimen.image_width, R.dimen.image_height)	// optional
                      .rotate(90)								// optional
                      .into(imageView);

Transformations:
Custom transformation on images can be done using Bitmaps in android. But bitmaps are very memory consuming and slow down application especially when a lot of images needs to be loaded into a single activity. This forces us to implement memory caching and lazy loading technique leading to lots of code writing.
Picasso provides transform() function in which we can pass custom transformation to be applied to images. Here I am going transform a rectangular image into a circular thumbnail (many applications use the circular image for showing profile pictures like WhatsApp, Viber).
centreCrop() crop the image from its centre.

    Picasso.with(this)
                .load(URL)
                .placeholder(R.drawable.placeholder_image) 	// optional
                .error(R.drawable.fallback_image)        		// optional
                .transform(new RoundedTransformation(R.dimen.radius, R.dimen.margin))	// optional
                .resizeDimen(R.dimen.image_width, R.dimen. image_height)			// optional
                .centerCrop()									// optional
                .into(imageView);

In RoundedTransformation() value of radius should be more than half the size of image width or height (whichever is smaller).
Add following file in project’s src package. This RoundedTransformation.java contain code for rounded transformation.

 import android.graphics.Bitmap;
 import android.graphics.Bitmap.Config;
 import android.graphics.BitmapShader;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.RectF;
 import android.graphics.Shader;
 public class RoundedTransformation implements com.squareup.picasso.Transformation {
 private final int radius;
 private final int margin;  

 public RoundedTransformation(final int radius, final int margin) {
    this.radius = radius;
    this.margin = margin;
 }

 @Override
 public Bitmap transform(final Bitmap source) {
    final Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setShader(new BitmapShader(source,  Shader.TileMode.CLAMP, Shader.TileMode.CLAMP));
    Bitmap output = Bitmap.createBitmap(source.getWidth(), source.getHeight(), Config.ARGB_8888);
    Canvas canvas = new Canvas(output);
    canvas.drawRoundRect(new RectF(margin, margin, source.getWidth() - margin, source.getHeight() - margin), radius, radius, paint);

    if (source != output) {
        source.recycle();
    }
     return output;
 }
 @Override
  public String key() {
    return "rounded";
  }

}
These transformations will occur in the same background thread used to decode the original source bitmap and the final result will be stored in memory. This means you can store different transformations of the same source bitmap for future use.

4) Add Internet permission
Add following line in the manifest file of the project.

< uses-permission android:name=”android.permission.INTERNET” />

5) Finally, build and run the project.