Mobile application run on different devices with different screen sizes and form factors. Android devices come in a variety of screen sizes and resolutions. That’s why handling the multiple screen size in android is most important.

Screen size : Actual physical size, measured as the screen’s diagonal.For simplicity, Android groups has four generalized sizes: small, normal, large, and extra large.

Screen density : The quantity of pixels within a physical area of the screen; usually referred to as dpi (dots per inch).For simplicity, Android groups has four generalized densities: low, medium, high, and extra high.

Orientation : The orientation of the screen from the user’s point of view.In Android, This is either landscape or portrait.

Resolution : The total number of physical pixels on a screen.In Android, we do not work directly with resolution; applications should be concerned only with screen size and density.

How To Support Different Screen’s

Use “wrap_content” and “match_parent”

To ensure that your layout is flexible and adapts to different screen sizes, you should use "wrap_content" and "match_parent" for the width and height of some view components. If you use "wrap_content", the width or height of the view is set to the minimum size necessary to fit the content within that view, while "match_parent" makes the component expand to match the size of its parent view.

By using the "wrap_content" and "match_parent" size values instead of hard-coded sizes, your views either use only the space required for that view or expand to fill the available space, respectively. For example:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <LinearLayout android:layout_width="match_parent" 
                  android:id="@+id/linearLayout1"  
                  android:gravity="center"
                  android:layout_height="50dp">
        <ImageView android:id="@+id/imageView1" 
                   android:layout_height="wrap_content"
                   android:layout_width="wrap_content"
                   android:src="@drawable/logo"
                   android:paddingRight="30dp"
                   android:layout_gravity="left"
                   android:layout_weight="0" />
        <View android:layout_height="wrap_content" 
              android:id="@+id/view1"
              android:layout_width="wrap_content"
              android:layout_weight="1" />
        <Button android:id="@+id/categorybutton"
                android:background="@drawable/button_bg"
                android:layout_height="match_parent"
                android:layout_weight="0"
                android:layout_width="120dp"
                style="@style/CategoryButtonStyle"/>
    </LinearLayout>
    <fragment android:id="@+id/headlines" 
              android:layout_height="fill_parent"
              android:name="com.example.android.newsreader.HeadlinesFragment"
              android:layout_width="match_parent" />
</LinearLayout>

Notice how the sample uses "wrap_content" and "match_parent" for component sizes rather than specific dimensions. This allows the layout to adapt correctly to different screen sizes and orientations.

Use RelativeLayout

You can construct fairly complex layouts using nested instances of LinearLayout and combinations of "wrap_content" and "match_parent" sizes. However, LinearLayout does not allow you to precisely control the spacial relationships of child views; views in a LinearLayout simply line up side-by-side. If you need child views to be oriented in variations other than a straight line, a better solution is often to use a RelativeLayout, which allows you to specify your layout in terms of the spacial relationships between components. For instance, you can align one child view on the left side and another view on the right side of the screen.

For example:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <TextView
        android:id="@+id/label"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Type here:"/>
    <EditText
        android:id="@+id/entry"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@id/label"/>
    <Button
        android:id="@+id/ok"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/entry"
        android:layout_alignParentRight="true"
        android:layout_marginLeft="10dp"
        android:text="OK" />
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_toLeftOf="@id/ok"
        android:layout_alignTop="@id/ok"
        android:text="Cancel" />
</RelativeLayout>

Use Size Qualifiers

There’s only so much mileage you can get from a flexible layout or relative layout like the one in the previous sections. While those layouts adapt to different screens by stretching the space within and around components, they may not provide the best user experience for each screen size. Therefore, your application should not only implement flexible layouts, but should also provide several alternative layouts to target different screen configurations. You do so by using configuration qualifiers, which allows the runtime to automatically select the appropriate resource based on the current device’s configuration (such as a different layout design for different screen sizes).

For example, many applications implement the “two pane” pattern for large screens (the app might show a list of items on one pane and the content on another pane). Tablets and TVs are large enough for both panes to fit simultaneously on screen, but phone screens have to show them separately. So, to implement these layouts, you could have the following files:

• res/layout/main.xml, single-pane (default) layout:
• <LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android"
  android:orientation=”vertical”
  android:layout_width=”match_parent”
  android:layout_height=”match_parent”>
• <fragment android:id=”@+id/headlines”
  android:layout_height=”fill_parent”
  android:name=”com.example.android.newsreader.HeadlinesFragment”
  android:layout_width=”match_parent” />
  </LinearLayout>
• res/layout-large/main.xml, two-pane layout:
• <LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android"
  android:layout_width=”fill_parent”
  android:layout_height=”fill_parent”
  android:orientation=”horizontal”>
  <fragment android:id=”@+id/headlines”
  android:layout_height=”fill_parent”
  android:name=”com.example.android.newsreader.HeadlinesFragment”
  android:layout_width=”400dp”
  android:layout_marginRight=”10dp”/>
  <fragment android:id=”@+id/article”
  android:layout_height=”fill_parent”
  android:name=”com.example.android.newsreader.ArticleFragment”
  android:layout_width=”fill_parent” />
  </LinearLayout>

Notice the large qualifier in the directory name of the second layout. This layout will be selected on devices with screens classified as large (for example, 7" tablets and above). The other layout (without qualifiers) will be selected for smaller devices.

Use the Smallest-width Qualifier

One of the difficulties developers had in pre-3.2 Android devices was the “large” screen size bin, which encompasses the Dell Streak, the original Galaxy Tab, and 7" tablets in general. However, many applications may want to show different layouts for different devices in this category (such as for 5" and 7" devices), even though they are all considered to be “large” screens. That’s why Android introduced the “Smallest-width” qualifier (amongst others) in Android 3.2.

The Smallest-width qualifier allows you to target screens that have a certain minimum width given in dp. For example, the typical 7" tablet has a minimum width of 600 dp, so if you want your UI to have two panes on those screens (but a single list on smaller screens), you can use the same two layouts from the previous section for single and two-pane layouts, but instead of the large size qualifier, use sw600dp to indicate the two-pane layout is for screens on which the smallest-width is 600 dp.

Use Layout Aliases

The smallest-width qualifier is available only on Android 3.2 and above. Therefore, you should also still use the abstract size bins (small, normal, large and xlarge) to be compatible with earlier versions. For example, if you want to design your UI so that it shows a single-pane UI on phones but a multi-pane UI on 7" tablets, TVs and other large devices, you’d have to supply these files:

• res/layout/main.xml: single-pane layout
• res/layout-large: multi-pane layout
• res/layout-sw600dp: multi-pane layout

Use Orientation Qualifiers

Some layouts work well in both landscape and portrait orientations, but most of them can benefit from adjustments. In the News Reader sample app, here is how the layout behaves in each screen size and orientation:

• small screen, portrait: single pane, with logo
• small screen, landscape: single pane, with logo
• 7" tablet, portrait: single pane, with action bar
• 7" tablet, landscape: dual pane, wide, with action bar
• 10" tablet, portrait: dual pane, narrow, with action bar
• 10" tablet, landscape: dual pane, wide, with action bar
• TV, landscape: dual pane, wide, with action bar

Use Nine-patch Bitmaps

Supporting different screen sizes usually means that your image resources must also be capable of adapting to different sizes. For example, a button background must fit whichever button shape it is applied to.

If you use simple images on components that can change size, you will quickly notice that the results are somewhat less than impressive, since the runtime will stretch or shrink your images uniformly. The solution is using nine-patch bitmaps, which are specially formatted PNG files that indicate which areas can and cannot be stretched.

Developing an Android app that looks good on multiple screen sizes and resolutions can be a challenging task. This tutorial will guide you through the steps required to design and develop an Android app that supports various screen sizes and resolutions, ensuring that your app looks great on a wide range of devices. We will cover the following topics: understanding screen sizes and resolutions, using Android Studio, creating layouts, and using resources (such as images and strings) to optimize your app for multiple screens.

Understanding Screen Sizes and Resolutions

Before starting the development process, it is essential to understand the terms related to screen sizes and resolutions. Here are some key terms:

• Screen size: The physical size of the display, usually measured in inches.
• Resolution: The number of pixels on the screen, represented as width x height (e.g., 1080x1920).
• Screen density: The number of pixels per inch (PPI) on the screen, which affects the sharpness of the images and text.
• Density-independent pixel (dp): A unit of measurement based on the physical density of the screen, which allows developers to create UI elements that appear the same size on different screen densities.

Using Android Studio

Android Studio is the official Integrated Development Environment (IDE) for Android app development. It provides a set of tools and features that make it easier to design, develop, and test your app on multiple screen sizes and resolutions. Here are some steps to set up your project in Android Studio:

1. Create a new project in Android Studio with a default "Empty Activity" template.
2. Open the "build.gradle (Module: app)" file and add the following line to the "defaultConfig" block:

defaultConfig {
    ...
    vectorDrawables.useSupportLibrary = true
}

This line enables support for vector drawables, which are scalable images that can be used as icons or illustrations in your app. Vector drawables are essential for creating apps that look sharp on different screen densities.

Creating Layouts

To create an app that looks good on multiple screen sizes and resolutions, you need to use responsive layouts. A responsive layout is a layout that automatically adapts to the screen size and orientation. Here are some tips for creating responsive layouts:

• Use ConstraintLayout as the root layout for your activities and fragments. ConstraintLayout is a flexible layout that allows you to create complex UIs with a flat view hierarchy, which can improve the performance of your app.
• Use RelativeLayout or LinearLayout as containers for your UI elements. These layouts can be nested inside ConstraintLayout and provide additional flexibility when arranging the UI elements.
• Use "wrap_content" and "match_parent" as the width and height attributes for your UI elements. These values automatically adjust the size of the elements based on their content or the size of their parent container.
• Use "dp" units for specifying the size and margins of your UI elements. This ensures that the elements appear the same size on different screen densities.
• Use percentage values for specifying the width and height of your UI elements inside ConstraintLayout. This allows the elements to scale proportionally with the screen size. For example:

<androidx.constraintlayout.widget.ConstraintLayout
    ...
    app:layout_constraintWidth_percent="0.5"
    app:layout_constraintHeight_percent="0.5">

Using Resources

Using resources is an essential part of developing an Android app that supports multiple screen sizes and resolutions. Resources are external files, such as images, strings, and styles, that can be loaded into your app at runtime. Here are some tips for using resources:

• Create different resource folders for different screen densities (e.g., "drawable-mdpi," "drawable-hdpi," "drawable-xhdpi," etc.). Place images with the appropriate resolution in each folder. This ensures that the images look sharp on different screen densities.
• Use vector drawables whenever possible. Vector drawables are scalable images that can be used as icons or illustrations in your app. They can be created using tools like Adobe Illustrator or converted from SVG files using Android Studio. Vector drawables can be placed in the "drawable" folder and used like regular images.
• Create different resource folders for different screen sizes (e.g., "values-small," "values-normal," "values-large," etc.). Place XML files with dimension values (e.g., "dimens.xml") and string values (e.g., "strings.xml") in each folder. This allows you to customize the size and text of your UI elements for different screen sizes.
• Use styles and themes to define the appearance of your app. Styles and themes are XML files that can be placed in the "values" folder and used to customize the appearance of your UI elements. This makes it easier to apply consistent styling across your app and adapt the appearance for different screen sizes and resolutions.

By following these guidelines and using the tools provided by Android Studio, you can create an Android app that looks great on multiple screen sizes and resolutions. This will ensure that your app provides a consistent user experience across a wide range of devices, which is essential for maximizing your app's reach and success. If you need additional help or resources, consider reaching out to hire Android developers who are experienced in creating apps that support multiple screens.