Android: Image Processing with Picasso

Android apps often require dynamic image content in order to meet modern design standards. In this course, you will learn how to use the Picasso Image Library to work with images, such as managing request activity, caching, transformations, and more.
Course info
Level
Beginner
Updated
Mar 9, 2018
Duration
1h 57m
Table of contents
Course Overview
Getting Started with Picasso
Retrieving and Displaying Images
Controlling Image Transformations
Working with Caching
Managing Request Activity
Description
Course info
Level
Beginner
Updated
Mar 9, 2018
Duration
1h 57m
Description

As you learn to develop for Android you’ll quickly want to enhance your apps with dynamic image content. In this course, Android: Image Processing with Picasso you’ll learn how to manage and process images in using Picasso. First, you'll learn how Picasso is a popular, reusable, and lightweight library that reduces the technical problems of working with images. Next, you’ll learn how to utilize Picasso’s powerful features, like how to load images from different source locations, and maintain performance with caching. Finally, you’ll discover how to resize and transform images properly, manage request behavior, and much more. By the end of this course, you should feel comfortable building your own apps that display image content in dynamic ways.

About the author
About the author

Alex Wolf is passionate about software development and mastering new technologies. He has several years of experience working almost exclusively with the .NET Framework and related platforms. Alex is also a Microsoft Certified Professional in both MVC Application development and HTML 5 technologies. He loves learning new things!

More from the author
More courses by Alex Wolf
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hey everyone. My name is Alex Wolf, and welcome to this course on Android: Image Processing with Picasso. As you learn to develop for Android, you'll soon want to add dynamic image content to your apps. Images are one of the best ways to enhance app design and offer a more professional user experience. However, images can also introduce considerable technical challenges that repeatedly surface in every project. So in this course, you will learn how to manage and process images in your app using Picasso. Picasso is a popular, reusable, and lightweight library that reduces the technical problems of working with images. In this course, you'll learn how to utilize Picasso's powerful features like how to load images from different source locations, maintain performance with caching, resize and transform images properly, manage request behavior, and much more. By the end of this course, you should feel comfortable building your own apps that display image content in dynamic ways. Before starting this course, you should be familiar with general Android development such as working with activities, layouts, and responding to user interactions. Any prior knowledge of web service communication over HTTP is a helpful bonus, but certainly not required since we'll be starting with the basics. So I hope you'll join me on this journey to mastering Picasso and really take your apps to the next level, right here on Pluralsight.

Retrieving and Displaying Images
In this module, let's explore how to load and display images with Picasso in greater detail. This will include how to retrieve files from different locations, manage drawable resources in our project, and how to build interesting UI elements like galleries and lists. So first, we'll discuss the different locations or sources we can load images from using Picasso such as from a web server or local project assets. Next, we'll review some basic image-management concepts in Android. This will include how to work with various image file types and sizes for different devices and screens. Once we understand these basics, we'll move on to completing one of the tabs in our app. First, we'll see how to load images from our local project resources. We'll then see how to work with density-aware icons to further enhance our app design. Next, we'll review some of the essentials of working with ListViews and GridViews. Understanding these controls can help us build more interesting UI layouts such as galleries or CardViews. We'll then build out our first image gallery using Picasso and see how it integrates with our ListViews and adapters. Our starter project already has some of the ground work done for us, so we'll see how Picasso can finish this process for us. We'll also review the essentials of RecyclerViews and how they can be used to create more interesting list layouts like our featured items tab. We'll then put those concepts to work in another demo where we'll add Picasso to that existing RecyclerView structure. Finally, we'll see how to load image files on the device outside of our own app using URIs and intents. So by the end of this module, the visual design of our app will be largely complete. We have a lot of material to cover in this module, so let's get started in the next clip.

Controlling Image Transformations
Picasso offers a number of useful image transformation features. In this module, let's see how to use those options to influence the way our images are displayed. First, we'll explore the full list of features Picasso offers for manipulating images and look at a few use cases for each one. We'll then start by resizing some of the icons and images in our app to more appropriate dimensions for our layouts. We'll also see how to use Picasso's autoscaling features to improve the appearance of our galleries and better adjust certain images to different screen sizes. Once we're done resizing our images, we'll also see how to rotate them into different positions and just add some visual interest to our app design. Picasso also provides more advanced options to change the appearance of images through custom transformations. We'll discuss what this feature is capable of and how to get started with a basic example. We'll then put those concepts to work with a simple demonstration of custom image cropping. Image transformations can be really rewarding to work with since they provide very quick results with minimal code. So let's get started improving our app in the next clip.

Working with Caching
In this module, let's explore the robust caching features offered by Picasso. Now traditionally, caching can be a somewhat bland topic, but I really encourage you to complete this module. Picasso makes caching more enjoyable through the use of simple helper methods and fairly straightforward concepts. Caching can have an extremely significant impact on the overall performance and usability of your app so it's definitely a concept worth mastering. So we'll begin by reviewing some high-level concepts around caching, specifically in the context of Picasso in mobile apps. Once we're comfortable with those ideas, we'll see what tools Picasso offers to manage and configure those caching features. Next, we'll see how to monitor the cache activity of our app. This will allow us to understand its current behavior so we can modify and optimize it according to our user-experience goals. After we understand how our app is caching images, we'll see how to make simple configuration changes to achieve different results. We'll also take a closer look at Picasso's network caching policy. This is an interesting feature that allows your web server to influence the way images are cached on a device. Finally, we'll see how to gain further insight into our app's caching behavior through Picasso's logging and analysis features. So let's get started with an overview of Picasso caching in the next clip.

Managing Request Activity
In this finale module, let's look more closely at some of the other features Picasso offers for managing image requests. This will include topics like how to improve our image gallery's performance and user experience, how to add more custom logic to the loading process, and much more. So first, we'll explore how to background request images with Picasso and not display them immediately in an ImageView. This can be useful in some specific scenarios, particularly in the context of caching, which conveniently builds off of the concepts from the previous module. We'll then start with a simple example of how to handle situations where Picasso fails to load an image. There are a few different ways to deal with these situations, but we'll start with a technique that can handle the majority of use cases. Picasso also includes a feature to use placeholder images during the loading process so we'll see how to use this and improve the overall experience of our app. We'll also discuss a powerful feature called tags and how they can be used to control groups of requests at once, as well as the request lifecycle itself. We'll then use those tagging concepts to improve the performance and responsiveness of our image gallery. Finally, we'll discuss a concept called Picasso targets and how they can be used as alternatives to loading images directly into ImageViews, handle additional error scenarios, and more. Now many of the concepts in this module are extensions of previous topics we've explored in depth, so let's dive right into the code and make some final enhancements to our app.