- Creating a Basic Form
- Displaying Images
- Creating Maps and Displaying Websites
- Wrapping Up
This chapter is from the book
This chapter is from the book
This chapter is from the book
Displaying Images
Android phones feature large, high-resolution displays that are perfect for displaying images in your application. Images are an important way of conveying information to your users without explicitly stating it. Typically, images are displayed using the built-in image view. This view takes care of the loading and optimizing of the image, freeing you to focus on app-specific details like the layout and content. Unless you need special optimizations for your application, you should take advantage of the built-in image view whenever possible.
ImageView and Resources
The simplest way to display an image is to declare an ImageView in your layout file and set its source to a resource in your project. Image resources are placed in the /res/drawable folders. This example will display an image named “icon”:
<ImageView
android:id="@+id/image"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:scaleType="center"
android:src="@drawable/icon" />
The ImageView handles all the loading and scaling of the image for you. Note the scaleType attribute? This defines how the images will be scaled to fit in your layout. In the example, using scale type center, the image will be displayed at its native resolution and centered in the view, regardless of how much space the view consumes. Other scaling options fit the image to the dimensions of the image view or scale the image based on the width and height of the device. Table 4.1 lists the scale type options and how they alter the image.
Table 4.1 ImageView Scale Types
|
Scale Type |
Description |
|
center |
Displays the image centered in the view with no scaling. |
|
centerCrop |
Scales the image such that both the x and y dimensions are greater than or equal to the view, while maintaining the image aspect ratio; crops any part of the image that exceeds the size of the view; centers the image in the view. |
|
centerInside |
Scales the image to fit inside the view, while maintaining the image aspect ratio. If the image is already smaller than the view, then this is the same as center. |
|
fitCenter |
Scales the image to fit inside the view, while maintaining the image aspect ratio. At least one axis will exactly match the view, and the result is centered inside the view. |
|
fitStart |
Same as fitCenter but aligned to the top left of the view. |
|
fitEnd |
Same as fitCenter but aligned to the bottom right of the view. |
|
fitXY |
Scales the x and y dimensions to exactly match the view size; does not maintain the image aspect ratio. |
|
matrix |
Scales the image using a supplied Matrix class. The matrix can be supplied using the setImageMatrix method. A Matrix class can be used to apply transformations such as rotations to an image. |
Tip
The fitXY scale type allows you to set the exact size of the image in your layout. However, be mindful of potential distortions of the image due to scaling. If you’re creating a photo-viewing application, you will probably want to use the center or fitCenter scale types.
Figure 4.9 shows examples of the scale types. Using the correct scale type is important if you want to properly display images.
){kind=link}
)
Figure 4.9 Examples of android:scaleType attribute. Top row (l-r) center, centerCrop, centerInside. Bottom row (l-r): fitCenter, fitStart, fitEnd, fitXY.
Bitmaps
Images used in your application are stored in the /res/drawable folders. These folders follow the device-configuration naming scheme to provide different images for different devices. Typically, you will create four different versions of each image and place them in the following folders: drawable-ldpi, drawable-mdpi, drawable-hdpi, and drawable-xhdpi. These represent the increasing resolutions of each device, and appropriately sized images should be placed in each. Use the same filename for each of the different versions, and then when you specify the drawable name, the Android resources manager will choose the image from the appropriate folder.
It’s not always necessary to create an image for a particular resolution; Android will display whatever image is the best match. In general, Android will prefer scaling an image down in size so that images are always crisp and not blurred. By default, you should create hdpi-resolution images. However, you should strive to create resources for all resolutions to prevent unnecessary hardware scaling, which slows down the drawing of your UI. Once your image resources are placed in the res/drawable folders, you can reference them the same way you reference your layout files: via the R.java file.
NOTE
Image resources in your project should be in one of three formats: PNG (preferred), JPEG (acceptable), and GIF (discouraged). Of course, 9-patch images are also accepted.
Including images in the res/drawable folders is a simple way of adding images to your app. However, it’s also possible to create images at runtime and add them to your layout. For example, you may want to download an image from the Internet and display it to the user. To do this, you create a Bitmap object to encapsulate the image, and then load it into your UI. The Bitmap class is simply an object that references a bitmap image. You can use a BitmapFactory to create a bitmap image from any source: a resource in your app, a file, or even an arbitrary InputStream. A bitmap can then be loaded into an image view by calling setImageBitmap. Here is an example:
Bitmap bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888); ImageView iv = (ImageView) findViewById(R.id.image); iv.setImageBitmap(bitmap);
Drawables
Not all graphics need to be images—Android also lets you create graphics by using XML or writing custom drawing code. You’ll learn more about creating custom graphics using Canvas and other classes in Chapter 11. To create graphics using XML, you use the Drawable class. A drawable represents something that can be drawn on the screen. This can be an image, an XML resource, or a custom class. The Drawable class is the general abstraction for representing all of these in your UI.
The Android framework makes extensive use of drawables for all the built-in UI views. One of the most common is the Button class, which uses an XML file to define the possible states a button can have. Here is an example XML file for Button:
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:state_pressed="true"
android:drawable="@drawable/button_pressed" />
<item android:state_focused="true"
android:drawable="@drawable/button_focused" />
<item android:state_hovered="true"
android:drawable="@drawable/button_hovered" />
<item android:drawable="@drawable/button_normal" />
</selector>
This is called a StateListDrawable. It defines a set of drawables associated with different states. In this example, there are four possible states the button can be in: normal, hovered, focused, and pressed. Each item in the StateListDrawable defines a drawable that will be displayed when the button is in the specified state. In this case, the android:drawable attribute references an actual image drawable. The StateListDrawable does not select the best matching item, but rather selects the first item that meets the criteria for the current state. It performs this search from top to bottom, so the order in which you place each item is important. Using different drawables for button states provides feedback to the user when they are interacting with the UI.
There are more options than just defining states for a drawable. There are formats that create simple transformations of an existing bitmap or add padding and dithering to an image. You can combine several bitmaps to create a composite image. Or you can use XML to actually draw a shape using the ShapeDrawable class. You can add gradients, shadows, and rounded corners. The full range of XML drawable options is outside the scope of this book, but you should familiarize yourself with the available options. If you find yourself contemplating creating custom graphics to achieve the effects you want, consider using a drawable resource that may already be available.
In addition to displaying images using drawables and bitmaps, you have the option to create custom graphics using classes like Canvas, SurfaceView, and TextureView. You’ll learn more about this in Chapter 11.
NOTE
Drawing images into a view uses the system’s standard drawing process. In Android versions earlier than 3.0, this process is not fully hardware accelerated. Be aware that graphics-intensive applications using this process will not perform well on older versions of Android.