Android Layouts

In Android, layouts define structure for the user interface shown on the window of the device. The structure in the layouts are built using Views and ViewGroups. These are the building block of any UI elements shown on the screen.

View: Refers to the element which the user can touch and interact with.

ViewGroup: Refers to an invisible component which contains Views, or other ViewGroups.

Below are some predefined Views and ViewGroups available in Android Library:

Views: Button, TextView (all these extend View class)

ViewGroups: LinearLayout, ConstraintLayout, RelativeLayout and many others (all these extend ViewGroup class)

What should you look for when defining layouts?

Layouts are a very important part of Android applications. The devices we use do not have unlimited memory, battery or similar other resources. Everything is limited. So designing layouts in an optimized way helps in making efficient use of available these resources. If implemented poorly your layout can lead to a memory hungry application with slow UIs and which directly impacts the user experience.

To achieve better layout performance we need to keep looking to optimize our layouts. A few ways we can achieve:
  • Always strive to achieve flatter hierarchies. Having complex, deeper hierarchy will cause a lot performance issues
  • Make UIs as reusable components. Use <include/>, <merge/> tags to avoid deeper hierarchy
  • To load views only when required i.e at runtime.

How to define a layout in the project?

Using XML

a. Defining a layout

All the layouts defined using XML are declared in the "res/layout" directory of the project. Each of those files have .xml as extension.



Diagram explanation

<androidx.appcompat.widget.LinearLayoutCompat
This is the root tag of this layout which is ViewGroup. Each layout file has exactly one root element. This just acts as a container to other views and view groups.

<com.google.android.material.button.MaterialButton
This is a view which extends the View class and part of Android material library (it can be easily understood from the path part of the view tag.

<FrameLayout
This is a view group which extends the ViewGroup class and part of the Android library.


b. Load the layout

To be able to show the UI to the user the defined layout needs to be loaded into the app code. Here is an example on how layout is loaded into the Activity component. Check the “setContentView” method.


Using code (dynamically added a View)

a. Creating a new View object

To create a new view dynamically the first step is to create a new object of the view class. In this example we have created a MaterialButton object using its constructor and have set its ID and text attribute.


b. Loading new view object into the ViewGroup

To let the newly created view object visible to the user we will have to add it to new ViewGroup or any existing view group defined in the XML or using code. Here in this example we are adding the new view object in the existing ViewGroup declared in the XML file with id "bodyLayout".

Resources

Location: India

Comments

Post a Comment

Popular posts from this blog

Fragment Lifecycle

Image
Just like Activities, Fragments also manages its own lifecycle. Though these lifecycle callbacks are a bit different than activity’s callbacks they exist for the similar reason as that of activity’s callback. Fragment manages two different lifecycles. One for the fragment instance and other for the view shown in the fragment. Having different lifecycle for fragment’s view is useful in the situations where the work should be performed only when view exists. Points to note: Fragment lifecycle call-backs are similar to Activity’s lifecycle. More important they are dependent on Activity’ state. Fragment manages 2 different lifecycles - Instance and View. Fragment callbacks are: onAttach, onCreate, onCreateView, onViewCreated, onViewStateRestored, onStart, onResume, onPause, onStop, onDestroyView, onDestroy, onDetach Fragment state is saved before onStop for API level less than 28 while in API level 28 and above its saved after onStop method. i.e In API level 28 or above devices its safe to...
Read more

AndroidManifest

Image
One of the most important components of your project. Stays in the root directory of the project source. This is used to describe essential information about the app to Android Build Tools, Android OS and Google Play. Most important things for which AndroidManifest is used: To declare app’s package name: Used by Android build tools to map code entities and to map it with applicationId defined in build.gradle To declare different app components: Include all activities, services, broadcast receivers, and content providers To declare app permissions: Helps in accessing specific restricted by System or other apps. To declare hardware and software features: Used to decide which device can app be installed into Package name and application ID Example <?xml version="1.0" encoding="utf-8"?>        <manifest            xmlns:android="http://schemas.android.com/apk/res/android"           package="co...
Read more

Activity Lifecycle

Image
To let Android System interact with Application different methods are defined by the system which communicate different states of the activity to the application. Those methods/states are called as Lifecycle Callbacks. Activity can go into different combination of these states. In the code each callback is used to understand the state in which the activity is in and accordingly perform different operations. Let’s discuss different activity callbacks and what each of them represent in real life scenarios. You will find each section explained with the 3 labels. Let us see what each label represents: Called: It will tell you when is this method called. Implement: What should be implemented in this method. State: What is the state of activity from user's perspective.                         onCreate() Called: This is the first callback received in Activity which is called as soon as the system creates the Activity. Implement: Used ...
Read more