However, the real challenge begins when you attempt to use an app and have to log in. In some cases, it's more than just a simple login. Users may forget their login email, username, or password.

In today's digital world, people use different passwords for various purposes, which can lead to confusion. This issue sometimes results in users either creating a new account or abandoning the app altogether.

Block Store can solve this problem. The Block Store API aims to make logging back into users' applications on a new device as simple as restoring from a backup during the setup process.

This allows users to return to their apps just as they left them. Read on to learn more about Block Store, its benefits, and how to provide users with a seamless experience!

How BlockStore Works?

Blockstore is a Google Play Services API that allows developers to store and restore small amounts of data on an Android device. This data can be anything important to the current user session, such as an authentication token, a user preference, or a small piece of file data.

Blockstore data is stored in an encrypted file on the device. This file is only accessible to the app that created it, and it cannot be accessed by other apps.

When a user signs into your app, you can save their authentication token to Blockstore. This token will then be stored on the device and will be available when the user signs in again on a different device.

Blockstore data can also be used to transfer data between devices. For example, if a user has your app installed on two devices, you can use Blockstore to transfer their user preferences from one device to the other.

This allows for a seamless user experience, as the user will not have to re-enter their preferences when they switch devices.

Here is how Blockstore works in more detail:

1. When a developer wants to store data in Blockstore, they call the putBytes() method. This method takes two parameters: the data to be stored, and a unique identifier for the data.

2. The putBytes() the method encrypts the data and stores it in the Blockstore file. The unique identifier is used to associate the data with the app that created it.

3. When a developer wants to retrieve data from Blockstore, they call the retrieveBytes() method. This method takes the unique identifier for the data as a parameter and returns the encrypted data.

4. The developer can then decrypt the data and use it as they see fit.

Example of Saving a Token -

 val client = Blockstore.getClient(this)

  val bytes1 = byteArrayOf(1, 2, 3, 4) // Store one data block.
  val key1 = "com.example.app.key1"
  val storeRequest1 = StoreBytesData.Builder()
    .setBytes(bytes1) // Call this method to set the key value with which the data should be associated with.
    .setKeys(Arrays.asList(key1))
    .build()
  client.storeBytes(storeRequest1)
    .addOnSuccessListener { result: Int ->
      Log.d(TAG,
            "Stored $result bytes")
    }
  .addOnFailureListener { e ->
      Log.e(TAG, "Failed to store bytes", e)
    }

Source: 2021 Google LLC.

Example of retrieving a token -

val client = Blockstore.getClient(this)

// Retrieve data associated with certain keys.
val key1 = "com.example.app.key1"
val key2 = "com.example.app.key2"
val key3 = BlockstoreClient.DEFAULT_BYTES_DATA_KEY // Used to retrieve data stored without a key

val requestedKeys = Arrays.asList(key1, key2, key3) // Add keys to array

val retrieveRequest = RetrieveBytesRequest.Builder()
  .setKeys(requestedKeys)
  .build()

client.retrieveBytes(retrieveRequest)
  .addOnSuccessListener { result: RetrieveBytesResponse ->
    val blockstoreDataMap =
      result.blockstoreDataMap
    for ((key, value) in blockstoreDataMap) {
      Log.d(ContentValues.TAG, String.format(
        "Retrieved bytes %s associated with key %s.",
        String(value.bytes), key))
    }
  }
  .addOnFailureListener { e: Exception? ->
    Log.e(ContentValues.TAG,
          "Failed to store bytes",
          e)
  }

Source: 2021 Google LLC.

In conclusion, Blockstore offers a seamless and secure solution for storing and transferring app-specific data on Android devices.

By leveraging this API, developers can enhance user experience and reduce the hassle of logging in or setting up preferences across multiple devices. As users increasingly rely on multiple devices, integrating Blockstore into your app can significantly improve user satisfaction and retention.

That's all for now. To learn more check out the documentation.

If you enjoyed the article, please give it a thumbs up. Happy coding!

One such feature is interceptors, which allow developers to modify and observe HTTP requests and responses. In this blog post, we will explore interceptors in OkHttp and understand how they can be used effectively in Android applications.

What are Interceptors?

An interceptor in OkHttp is a powerful mechanism that sits between the application and the network. It intercepts and modifies HTTP requests and responses, enabling developers to perform various tasks like logging, authentication, caching, and more.

According to documentation, Interceptors are a powerful mechanism that can monitor, rewrite, and retry the API call. So basically, when we do some API call, we can monitor the call or perform some tasks.

It acts as a middleware, providing a way to intercept and manipulate network communication without modifying the existing codebase.

Working Principle: When an HTTP request is made using OkHttp, interceptors come into action. OkHttp allows you to add interceptors to the client, which will be executed in the order they are added.

Each interceptor has the opportunity to inspect and modify the request before it is sent to the server and the response before it reaches the application.

Types of Interceptors: OkHttp provides two types of interceptors: application interceptors and network interceptors.

1. Application Interceptors: Application interceptors work on the application layer and have access to both the request and response. They are ideal for tasks like adding headers, logging, request/response modification, and authentication. These interceptors are executed first, allowing them to observe the entire network interaction.

2. Network Interceptors: Network interceptors operate on the network layer and have access to the raw network response. They are useful for tasks like caching, transparently decompressing responses, and rewriting responses. Network interceptors are executed after the application interceptors, enabling them to modify the response coming from the server.

Using Interceptors in OkHttp: To use interceptors in your OkHttp client, follow these steps:

1. Create an Interceptor: First, create a class that implements the Interceptor interface. This class will define the logic you want to execute when the interceptor intercepts a request or response.

2. Implement Interceptor Logic: Inside the interceptor class, override the intercept method. This method receives an Chain object that allows you to access and modify the request and response.

3. Add Interceptors to the OkHttp Client: Create an OkHttp OkHttpClient instance and add your interceptors using the addInterceptor or addNetworkInterceptor methods. Application interceptors should be added using, and network interceptors should be added using addNetworkInterceptor.

4. Make HTTP Requests: With the interceptors added to the client, you can now make HTTP requests using OkHttp as usual. The interceptors will automatically intercept the requests and responses, executing the logic you defined.

Here are a few examples of what you can do with interceptors in Kotlin using the OkHttp library:

Logging Interceptor:

You can create an interceptor that logs the details of your network requests and responses.

This can help debug or monitor network activity. You can log information like request method, URL, headers, and response code.

val loggingInterceptor = HttpLoggingInterceptor().apply {
    level = HttpLoggingInterceptor.Level.BODY
}

val client = OkHttpClient.Builder()
    .addInterceptor(loggingInterceptor)
    .build()

Authentication Interceptor:

This interceptor can be used to add authentication headers to your requests. For example, if your API requires an access token, you can check if the token is present in the request and add it if needed. If the token is expired, you can refresh it and retry the request.

val authInterceptor = Interceptor { chain ->
    val originalRequest = chain.request()
    val authenticatedRequest = originalRequest.newBuilder()
        .header("Authorization", "<your_access_token>")
        .build()
    chain.proceed(authenticatedRequest)
}

val client = OkHttpClient.Builder()
    .addInterceptor(authInterceptor)
    .build()

Header Interceptor:

You can use this interceptor to add or modify headers in your requests. This can be useful for adding custom headers required by your server, such as API keys or user agent information.

val headerInterceptor = Interceptor { chain ->
    val originalRequest = chain.request()
    val modifiedRequest = originalRequest.newBuilder()
        .header("Custom-Header", "value")
        .build()
    chain.proceed(modifiedRequest)
}

val client = OkHttpClient.Builder()
    .addInterceptor(headerInterceptor)
    .build()

Caching Interceptor:

This interceptor can implement caching strategies. You can intercept the responses and cache them locally based on specific criteria like response headers or URLs.

This can improve performance by reducing network requests for resources that are already cached.

val cache = Cache(context.cacheDir, CACHE_SIZE)

val cacheInterceptor = Interceptor { chain ->
    val originalResponse = chain.proceed(chain.request())
    val cacheControl = originalResponse.header("Cache-Control")

    if (cacheControl == null || cacheControl.contains("no-store") ||
        cacheControl.contains("no-cache") || cacheControl.contains("must-revalidate") ||
        cacheControl.contains("max-age=0")
    ) {
        originalResponse.newBuilder()
            .header("Cache-Control", "public, max-age=${CACHE_MAX_AGE}")
            .build()
    } else {
        originalResponse
    }
}

val client = OkHttpClient.Builder()
    .addNetworkInterceptor(cacheInterceptor)
    .cache(cache)
    .build()

Offline Mode Interceptor:

You can create an interceptor that checks if the device is offline and returns cached responses instead of making network requests. This can help your app work offline by serving data from the cache when there is no internet connectivity.

val offlineInterceptor = Interceptor { chain ->
    var request = chain.request()
    if (!isOnline()) {
        request = request.newBuilder()
            .header("Cache-Control", "public, only-if-cached")
            .build()
    }
    chain.proceed(request)
}

val client = OkHttpClient.Builder()
    .addInterceptor(offlineInterceptor)
    .build()

// Helper method to check network connectivity
fun isOnline(): Boolean {
    val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val networkInfo = connectivityManager.activeNetworkInfo
    return networkInfo != null && networkInfo.isConnected
}

Error Handling Interceptor:

This interceptor can handle specific HTTP error codes and perform actions accordingly. For example, if you receive a 401 Unauthorized response, you can automatically redirect the user to the login screen.

val errorInterceptor = Interceptor { chain ->
    val response = chain.proceed(chain.request())
    if (!response.isSuccessful && response.code == 401) {
        // Handle 401 Unauthorized error here
        // For example, redirect the user to the login screen
    }
    response
}

val client = OkHttpClient.Builder()
    .addInterceptor(errorInterceptor)
    .build()

Rewriting Responses

Interceptors can modify the headers of a response and change the content of the response itself. However, this action can be riskier compared to modifying request headers because it might go against what the web server expects.

In challenging situations, if you are willing to accept the potential consequences, rewriting response headers can be a powerful solution to overcome issues. For instance, you can correct a server's misconfigured Cache-Control response header to improve response caching.

val rewriteCacheControlInterceptor = Interceptor { chain ->
    val originalResponse = chain.proceed(chain.request())
    val modifiedResponse = originalResponse.newBuilder()
        .header("Cache-Control", "max-age=60")
        .build()
    modifiedResponse
}

conclusion

interceptors in OkHttp are powerful tools that enable developers to efficiently handle various tasks like logging, authentication, caching, and error handling in Android applications.

By understanding the working principles and types of interceptors, developers can enhance their applications' performance and functionality while maintaining a clean and modular codebase.

4. Sets

In simple terms, a set is a data structure that represents a collection of unique elements. It's like a container that can hold different objects, but it only keeps track of each object once, even if it appears multiple times in the collection.

Think of it like a bag where you can put various items. However, in a set, you won't find any duplicates. If you try to add the same item to the set again, it won't change because the set already contains that item.

Sets are useful when you want to keep track of a group of distinct elements without worrying about their order or how many times they appear. You can perform operations on sets like adding elements, removing elements, or checking if a specific element is present in the set.

For example, imagine you have a set of fruits that includes an apple, a banana, and an orange. If you try to add another apple to the set, it won't make a difference because the set already has an apple. However, if you add a strawberry, it will be included because it's a new element. Similarly, if you remove the banana, it will no longer be part of the set.

fun main() {
    // Creating a set of fruits
    val fruitSet = mutableSetOf("apple", "banana", "orange")

    // Adding an element to the set
    fruitSet.add("strawberry")

    // Trying to add a duplicate element
    fruitSet.add("apple")

    // Removing an element from the set
    fruitSet.remove("banana")

    // Checking if an element is present in the set
    val containsOrange = fruitSet.contains("orange")
    val containsGrapes = fruitSet.contains("grapes")

    // Printing the set
    println(fruitSet)

    // Printing the results of the membership checks
    println("Contains orange: $containsOrange")
    println("Contains grapes: $containsGrapes")
}

Output -

[strawberry, apple, orange]
Contains orange: true
Contains grapes: false

Sets are often used in programming to solve problems involving uniqueness and membership checks efficiently.

5.Queue

a queue is a data structure that represents a collection of elements arranged in a specific order. It follows the principle of "first in, first out" (FIFO), which means that the element that enters the queue first will be the first one to be removed.

Think of a queue as a line of people waiting for something, such as waiting in line at a ticket counter or a bus stop. The person who arrives first is the first to be served or get on the bus, and as more people join the line, they stand behind the others. Similarly, in a queue data structure, elements are added at one end and removed from the other end.

You can perform two main operations on a queue:

1. Enqueue: This operation adds an element to the end of the queue. It represents joining the line or adding a new person to the back of the line.

2. Dequeue: This operation removes the element from the front of the queue. It represents serving the first person in line or the person who has been waiting the longest.

Queues are useful when you need to manage a sequence of elements where the order of insertion is important. They are commonly used in scenarios where elements arrive or need to be processed in a specific order, such as task scheduling, message processing, or breadth-first search algorithms.

import java.util.LinkedList

fun main() {
    // Create a queue
    val queue: Queue<String> = LinkedList()

    // Enqueue elements
    queue.offer("Element 1")
    queue.offer("Element 2")
    queue.offer("Element 3")

    // Dequeue elements
    val dequeuedElement = queue.poll()

    // Print the dequeued element
    println("Dequeued element: $dequeuedElement")

    // Peek at the front element without dequeuing
    val frontElement = queue.peek()

    // Print the front element
    println("Front element: $frontElement")

    // Print the entire queue
    println("Queue: $queue")
}

Output -

Dequeued element: Element 1
Front element: Element 2
Queue: [Element 2, Element 3]

In this example, we use the LinkedList class from the Java standard library to implement the queue. We create a queue called queue using the Queue interface.

We enqueue elements into the queue using the offer function, which adds elements to the rear of the queue.

Next, we dequeue an element from the front of the queue using the poll function, which also removes the element from the queue. The dequeued element is stored in the dequeuedElement variable.

We then use the peek function to access the front element of the queue without removing it. The front element is stored in the frontElement variable.

Finally, we print the dequeued element, the front element, and the entire queue.

Note that we're using the Queue interface, which provides basic queue operations like offer, poll, and peek. The LinkedList class is used as the concrete implementation of the queue, but you can also use other implementations such as ArrayDeque.

6.Stack

A Stack is a data structure that represents a collection of elements in a specific order. It follows the principle of "last in, first out" (LIFO), which means that the element that enters the stack last will be the first one to be removed.

Think of a stack like a stack of plates. When you add a new plate, you place it on top of the stack. Similarly, when you remove a plate, you take the one from the top. The last plate you put on the stack is the first one you can access or remove.

You can perform two main operations on a stack:

1. Push: This operation adds an element to the top of the stack. It represents placing a new plate on top of the stack.

2. Pop: This operation removes the element from the top of the stack. It represents taking the plate from the top of the stack.

Stacks are useful when you need to manage elements in a last-in, first-out manner. They are commonly used in scenarios where you want to keep track of the order of operations or process elements in reverse order, such as function call stacks, undo/redo functionality, or parsing expressions.

This is how to stack internal implementation looks like

class Stack<T> {
    private val stackList = mutableListOf<T>()

    fun push(element: T) {
        stackList.add(element)
    }

    fun pop(): T? {
        if (stackList.isEmpty()) {
            return null
        }
        val lastIndex = stackList.size - 1
        return stackList.removeAt(lastIndex)
    }

    fun peek(): T? {
        if (stackList.isEmpty()) {
            return null
        }
        val lastIndex = stackList.size - 1
        return stackList[lastIndex]
    }

    fun isEmpty(): Boolean {
        return stackList.isEmpty()
    }

    fun size(): Int {
        return stackList.size
    }
}

fun main() {
    val stack = Stack<Int>()

    stack.push(1)
    stack.push(2)
    stack.push(3)

    println("Stack size: ${stack.size()}")
    println("Top element: ${stack.peek()}")

    val poppedElement = stack.pop()
    println("Popped element: $poppedElement")

    println("Is the stack empty? ${stack.isEmpty()}")
}

Output -

Stack size: 3
Top element: 3
Popped element: 3
Is the stack empty? false

In Android development, the stack data structure is commonly used in various scenarios, including:

1. Activity Stack: Android uses a stack to manage the activity lifecycle. When a new activity is launched, it is placed on top of the activity stack. When the user navigates back, the top activity is popped from the stack and the previous activity is resumed. This allows for a hierarchical flow of activities, with the back button behaviour following a stack-like structure.

2. Fragment Back Stack: Fragments in Android can also be managed using a stack-like structure. Fragments are added to a back stack, and when the user navigates back, the top fragment is popped and the previous fragment is shown. This enables navigation within a single activity using the Fragment Manager.

3. Undo/Redo Functionality: Android apps often provide undo and redo functionality for user actions. A stack data structure can be used to store the history of actions, allowing users to revert or redo their actions by popping or pushing elements onto the stack.

4. Navigation History: Navigation within Android apps, especially those using navigation components like Navigation Architecture Component, often relies on a stack-like structure. As users navigate through different screens or destinations, the app maintains a navigation stack, allowing users to navigate back through the history of visited screens.

5. Input Events: In certain cases, the stack data structure can be utilized to manage input events or tasks that need to be processed in a specific order. For example, if an app receives a stream of user inputs, the inputs can be pushed onto a stack and processed in reverse order, ensuring that the most recent input is handled first.

These are just a few examples of how the stack data structure is used in Android development. Stacks are particularly useful in scenarios involving hierarchical or sequential operations where the last item processed or accessed needs to be prioritized.

7.Tree

Certainly! Think of a tree data structure as a visual representation of a hierarchical relationship between elements. Just like a tree in nature, a tree data structure has a root at the top, branches that extend downwards and leaves at the bottom.

• Root: The root is the starting point of the tree. It is the topmost node and has no parent. Think of it as the base of the tree.

• Node : Each element in the tree is called a node. A node can have some associated data and can be connected to other nodes.

• Parent and Child: Nodes in a tree have parent-child relationships. A parent node is connected to its child nodes, and child nodes are connected to their parent. A node can have multiple child nodes but only one parent.

• Leaf: A leaf is a node that does not have any children. It is at the bottom of the tree.

• Branch: A branch is a connection between a parent node and its child node. It represents the path from one node to another.

• Depth: The depth of a node is the number of edges from the root to that node. The depth of the root node is 0, and the depth of other nodes increases as you move down the tree.

• Height: The height of a tree is the length of the longest path from the root to any leaf node. It represents the overall height of the tree.

• Subtree: A subtree is a smaller tree within the main tree, consisting of a node and all its descendants (children, grandchildren, and so on).

Tree data structures are useful for organizing hierarchical data, such as file systems, organization charts

Here's an example of implementing a basic tree data structure in Kotlin:

class TreeNode<T>(val data: T) {
    val children: MutableList<TreeNode<T>> = mutableListOf()

    fun addChild(child: TreeNode<T>) {
        children.add(child)
    }
}

fun main() {
    // Create a tree
    val root = TreeNode("A")

    val nodeB = TreeNode("B")
    val nodeC = TreeNode("C")
    val nodeD = TreeNode("D")

    val nodeE = TreeNode("E")
    val nodeF = TreeNode("F")

    root.addChild(nodeB)
    root.addChild(nodeC)
    root.addChild(nodeD)

    nodeB.addChild(nodeE)
    nodeB.addChild(nodeF)

    // Traverse the tree
    traverseTree(root)
}

fun traverseTree(node: TreeNode<String>) {
    println(node.data)

    for (child in node.children) {
        traverseTree(child)
    }
}

Output:

A
B
E
F
C
D

In this example, we define a TreeNode class that represents a node in the tree. Each node contains some data and a list of child nodes.

We create a tree by creating instances of TreeNode and connecting them using the addChild function. The root node is "A", and we add nodes "B", "C", and "D" as its children. Node "B" has children "E" and "F".

To traverse the tree, we define a traverseTree function that takes a TreeNode as a parameter. It prints the data of the current node and then recursively calls itself on each child of the node, traversing the tree in a depth-first manner.

In the main function, we create the tree and initiate the traversal by calling traverseTree with the root node.

The Tree data structure in the Jetpack compose-

Jetpack Compose uses a tree data structure internally to represent the composition of its UI. This allows Compose to efficiently manage the layout and rendering of its UI, as well as to support features such as hot reload and state management.

Here is an example of how Jetpack Compose uses a tree data structure to represent a simple UI:

@Composable
fun RootUI() {
    Column {
        Button(onClick = { /*TODO*/ }) {
            Text(text = "Button 1")
        }

        Button(onClick = { /*TODO*/ }) {
            Text(text = "Button 2")
        }
    }
}

When Compose renders this UI, it will first create a visual tree based on the tree data structure. This visual tree will then be used to render the UI on the screen.

RootUINode
  |
  ColumnNode
    |
    ButtonNode("Button 1")
    |
    ButtonNode("Button 2")

Jetpack Compose's use of a tree data structure makes it a very efficient UI framework. This is because Compose can easily update the visual tree when the state of its UI changes. This is what allows Compose to support features such as hot reloading, which allows you to see changes to your UI without having to rebuild your app.

Here is an example of how Compose uses a tree data structure to support hot reload:

@Composable
fun MyApp() {
  // Create a root node.
  val root = ComposeNode()

  // Add a Text node to the root node.
  root.add(Text("Hello, world!"))

  // Set a state variable.
  val text = mutableStateOf("Hello, world!")

  // Update the Text node when the state variable changes.
  LaunchedEffect(key1 = text) {
    while (true) {
      // Update the Text node with the current value of the state variable.
      root.update(0, Text(text.value))

      // Wait for a change to the state variable.
      text.awaitChange()
    }
  }

  // Return the root node.
  return root
}

When the state variable text changes, Compose will update the Text node in the visual tree. This will cause the UI to be updated without having to rebuild the app.

Jetpack Compose's use of a tree data structure is a powerful feature that makes it a very efficient and flexible UI framework.

8. Graph

Imagine you have a group of friends and you want to represent their relationships using a graph. Each person is a node, and the connections between them are represented by edges.

In a graph, you have nodes (also called vertices) and edges. Nodes represent individual entities, like people, while edges represent the relationships or connections between them.

For example, let's say we have three friends named Alice, Bob, and Carol. We can represent them as nodes in the graph. If Alice is friends with Bob and Carol, and Bob is friends with Carol, we can connect these nodes with edges to represent their relationships.

Here's a simple visual representation:

        Alice
        /   \
      Bob   Carol

In this graph, we have three nodes (Alice, Bob, and Carol) connected by two edges. Alice is connected to both Bob and Carol, while Bob is connected to Carol.

In a graph:

• Nodes (vertices): These are entities or objects represented as points in the graph. Each node can contain additional data or attributes.

• Edges: These are the connections between nodes. Edges can be directed (one-way) or undirected (two-way). They represent the relationships or connections between nodes.

• Weight: Edges can also have weights or costs associated with them. These weights can represent various properties, such as distance, cost, or any other relevant metric.

Graphs can be classified into two main types based on the presence or absence of directed edges:

1. Directed Graph (Digraph): In a directed graph, each edge has a specific direction. The edges indicate a one-way relationship between nodes.

2. Undirected Graph: In an undirected graph, edges have no direction. The relationships between nodes are bidirectional.

Graphs can have various structures, including:

• Cyclic: A graph with at least one cycle (a path that starts and ends at the same node).

• Acyclic: A graph that does not contain any cycles.

• Connected: A graph in which there is a path between any two nodes.

• Disconnected: A graph in which there are one or more isolated components, with no paths connecting them.

Graphs can also have more complex structures. For example, a social network can have hundreds or thousands of nodes representing users, with edges representing friendships between them.

Use of Graph In Dagger/Hilt

Both Dagger and Hilt use a graph data structure to represent the dependencies between classes in your app. This graph is used to determine which classes need to be created and how they should be injected with dependencies.

Dagger uses a compile-time graph, which means that the graph is generated at compile-time. This makes Dagger faster than Hilt, but it also makes it more difficult to change the dependencies in your app.

Hilt uses a runtime graph, which means that the graph is generated at runtime. This makes Hilt slower than Dagger, but it also makes it easier to change the dependencies in your app.

Here is an example of a graph that Hilt might generate for an Android app:

Code snippet

class MainActivity {
    @Inject
    lateinit var viewModel: ViewModel

    fun onCreate() {
        // Hilt will inject the viewModel dependency into this class.
    }
}

class ViewModel {
    @Inject
    lateinit var userRepo: UserRepo

    @Inject
    lateinit var newsRepo: NewsRepo

    fun doSomething() {
        // Hilt will inject the repository dependency into this class.
    }
}

class UserRepo {

}

class NewsRepo {

}

In this example, the MainActivity class depends on the ViewModel class, and the ViewModel class depends on the Repository class. Hilt will generate a graph that represents these dependencies.

When Hilt needs to create an instance of MainActivity, it will traverse the graph and find all of the dependencies that MainActivity needs. Hilt will then create instances of those dependencies and inject them into MainActivity.

Hilt uses this process to generate instances of all of the classes in your app and to inject them with their dependencies. This allows you to write code that is independent of specific implementations of dependencies.

Example of A Dagger/Hilt Graph -

Conclusion

In conclusion, understanding data structures is crucial for successful Android app development. In this blog, we have explored various fundamental data structures such as arrays, lists, hashmaps, sets, queues, stacks, trees, and graphs. These structures serve as the building blocks for organizing and manipulating data efficiently in your app.

Sure, here is a good conclusion for a blog where you have explained about data structures like arrays, lists, hashmaps, sets, queues, stacks, trees, and graphs for Android app development:

In conclusion, data structures are an essential part of Android app development. They provide a way to store and organize data in a way that is efficient and easy to access. There are many different data structures available, and the best one to use will depend on the specific needs of your app.

Here is a quick summary of the data structures that we have discussed:

• Arrays: Arrays are a simple data structure that stores data in a contiguous block of memory. They are efficient for storing data that is accessed in sequential order.

• Lists: Lists are a more flexible data structure than arrays. They can store data in any order, and they can be easily modified.

• HashMaps: HashMaps are a data structure that stores data in a key-value pair. They are efficient for storing data that is accessed by its key.

• Sets: Sets are a data structure that stores data in a unique collection. They are efficient for storing data that does not need to be accessed in any particular order.

• Queues: Queues are a data structure that stores data in a first-in, first-out (FIFO) order. They are efficient for storing data that needs to be processed in a specific order.

• Stacks: Stacks are a data structure that stores data in a last-in, first-out (LIFO) order. They are efficient for storing data that needs to be processed in reverse order.

• Trees: Trees are a data structure that stores data in a hierarchical order. They are efficient for storing data that needs to be accessed by its relationship to other data.

• Graphs: Graphs are a data structure that stores data in a network of nodes and edges. They are efficient for storing data that needs to be processed in a complex way.

Having a solid understanding of these data structures enables you to design and implement efficient algorithms, optimize memory usage, and enhance the overall performance of your Android app.

It allows you to choose the most suitable data structure based on the requirements of your application, ensuring better user experiences and smoother functionality.

Remember, selecting the appropriate data structure requires careful consideration of factors such as data access patterns, search requirements, insertion and deletion operations, and memory usage.

Additionally, continuously improving your knowledge of data structures and algorithms will empower you to tackle more complex problems and make your Android app development journey even more successful.

So, take the time to master these foundational data structures, experiment with them, and explore their capabilities within the context of Android app development. By doing so, you'll be equipped with the tools to create efficient, scalable, and robust applications that deliver exceptional user experiences.

I hope this blog has helped you to understand the basics of data structures and how they can be used in Android app development. If you have any questions, please feel free to leave a comment below. Happy coding!

It is a crucial step in identifying candidates who can handle complex programming challenges and contribute effectively to the development team.

Data structures are a fundamental concept in computer science that allow us to store and organize data efficiently and effectively.

In the world of Android development, understanding the different types of data structures and how to use them can make a significant difference in the performance and functionality of your application.

In this blog, we will explore some of the most commonly used data structures by Android developers and how they can be implemented in your own projects.

Whether you are a beginner or an experienced developer, this guide will provide you with a solid foundation in the world of data structures for Android development.

Though there are numerous concepts to grasp, we will concentrate solely on those most commonly utilized from an Android perspective.

In this blog, we will cover these data structures.

Array List HashMap Sets Queue Stack Tree Graph

Before delving into the data structures, let's discuss where they are stored: the RAM.

What is RAM?

Certainly! RAM, or Random Access Memory, is a vital part of a computer's hardware. It is responsible for temporarily storing data and instructions actively used by the computer's processor.

From a data structure perspective, RAM can be thought of as a large collection of storage cells, each capable of storing a certain amount of information. These cells are organized into a two-dimensional grid of bits. A bit is the smallest unit of data in a computer, representing a binary value of either 0 or 1.

The size of RAM is typically measured in terms of bytes. A byte consists of 8 bits. So, when you see specifications like 4 GB (gigabytes) of RAM, it means there are approximately 4 billion bytes of storage available.

Now, let's understand how data structures utilize RAM. When you create variables, arrays, or other data structures in a programming language, they occupy a certain amount of memory in RAM based on their data type and size.

For example, let's consider an integer variable in a programming language. In most programming languages, an integer is typically represented using 4 bytes (32 bits) of memory. This means that when you declare an integer variable, 4 bytes of RAM will be allocated to store its value.

Similarly, let's say you have an array of 100 integers. Since each integer occupies 4 bytes, the array would require 100 * 4 = 400 bytes of RAM.

Different data structures have different memory requirements based on their design and the type of data they store. For instance:

1. Arrays: As mentioned earlier, arrays store elements of the same data type in contiguous memory locations. The memory required by an array is determined by multiplying the size of each element by the number of elements in the array.

2. Linked Lists: In a linked list, memory is dynamically allocated for each node. Each node contains both the data and a pointer/reference to the next node in the list. The memory required for a linked list depends on the number of nodes and the size of each node.

3. Trees: Trees consist of nodes connected in a hierarchical structure. Each node holds data and pointers to its child nodes. The memory needed for a tree depends on the number of nodes and the size of each node.

It's important to note that the memory usage of data structures is not limited to just the data they store. It also includes any additional metadata or overhead required by the programming language or the underlying implementation of the data structure.

Efficient memory management is a crucial consideration when designing and working with data structures. It helps ensure optimal utilization of RAM and avoids unnecessary memory wastage.

1. Array

An array is a data structure in Kotlin that stores a fixed-size sequential collection of elements of the same type. In other words, an array is a container that holds a fixed number of elements of a specific type.

Declaring and initializing an array in Kotlin is easy. Here is an example of an array of integers:

val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)

In this example, we declare an array called numbers and initialize it with the values 1, 2, 3, 4, and 5. The IntArray type specifies that the array holds integers.

We can access individual elements of the array using their index, which starts at 0. For example, to access the first element of the numbers array, we can use the following code:

val firstNumber = numbers[0]

This assigns the value of the first element of the numbers array to the variable firstNumber. Similarly, we can access any other element of the array by specifying its index.

We can also modify individual elements of the array by assigning a new value to their index. For example, to change the value of the third element of the numbers array to 10, we can use the following code:

numbers[2] = 10

Arrays in Kotlin also provide several useful methods for working with their elements, such as size, which returns the number of elements in the array, and forEach, which applies a function to each element of the array.

arraySize = numbers.size // returns 5
numbers.forEach { println(it) } // prints each element of the array

Keep in mind that arrays in Kotlin have a fixed size, which means that once you declare an array, you cannot add or remove elements from it. If you need a collection that can grow or shrink dynamically, you may want to consider using a List instead.

How an Array is stored in memory?

When an array is created in a programming language, the memory for the array is allocated in the computer's RAM (Random Access Memory) in a contiguous block of memory. The amount of memory required to store an array depends on the data type and the number of elements in the array.

For example, consider this array:

val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)

This creates an array of integers called numbers with a size of 5. The array can hold 5 integers, and each integer requires 4 bytes of memory on a typical 32-bit system. Therefore, the total memory required to store the entire array is 5 * 4 = 20 bytes.

When the array is created, the memory for the array is allocated in the computer's RAM as a contiguous block of memory.

The starting address of this block of memory is stored in reference variable numbers.

Each element of the array is stored in a consecutive memory location, and the index of an element corresponds to its offset from the starting address of the array.

For example, let's say that the starting address of the array arr is 1000. Then, the memory locations for each element of the array would be as follows:

numbers[0]: 1000
numbers[1]: 1004
numbers[2]: 1008
numbers[3]: 1012
numbers[4]: 1016

As you can see, each element of the array is stored in a consecutive memory location, and the offset between two consecutive elements is equal to the size of the data type, which is 4 bytes in this case.

When an element of the array is accessed, the computer uses the starting address of the array and the index of the element to calculate the memory location of the element in the RAM. This process is very efficient and allows for fast and easy access to the elements of the array in O(1).

2. List

list is a data structure that represents an ordered collection of elements, where each element has an associated index. It allows for efficient insertion, deletion, and retrieval of elements based on their positions in the list.

In Kotlin, the List the interface provides a read-only list, while the MutableList interface extends List to support the modification of elements.

Arrays and lists are similar in that they both store ordered collections of elements. However, there are some key differences:

• Size: Arrays have a fixed size defined at the time of creation, whereas lists can dynamically grow or shrink as elements are added or removed.

• Flexibility: Lists offer more flexibility in terms of resizing and modifying elements, while arrays are more static in nature.

• Memory Management: Arrays generally require less memory overhead, as they only store the elements themselves, whereas lists may require additional memory for managing their internal structures.

How List works inside memory

When a dynamic list (also known as a dynamic array or resizable array) is stored in memory, it starts with an initial allocated capacity. As new items are added to the list and the capacity is exceeded, the list is resized by allocating a larger block of memory and copying the existing elements to the new block. Let's explore the process in more detail:

1. Memory Allocation: When the dynamic list is created, an initial block of memory is allocated to hold a certain number of elements. The size of this block depends on the implementation and may vary. The list also keeps track of the current number of elements and the allocated capacity.

2. Adding a New Item: When a new item is added to the dynamic list, the implementation checks if there is enough space in the allocated block to accommodate the new element.

   a. If there is available space: If the current number of elements does not exceed the allocated capacity, the new item is simply stored in the next available memory slot.

   b. If the capacity is exceeded: If the current number of elements exceeds the allocated capacity, the list needs to be resized. The implementation follows these steps:

   1. Allocate a new, larger block of memory: A new block of memory is allocated with an increased capacity. The new capacity can be determined based on various factors, such as doubling the current capacity or adding a fixed number of additional slots.

   2. Copy existing elements to the new block: The existing elements from the old block of memory are copied to the new block, ensuring their order is maintained.

   3. Update references and release old memory: The list updates the references to the new block and releases the old memory to free up resources.

   4. Add the new item: Finally, the new item is added to the next available memory slot in the resized list.

This resizing process ensures that the dynamic list can accommodate additional elements beyond its initial capacity.

It's important to note that the resizing operation can be costly in terms of time and memory. The frequency of resizing can impact the performance of the dynamic list. To mitigate excessive resizing, some implementations may employ strategies such as resizing by a larger factor or using incremental resizing.

fun main() {
    // Creating a List
    val myList = listOf("apple", "banana", "orange", "kiwi")
    println("Original List: $myList")

    // Accessing Elements
    val firstElement = myList[0]
    println("First Element: $firstElement")

    // Modifying Elements (Creating a Mutable List)
    val mutableList = myList.toMutableList()
    mutableList[1] = "grape"
    println("Modified List: $mutableList")

    // Adding Elements
    mutableList.add("watermelon") // Adding an element to the end
    mutableList.add(2, "mango") // Inserting an element at index 2
    println("List after Adding Elements: $mutableList")

    // Removing Elements
    mutableList.remove("banana") // Removing an element by value
    mutableList.removeAt(0) // Removing an element at index 0
    println("List after Removing Elements: $mutableList")

    // Checking List Size and Empty
    val listSize = mutableList.size
    val isEmpty = mutableList.isEmpty()
    println("List Size: $listSize")
    println("Is List Empty? $isEmpty")

    // Iterating and Transforming Elements
    mutableList.forEach { element ->
        println("Processing element: $element")
    }

    val upperCaseList = mutableList.map { element ->
        element.toUpperCase()
    }
    println("List after Transforming to Upper Case: $upperCaseList")

    // Filtering Elements
    val filteredList = mutableList.filter { element ->
        element.length > 4
    }
    println("Filtered List: $filteredList")

    // Sorting Elements
    val sortedList = mutableList.sorted()
    println("Sorted List: $sortedList")
}

3. HashMap

A HashMap is a data structure that provides fast access to values based on a unique key. It internally uses an array and a hashing function to map keys to specific indices in the array, allowing for efficient retrieval and storage of key-value pairs.Let's explore HashMaps with an example in Kotlin:

Consider a scenario where you want to store a collection of students and their corresponding grades using a HashMap.

fun main() {
    // Create a HashMap to store student grades
    val gradesMap = HashMap<String, Int>()

    // Add student grades to the HashMap
    gradesMap["John"] = 85
    gradesMap["Emily"] = 92
    gradesMap["Michael"] = 78

    // Accessing values from the HashMap
    val johnGrade = gradesMap["John"]
    println("John's Grade: $johnGrade")

    // Updating a value in the HashMap
    gradesMap["Emily"] = 95
    val updatedEmilyGrade = gradesMap["Emily"]
    println("Updated Emily's Grade: $updatedEmilyGrade")

    // Removing a value from the HashMap
    gradesMap.remove("Michael")
    val michaelGrade = gradesMap["Michael"]
    println("Michael's Grade: $michaelGrade")

    // Checking if a key exists in the HashMap
    val containsJohn = gradesMap.containsKey("John")
    println("Does the HashMap contain John? $containsJohn")

    // Iterating over the HashMap
    for ((student, grade) in gradesMap) {
        println("$student: $grade")
    }
}

Regarding how HashMap generates indices, it uses a hashing function to convert the keys into integer values called hash codes.

The hash codes are then mapped to specific indices in the underlying array using a process called hashing. This allows for efficient storage and retrieval of key-value pairs. The exact hashing algorithm used depends on the implementation of HashMap.

internally, a HashMap in Kotlin uses an array of linked lists (buckets) to store key-value pairs. The hashing function in Kotlin is responsible for converting the key into an integer value called the hash code.

This hash code is used to determine the index (bucket) in the array where the key-value pair will be stored. Let's dive into the internal workings of a HashMap:

1. Hashing Function:

   • The hashing function in Kotlin is implemented by the hashCode() method, which is defined in the Any class. All objects inherit this method, and it can be overridden for custom types.

   • The hashCode() method calculates a unique integer value (hash code) for each object based on its internal state. Objects that are considered equal should have the same hash code.

   • Kotlin provides default implementations of hashCode() for built-in types, such as String, Int, and Boolean.

2. Hashing and Index Calculation:

   • Once the hash code is obtained from the key, the HashMap applies a process called hashing to map the hash code to an index in the underlying array.

   • The index calculation is performed by applying a transformation to the hash code using bitwise operations and masking to ensure the index falls within the valid range of the array.

   • The specific algorithm for index calculation can vary based on the HashMap implementation.

3. Handling Collisions:

   • Since multiple keys can potentially have the same hash code or map to the same index, HashMap uses separate chaining to handle collisions.

   • Each index in the array can hold a linked list of key-value pairs. If multiple keys have the same index, they are stored in the corresponding linked list.

   • When retrieving a value, the HashMap uses the hash code and equality comparison to find the appropriate key-value pair in the linked list.

4. Resizing and Load Factor:

   • HashMap also implements resizing to maintain a balance between the number of key-value pairs and the capacity of the underlying array.

   • The load factor is a threshold that determines when to resize the HashMap. When the number of elements exceeds the load factor multiplied by the current capacity, the HashMap is resized by creating a new array with a larger capacity and rehashing all the key-value pairs into the new array.

   • Resizing allows for efficient storage and retrieval even as the number of key-value pairs increases.

It's important to note that the exact implementation details of hashing functions and collision resolution may vary depending on the HashMap implementation in different versions of Kotlin or different programming languages.

By leveraging the hashing function and handling collisions with linked lists, HashMap provides efficient storage and retrieval of key-value pairs based on their unique keys.

We will continue with part 2, discussing the rest of the Data structures. Click here to read . Happy Coding !!

But there's good news! There's a new way to sign in to websites and apps that is both easier and more secure than passwords. It's called Android passkeys.

1. What is Android Passkey?

Android Passkeys are a more secure and convenient alternative to passwords, allowing users to sign in to apps and websites using biometric sensors, PINs, or patterns instead of traditional passwords.

Passkeys use cryptographic keys instead of strings of characters. This makes them much more secure than traditional passwords, which can be easily guessed or stolen.

2. How does Android Passkey work?

Passkeys are based on public-key cryptography, which allows for secure authentication without the need to store any sensitive data on a server.

When you create a passkey, your device generates a unique public and private key pair. The public key is stored on the server, while the private key is kept secret on your device.

When you log in, the server sends a challenge to your device. Your device uses the private key to generate a response, which is then sent back to the server. If the response is correct, you are logged in.

Passkeys have several advantages over traditional passwords. First, they are much more secure. Because the private key is never stored on a server, it cannot be stolen or hacked.

Second, passkeys are much easier to use. You do not have to remember a long, complex password. Instead, you can simply use your fingerprint or facial recognition to log in.

3. What are the benefits of using Android Passkey?

• They are more secure than passwords. Passkeys use public-key cryptography, which makes them much more difficult to hack or steal than traditional passwords.

• They are easier to use. You do not have to remember a long, complex passkey. Instead, you can simply use your fingerprint or facial recognition to log in.

• They are more portable. Passkeys are stored on your device, so you can use them on any computer or device that supports them.

• They are more future-proof. Passwords are becoming increasingly obsolete. As more and more websites and apps adopt passkeys, it will become increasingly important to use them.

4. How to Create an Android Passkey

To use CredentialManager for generating a passkey, you can follow these steps:

1. Open your app and sign in to establish a session.

2. Next, your app prompts the user to create a passkey.

3. The system displays this UI near the bottom of the screen.

1. A passkey is created after receiving the user's consent using the device's screen lock/biometrics. The credential provider creates a new asymmetric key pair and securely stores the private key on the device.

2. After the suspendable call is resolved, a public key credential containing a new public key, a credential ID, and other attestation data is returned to your app.

The example code shows how to create a passkey using CredentialManager

// Use your app or activity context to instantiate a client instance of
// CredentialManager.
val credentialManager = CredentialManager.create(context)

fun createPasskey(requestJson: String, preferImmediatelyAvailableCredentials: Boolean) {
    val createPublicKeyCredentialRequest = CreatePublicKeyCredentialRequest(
        // Contains the request in JSON format. Uses the standard WebAuthn
        // web JSON spec.
        requestJson = requestJson,
        // Defines whether you prefer to use only immediately available credentials,
        // not hybrid credentials, to fulfill this request. This value is false
        // by default.
        preferImmediatelyAvailableCredentials = preferImmediatelyAvailableCredentials,
    )
    // Execute CreateCredentialRequest asynchronously to register credentials
    // for a user account. Handle success and failure cases with the result and
    // exceptions, respectively.
    coroutineScope.launch {
        try {
            val result = credentialManager.createCredential(
                request = createPublicKeyCredentialRequest,
                activity = activity,
            )
            handlePasskeyRegistrationResult(result)
        } catch (e : CreateCredentialException){
            //handle error
        }
    }
}

Source: Google LLC. 2022

5. What are some of the limitations of Android Passkey?

• Not all websites and apps support passkeys yet. This is a rapidly developing technology, and more and more websites and apps are supporting passkeys all the time. However, there are still some that don't, so you may not be able to use passkeys everywhere.

• Passkeys are not as secure as hardware security keys. Hardware security keys are physical devices that you plug into your computer or phone when you log in to websites and apps. They offer an extra layer of security because they are not connected to the internet, so they cannot be hacked remotely. Passkeys are still very secure, but they are not as secure as hardware security keys.

• Passkeys can be a bit of a hassle to set up. You have to create a passkey for each website or app that you want to use. This can be a bit time-consuming, especially if you have a lot of accounts.

6. The future of Android Passkey

Google has been working on this technology for years, and it is finally starting to gain traction. More and more websites and apps are supporting passkeys, and it is only a matter of time before they become the standard way to log in to online accounts.

There are several reasons why passkeys are so promising. First, they are much more secure than traditional passwords. Passkeys use public-key cryptography, which makes them very difficult to hack or steal.

Second, passkeys are much easier to use than traditional passwords. You do not have to remember a long, complex password. Instead, you can simply use your fingerprint or facial recognition to log in.

As more and more people become aware of the benefits of passkeys, they are likely to become the standard way to log in to online accounts. This will make our online lives much more secure and convenient.

In conclusion, Android Passkeys offer a more secure and convenient alternative to traditional passwords for signing in to websites and apps. using public-key cryptography and biometric authentication.

Though not universally supported or as secure as hardware security keys, their adoption is growing, leading to a safer and user-friendly online experience.

If you enjoyed this blog, please give it a like and share it with others who may find it helpful.

Memory management in operating systems is the process of managing the RAM (Random Access Memory) and ensuring that each process and application has access to the required amount of memory.

It involves allocating memory when a process or application needs it, freeing up memory when it is no longer required, and preventing memory leaks and other issues that can arise from inefficient memory usage.

Every Operating system has its own way of managing memory so does Android. The foundation of the Android platform is the Linux kernel. the Android Runtime (ART) relies on the Linux kernel for underlying functionalities such as threading and low-level memory management.

Efficient memory management helps to ensure that each process and application has access to the required amount of memory, preventing memory leaks and other issues that can arise from inefficient memory usage.

It also helps to conserve battery life by reducing unnecessary memory usage. Overall, proper memory management is essential for a smooth and efficient user experience on Android devices.

In this blog, we will cover how the system manages memory internally.

II. Types Of Memory

Android has 3 Types of Memory. Ram, zRam & Storage

• RAM: it's the fastest type of memory, but is usually limited in size. High-end devices typically have the largest amounts of RAM. This is the prime memory that handles all ongoing operations.

• zRAM: It's a partition of RAM used for swap space. Everything is compressed when placed into zRAM, and then decompressed when copied out of zRAM. This portion of RAM grows or shrinks in size as pages are moved into or taken out of zRAM. Device manufacturers can set the maximum size.

• Storage: It contains all of the persistent data such as the file system and the included object code for all apps, libraries, and the platform. Storage has much more capacity than the other two types of memory. On Android, storage isn’t used for swap space like it is on other Linux implementations since frequent writing can cause wear on this memory, and shorten the life of the storage medium.

III. Memory Pages

RAM is broken up into pages. Typically each page is 4KB of memory.

Pages are considered either free or used. Free pages are unused RAM. Used pages are RAM that the system is actively using, and are grouped into the following categories:

1. Cached: Memory backed by a file on storage (for example, code or memory-mapped files). There are two types of cached memory:/

   • Private: Owned by one process and not shared

     • Clean: Unmodified copy of a file on storage, can be deleted by kswapd to increase free memory

     • Dirty: Modified copy of the file on storage; can be moved to, or compressed in, zRAM by kswapd to increase free memory

   • Shared: Used by multiple processes

     • Clean: Unmodified copy of the file on storage, which can be deleted by kswapd to increase free memory

     • Dirty: Modified copy of the file on storage; allows changes to be written back to the file in storage to increase free memory by kswapd, or explicitly using msync() or munmap

1. Anonymous: Memory not backed by a file on storage (for example, allocated by mmap() with the MAP_ANONYMOUS flag set)

   it is a Dirty page that can be moved/compressed in zRAM by kswapd to increase free memory

IV. Low Memory Killer

When free memory falls below the low threshold, kswapd starts to reclaim memory. Once the free memory reaches the high threshold, kswapd stops reclaiming memory.

Clean Page : kswapd can reclaim clean pages by deleting them because they're backed by storage and have not been modified.

If a process tries to address a clean page that has been deleted, the system copies the page from storage to RAM. This operation is known as demand paging.

Dirty Pages: kswapd can move cached private dirty pages and anonymous dirty pages to zRAM, where they are compressed. Doing so frees up available memory in RAM (free pages).

If a process tries to touch a dirty page in zRAM, the page is uncompressed and moved back into RAM. If the process associated with a compressed page is killed, then the page is deleted from zRAM.

If the amount of free memory falls below a certain threshold, the system starts killing processes. To decide which process to kill, LMK uses an "out of memory" score called oom_adj_score to prioritize the running processes.

Processes with a high score are killed first. Background apps are first to be killed, and system processes are last to be killed. The following table lists the LMK scoring categories from high-to-low. Items in the highest-scoring category, in row one, will be killed first:

V. Garbage Collection

Garbage collection in Android identifies and releases memory that is no longer being used by the app, helping to prevent memory leaks and ensure efficient memory usage.

It involves marking live objects in the heap, traversing the object graph to mark all reachable objects, sweeping away unreachable objects to free up memory, and compacting remaining live objects to reduce memory fragmentation.

In Android Garbage collection runs when System want to release the app completely from the heap or while the user using the app if any object reference is not required any more.

VI. Switch Apps

When users switch between apps, Android keeps apps that are not foreground—that is, not visible to the user or running a foreground service like music playback— in a cache.

For example, when a user first launches an app, a process is created for it; but when the user leaves the app, that process does not quit. The system keeps the process cached. If the user later returns to the app, the system reuses the process, thereby making the app switching faster.

If your app has a cached process and it retains resources that it currently does not need, then your app—even while the user is not using it— affects the system's overall performance.

As the system runs low on resources like memory, it kills processes in the cache. The system also accounts for processes that hold onto the most memory and can terminate them to free up RAM.

Note: The less memory your app consumes while in the cache, the better its chances are not to be killed and to be able to quickly resume. However, depending on instantaneous system requirements, it's possible for cached processes to be terminated at any time no matter their resource utilization.

In conclusion, understanding Android memory management is crucial for optimizing app performance and ensuring a smooth user experience.

By learning about the types of memory, memory pages, low memory killer, garbage collection, and app switching, developers can create efficient apps that make the best use of available resources.

Proper memory management helps conserve battery life and reduces the likelihood of app termination due to low memory conditions.

That's all for now. If you enjoyed the article, please give it a thumbs up. Thank you for reading! :)

In this article, we'll explore the benefits of using delegation functions in your Kotlin projects and provide practical examples to demonstrate their usage.

In Kotlin, a delegation function allows one object to delegate certain operations to another object.

For example, let's say you have two classes: ClassA and ClassB. ClassB wants to use some of the functionality of ClassA without inheriting from it. This is where delegation comes in.

Instead of ClassB inheriting from ClassA, it can delegate the functionality it needs to an instance of ClassA. This is done using the by keyword.

Here's an example:

class ClassA {
    fun someFunction() {
        println("Hello from ClassA")
    }
}

class ClassB(a: ClassA) {
    private val classA = a

    fun callSomeFunction() {
        classA.someFunction()
    }
}

In this example, ClassB is delegating the someFunction() operation to an instance of ClassA.

We create an instance of ClassA and pass it to ClassB's constructor. ClassB stores this instance in a private variable called classA.

Then, ClassB has a function called callSomeFunction() which calls someFunction() on the classA instance.

We can simplify this code by using the by keyword to delegate the functionality:

class ClassB(a: ClassA) by a {
    fun callSomeFunction() {
        someFunction()
    }
}

In this version, we're saying that ClassB will delegate all of its functions and properties to an instance of ClassA. We don't need to store the instance in a variable or call someFunction() using the classA variable. Instead, we can call it directly with someFunction().

Another Example: Delegating interface implementation

if we have an interface called MyInterface, we can create a class that implements this interface and then delegate its implementation to another object. This can be done using the by keyword and passing in the object that we want to delegate to. Here's an example:

interface MyInterface {
  fun doSomething()
}

class MyInterfaceImpl : MyInterface {
  override fun doSomething() {
    println("Doing something...")
  }
}

class MyClass : MyInterface by MyInterfaceImpl()

fun main() {
  val obj = MyClass()
  obj.doSomething() // output: "Doing something..."
}

In this example, we have an interface called MyInterface and a class called MyInterfaceImpl that implements it. We then create a class called MyClass and delegate its implementation of MyInterface to MyInterfaceImpl using the by keyword.

When we create an instance of MyClass and call doSomething(), it delegates the call to the MyInterfaceImpl object and prints "Doing something..." to the console.

Use Cases :

• Implementing interfaces: Kotlin delegation allows you to implement interfaces without implementing all of their methods. You can create a separate class that implements the interface and then delegate the implementation of the interface methods to that class.

• Property delegation: Kotlin delegation allows you to delegate property access to a separate object, which can handle getting and setting the property values. This can be useful for implementing lazy properties, observable properties, and properties that need to be initialized dynamically.

• Resource management: Kotlin delegation can be used for resource management, such as closing database connections or file handles when they are no longer needed. You can create a separate class that handles the resource management and delegate to it the class that uses the resources.

• Decorator pattern: Kotlin delegation can be used to implement the decorator pattern, where you have a base class and one or more decorator classes that add functionality to the base class. You can use delegation to delegate the base class functionality to the decorator classes.

• Dependency injection: Kotlin delegation can be used for dependency injection, where you create a separate class that provides the dependencies and then delegate to it in the class that needs the dependencies. This can help to reduce coupling between classes and make your code more modular.

These are just a few examples of how Kotlin delegation can be used. It's a powerful feature that can help to make your code more modular and reusable.

That's all for now. If you enjoyed this article, please give it a thumbs-up and subscribe to my newsletter for more.

Unlike the traditional Android View system, Jetpack Compose is built on Kotlin, which allows for easier integration with the rest of the Android ecosystem. With Jetpack Compose, developers can create beautiful, responsive, and performant UIs in less time and with less code.

Declarative UI:

Jetpack Compose provides a declarative way of building UI components, which makes it easier to create complex layouts and animations with less code.

XML :

<LinearLayout
   android:id="@+id/my_linearlayout"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:orientation="vertical">

   <TextView
       android:id="@+id/textview1"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="TextView 1" />

   <TextView
       android:id="@+id/textview2"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="TextView 2" />

</LinearLayout>

Compose :

Column {
   Text("TextView 1")
   Text("TextView 2")
}

Example 2 :

XML:

<androidx.recyclerview.widget.RecyclerView
   android:id="@+id/my_recyclerview"
   android:layout_width="match_parent"
   android:layout_height="match_parent" />

val recyclerView = findViewById<RecyclerView>(R.id.my_recyclerview)
val adapter = MyAdapter(data)
recyclerView.adapter = adapter

Then further another 60-80 lines of code for vidwHolder, Adapter, item blah blah.

Compose:

val data = listOf("Item 1", "Item 2", "Item 3")

LazyColumn {
   items(data) { item ->
      Text(text = item)
   }
}

Kotlin Integration

Jetpack Compose is built on Kotlin, which allows for easier integration with the rest of the Android ecosystem, and leveraging all the power of Kotlin while creating composable Functions.

It uses various Kotlin features such as extension functions, operator overloading, and lambda expressions to create composable functions that can be reused and combined to build complex UIs.

For example, Compose provides composable functions like Text(), Button(), and Column() that can be used to create UI components.

These functions can be combined to create more complex UIs and layouts. Additionally, Compose uses Kotlin's type inference and null safety features to reduce boilerplate code and catch errors at compile time.

@Composable
fun MyScreenContent(names: List<String> = listOf("Android", "there")) {
    Column(modifier = Modifier.padding(16.dp)) {
        Text(text = "Hello, ${names.first()}!")
        LazyColumn {
            items(names) { name ->
                Greeting(name = name)
                Divider(color = Color.Black)
            }
        }
    }
}

@Composable
fun Greeting(name: String) {
    Text(text = "Hello $name!", modifier = Modifier.padding(24.dp))
}

Improved Performance:

Jetpack Compose is designed to be more performant than traditional XML-based UI development, with faster rendering times and improved memory usage.

it improves performance by reducing the number of UI updates, which results in faster rendering times and improved memory usage.

This is achieved through the use of a unidirectional data flow architecture, where state changes are propagated from a single source of truth to the UI components that depend on them.

As a result, only the affected UI components are re-rendered, instead of the entire UI hierarchy. This approach can lead to significant performance improvements, especially for complex UIs with many dynamic elements.

Simplified UI Development:

Jetpack Compose simplifies and accelerates UI development, making it easier to create beautiful, responsive, and performant UIs in less time and with less code.

No need to create multiple XML files and go back and forth. One single file will likely contain everything that is responsible for the specific screen.

With Compose, bringing movement and life to your apps through animations is quick and easy to implement: “Animations are so easy to add in Compose that there’s very little reason not to animate things like colour/size/elevation changes” (Monzo), “you can make animations without requiring anything special -- it’s no different than showing a static screen” - Square

With Compose, you build small, stateless components that are not tied to a specific activity or fragment. That makes them easy to reuse and test: “We set a goal for ourselves to deliver a new set of UI components that were stateless, easy to use and maintain, and intuitive to implement/extend/customize. Compose really provided a solid answer for us in this.” - Twitter

In the Next blog, we will see how Compose draws UI internally.

If you found this article helpful, please give it a thumbs up. Thanks for reading.

Here's an example: let's say you're working on an Android app and you're using the type Pair<String, Int> a lot in your code. Instead of writing Pair<String, Int> every time you need to use it, you can create a type alias for it:

typealias StringIntPair = Pair<String, Int>

Now you can use the StringIntPair type alias instead of Pair<String, Int> in your code. Here's an example:

val pair: StringIntPair = "foo" to 42

This is the same as writing:

val pair: Pair<String, Int> = "foo" to 42

Type aliases can also be used with generic types, nullable types, and function types. For example, the following code defines a type alias for a nullable function that takes two integers as arguments and returns a nullable integer

typealias MyFunction = ((Int, Int) -> Int)?

Now you can use the type alias "MyFunction" instead of the function type ((Int, Int) -> Int)?. For example, the following code creates a variable of type "MyFunction" and assigns a lambda expression to it:

val myFunction: MyFunction = { a, b -> a + b }

This is equivalent to creating a variable of the type ((Int, Int) -> Int)? and assign a lambda expression to it:

val myFunction: ((Int, Int) -> Int)? = { a, b -> a + b }

You can have new names for inner nested classes

class A {
    inner class Inner
}
class B {
    inner class Inner
}

typealias AInner = A.Inner
typealias BInner = B.Inner

You can even use resource file names.

typealias Drawable = R.drawable
typealias Layout = R.layout

setContentView(Layout.activity_main)
imageView.setImageDrawable(ContextCompat.getDrawable(this,Drawable.ic_launcher_background))

In general, type aliases can make your code more concise and easier to read. They're especially useful when you're working with complex types or when you want to create your own custom types that are more specific to your app's needs.

This is all about typeAlias in Koltin.

Happy learning.

Why utilize an external library should be the first question that pops into your head. Is it only because we want to write fewer lines of code? perhaps it has additional aspects. Let's learn the fundamentals of loading an image from a URL.

It appears simple. This approach will work for the app's single image. However, as the number of images increases, you will begin to experience these issues.

• The app will feel unresponsive and Laggy - Because a large amount of memory will be allocated to these images in the heap, and the GC will attempt to release the memory whenever this image view is off the screen.

• Out Of Memory and App crash - Because our heap has a limited amount of memory if we keep assigning it multiple images, eventually it will run out of memory and the app will crash.

• Slow Loading of Images and Poor UX - Since we will be loading images one at a time, this method will slow down the loading of the images.

  As an example, if there are 20 images on the screen and the user scrolls to image number 20, the first 19 images will load before the 20th one. Additionally, the user wants to view the image of the spot where he is now, so this is an awful user experience.

Now let's see how these libraries fix these problems for us and make our life easier.

1. How does Image Loading Library add Responsiveness to the App?

The Answer is BitmapPool.

In Android, a Bitmap Pool is a cache that keeps reusable Bitmap objects in memory. The purpose of a Bitmap Pool is to reduce the frequency of garbage collection and improve performance by recycling Bitmaps that are no longer being used.

When you load Bitmaps in your Android application, the system allocates memory for each Bitmap object. When the Bitmap is no longer needed, the memory used by the Bitmap is released and can be reused by the system.

However, allocating new memory for Bitmaps can be expensive and cause performance issues if done frequently.

By using a Bitmap Pool, you can reuse Bitmaps that are no longer being used instead of allocating new memory each time. This can improve the performance of your application and reduce the frequency of garbage collection.

Here's an example of how to create and use a Bitmap Pool in Android:

// Create a Bitmap Pool with the desired size
BitmapPool bitmapPool = new LruBitmapPool(maxSizeBytes);

// Load a Bitmap into memory
Bitmap bitmap = BitmapFactory.decodeResource(resources, resourceId);

// Get a Bitmap from the pool, or allocate a new one
Bitmap pooledBitmap = bitmapPool.get(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);

// Set the pixels of the pooled Bitmap to match the original Bitmap
pooledBitmap.setPixels(bitmap.getPixels(), 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());

// Use the Bitmap

// When the Bitmap is no longer needed, return it to the pool
bitmapPool.put(pooledBitmap);

In the above example, a Bitmap Pool is created using the LruBitmapPool implementation with the maximum size in bytes that the pool can hold.

The code then loads a Bitmap and retrieves a Bitmap object from the pool using the get() method. If there is no available Bitmap in the pool, a new Bitmap is allocated.

The pixels of the new Bitmap is set to match the original Bitmap, and the pooled Bitmap is used for the intended purpose. When the Bitmap is no longer needed, it should be returned to the pool using the put() method.

For example, if our bitmap pool is capable of holding 20 bitmaps and the user is scrolling through a list of 40 images when the user will reach the 21st position, the memory of the 1st bitMap will be reused to store the 21st bitmap

final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;

//Decoding bitmap from file
BitmapFactory.decodeFile(filePathTwntyOne, options); 
options.inMutable = true;

//attempt to reuse bitmapOne when loading content
options.inBitmap = bitmapOne;
options.inJustDecodeBounds = false;

Bitmap bitmapTwentyOne = BitmapFactory.decodeFile(filePathTwntyOne, options);
imageView.setImageBitmap(bitmapTwentyOne);

You can read more about BitmapFactory here.

2. How do Image Loading Libraries solve OutOfMemory issues?

The Answer is the downsampling of the image.

Image downsampling is the process of decreasing the resolution of a digital image. Downsampling is done by reducing the number of pixels in the image, which in turn reduces the amount of information stored in the image.

The process of downsampling can be used to reduce the file size of an image or to create a smaller version of the same image.

Downsampling can be achieved by removing every other pixel in a specified direction, or by taking an average of adjacent pixels to create a new, smaller image. Image downsampling can also be referred to as image resampling or image scaling.

After Downloading the Entire image File from the URL The Library Downsample it to the size of imageView.

As an example, the downloaded image resolution may be 1920*1080 but our imageView size is 420*270. So we don't need to decode the whole image in 1920*1080 resolution which will waste resources unless you have explicitly told the library not to downsample it. So it gets downsampled to 420*270 and sent to imageView.

public Bitmap getResizedBitmap(int targetW, int targetH,  String imagePath) {

    // Get the dimensions of the bitmap
    BitmapFactory.Options bmOptions = new BitmapFactory.Options();

    //inJustDecodeBounds = true <-- will not load the bitmap into memory
    bmOptions.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(imagePath, bmOptions);
    int photoW = bmOptions.outWidth;
    int photoH = bmOptions.outHeight;

    // Determine how much to scale down the image
    int scaleFactor = Math.min(photoW/targetW, photoH/targetH);

    // Decode the image file into a Bitmap sized to fill the View
    bmOptions.inJustDecodeBounds = false;
    bmOptions.inSampleSize = scaleFactor;

    Bitmap bitmap = BitmapFactory.decodeFile(imagePath, bmOptions);
    return(bitmap);
}

3. How Image Loading Libraries solve the Slow loading issue?

Here 2 things come into the picture. Prioritizing and deprioritizing the image request and Cache Management.

Prioritizing Request

Multiple image requests may be added to the queue when switching from one page to another. However, we must load the images where the user is at the moment according to the precedence.

As we provide the context to the imageLoading request it exactly knows what is the exact position of the user. And based on that it prioritizes the request. As a result, the current screen images load as soon as possible.

Cache Management

Memory caching and disk caching are two different types of caching mechanisms used in image-loading libraries:

Memory Caching: It is the process of temporarily storing data (in this case, images) in the device's RAM or memory. When the data is accessed again, it can be loaded more quickly since it's stored in memory.

Memory caching is ideal for frequently accessed data, such as images that are repeatedly displayed on the screen.

The drawback of memory caching is that it can consume a lot of RAM, leading to memory overflow and crashes. This is why we use the Bitmap pool as discussed above.

Disk Caching: It is the process of saving data (in this case, images) to the device's local storage. When the data is accessed again, it's loaded from the disk instead of being downloaded from the internet or server, which can be slower.

Disk caching is ideal for infrequently accessed data since it doesn't consume memory as memory caching does. The drawback of disk caching is that it requires more storage space on the device, and the read/write operations can also be slow.

whenever a new request is introduced to the queue it first looks for the image in-memory cache. If it is not found, look in the disc cache. If that fails, go to the source URL to obtain the downsample and set it as the imageView.

Conclusion

As we have seen, image-loading libraries not only allow us to write less code but also directly address several more difficult problems, making the lives of developers much simpler.

Here is an LLD of these libraries.

Some of the popular Image loading libraries are Glide, Picasso, Freso, and COIL.