How to use composable functions in Android Jetpack Compose

Android Jetpack Compose is a modern toolkit for building native UI. It simplifies and accelerates UI development on Android with less code, powerful tools, and intuitive Kotlin APIs ¹. In this blog post, we will explore how to use composable functions, which are the building blocks of Jetpack Compose.

What are composable functions?

Composable functions are functions that can be used to describe your UI programmatically by providing data dependencies, rather than focusing on the process of the UI’s construction ¹. To create a composable function, you just need to add the @Composable annotation to the function name. For example:

@Composable fun Greeting(name: String) { Text(text = "Hello, $name!") }

This function defines a simple UI element that displays a text label with a greeting message. You can call this function from another composable function, such as the setContent block that defines the activity’s layout:

override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContent { Greeting(name = "World") } }

This will render the text “Hello, World!” on the screen. You can also pass different parameters to the composable function to customize its behavior. For example:

setContent { Greeting(name = "Android") }

This will render the text “Hello, Android!” on the screen.

How to preview composable functions in Android Studio?

One of the advantages of using composable functions is that you can preview them in Android Studio without having to build and install the app to an Android device or emulator ¹. To do this, you need to use the @Preview annotation on a composable function that does not take in parameters. For example:

@Preview @Composable fun PreviewGreeting() { Greeting(name = "Compose") }

This function calls the Greeting function with a parameter of “Compose”. You can then see a preview of this function in Android Studio by clicking on the split (design/code) view. You can also refresh the preview at any time by clicking on the refresh button at the top of the preview window.

How to use different types of composable functions?

There are many types of composable functions that you can use to create different UI elements and layouts in Jetpack Compose. Some of the most common ones are:

Text: This function displays a text label on the screen. You can customize its appearance by passing parameters such as color, fontSize, fontWeight, etc.
Image: This function displays an image on the screen. You can load an image from a resource or a URL by using the painterResource or rememberImagePainter functions respectively. You can also adjust its size and shape by using parameters such as modifier, contentScale, contentDescription, etc.
Button: This function displays a button on the screen. You can handle its click event by passing a lambda expression to the onClick parameter. You can also style it by using parameters such as colors, shape, elevation, etc.
Row: This function arranges its children horizontally in a row. You can control how they are aligned and spaced by using parameters such as horizontalArrangement, verticalAlignment, modifier, etc.
Column: This function arranges its children vertically in a column. You can control how they are aligned and spaced by using parameters such as verticalArrangement, horizontalAlignment, modifier, etc.
Box: This function stacks its children on top of each other in a box. You can control how they are positioned and sized by using parameters such as alignment, contentAlignment, modifier, etc.

Here is an example of how to use some of these composable functions to create a simple UI:

@Composable fun ProfileCard(name: String, image: Int) { Row( modifier = Modifier .padding(16.dp) .fillMaxWidth() .border(1.dp, Color.Gray) ) { Image( painter = painterResource(id = image), contentDescription = null, modifier = Modifier .size(64.dp) .clip(CircleShape) ) Spacer(modifier = Modifier.width(8.dp)) Column( verticalArrangement = Arrangement.Center ) { Text(text = name, fontWeight = FontWeight.Bold) Text(text = "Android Developer", fontStyle = FontStyle.Italic) } } }

This function creates a profile card with an image and some text. You can preview it in Android Studio by adding another function with the @Preview annotation:

@Preview @Composable fun PreviewProfileCard() { ProfileCard(name = "John Doe", image = R.drawable.profile_pic) }

This will show you how the profile card looks like in the preview window.

Conclusion

In this blog post, we learned how to use composable functions in Android Jetpack Compose. We saw how to create, preview, and use different types of composable functions to build native UI. Composable functions are a powerful and expressive way to describe your UI with less code and more flexibility. If you want to learn more about Jetpack Compose, you can check out the official documentation ¹ or some of the tutorials ² ³ available online.

I hope this blog post was helpful for you. If you have any questions or feedback, please let me know in the comments. Thank you for reading! 😊

Dell Laptop Charger 65W Watt USB Type C AC Power Adapter LA65NM190/HA65NM190/DA65NM190 Include Power Cord for Dell XPS 12 9250, XPS 13 9350 Compatible with XPS Series and Latitude 5000 Series

(733)

$24.00 (as of December 9, 2023 15:18 GMT -05:00 - )

50 Pcs The Grinch Stickers Christmas Stickers for Car Laptop PVC Backpack Water Bottle Pad Bicycle Waterproof Decal Sticker Kids Toy/Grinch

(220)

$6.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Olansit 200 PCS Water Bottle Stickers for Kids Teens, Cute Vinyl Waterproof Laptop Skateboard Stickers, Aesthetic Car Decals Computer Hydroflask Stickers for Adults Teens Kids Girls (200 pcs)

(1756)

$7.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Charger for HP Laptop Computer 65W 45W Smart Blue Tip Power Adapter

(2080)

$9.90 (as of December 9, 2023 15:18 GMT -05:00 - )

Amazon Fire 7 Kids tablet, ages 3-7. Top-selling 7" kids tablet on Amazon - 2022 | ad-free content with parental controls included, 10-hr battery, 16 GB, Blue

(12844)

$109.99 (as of December 9, 2023 15:18 GMT -05:00 - )

How to use Apollo GraphQL in Android Kotlin

GraphQL is a query language for APIs that allows you to specify the data you want from a server in a declarative way. Apollo GraphQL is a popular GraphQL client that generates Kotlin and Java models from GraphQL queries and executes them against a GraphQL server. In this blog post, I will show you how to set up Apollo GraphQL in your Android Kotlin project and how to use it to perform queries, mutations and subscriptions.

Setting up Apollo GraphQL

To use Apollo GraphQL in your Android Kotlin project, you need to add the following dependencies to your build.gradle.kts file:

plugins { id("com.apollographql.apollo3") version "3.8.1" } dependencies { implementation("com.apollographql.apollo3:apollo-runtime:3.8.1") }

You also need to set the package name for the generated models in your apollo block:

apollo { service("service") { packageName.set("com.example") } }

Apollo GraphQL supports three types of files:

.graphqls schema files: describe the types in your backend using the GraphQL syntax.
.json schema files: describe the types in your backend using the JSON syntax.
.graphql executable files: describe your queries and operations in the GraphQL syntax.

By default, Apollo GraphQL requires a schema in your module’s src/main/graphql directory. You can download a schema using introspection with the ./gradlew downloadApolloSchema task.

Writing and executing queries

To write a query, you need to create a .graphql file in your src/main/graphql directory with the following syntax:

query GetPosts($limit: Int) { posts(limit: $limit) { id title author { name } } }

This query will fetch a list of posts with their id, title and author name, and accept a limit argument to limit the number of posts.

Apollo GraphQL will generate a Kotlin class for this query with the same name as the file (GetPostsQuery) and a data class for each type (Post, Author). You can use these classes to execute the query using an ApolloClient instance:

val apolloClient = ApolloClient.Builder() .serverUrl("https://example.com/graphql") .build() val query = GetPostsQuery(limit = 10) apolloClient.query(query).execute().let { response -> if (response.isSuccessfull) { // handle success val posts = response.data?.posts // do something with posts } else { // handle error val error = response.errors?.firstOrNull() // do something with error } }

The execute() method returns an ApolloResponse object that contains either data or errors. You can access the data as query-specific Kotlin types and handle any errors that may occur.

Writing and executing mutations

To write a mutation, you need to create a .graphql file in your src/main/graphql directory with the following syntax:

mutation CreatePost($title: String!, $authorId: ID!) { createPost(input: {title: $title, authorId: $authorId}) { id title author { name } } }

This mutation will create a new post with the given title and author id, and return the created post with its id, title and author name.

Apollo GraphQL will generate a Kotlin class for this mutation with the same name as the file (CreatePostMutation) and a data class for each type (Post, Author). You can use these classes to execute the mutation using an ApolloClient instance:

val apolloClient = ApolloClient.Builder() .serverUrl("https://example.com/graphql") .build() val mutation = CreatePostMutation(title = "Hello world", authorId = "1") apolloClient.mutate(mutation).execute().let { response -> if (response.isSuccessfull) { // handle success val post = response.data?.createPost // do something with post } else { // handle error val error = response.errors?.firstOrNull() // do something with error } }

The execute() method returns an ApolloResponse object that contains either data or errors. You can access the data as mutation-specific Kotlin types and handle any errors that may occur.

Writing and executing subscriptions

To write a subscription, you need to create a .graphql file in your src/main/graphql directory with the following syntax:

subscription OnPostCreated { postCreated { id title author { name } } }

This subscription will listen for new posts created on the server and return the new post with its id, title and author name.

Apollo GraphQL will generate a Kotlin class for this subscription with the same name as the file (OnPostCreatedSubscription) and a data class for each type (Post, Author). You can use these classes to execute the subscription using an ApolloClient instance:

val apolloClient = ApolloClient.Builder() .serverUrl("wss://example.com/graphql") .build() val subscription = OnPostCreatedSubscription() apolloClient.subscribe(subscription).execute().collect { response -> if (response.isSuccessfull) { // handle success val post = response.data?.postCreated // do something with post } else { // handle error val error = response.errors?.firstOrNull() // do something with error } }

The execute() method returns a Flow of ApolloResponse objects that emit data or errors. You can collect the data as subscription-specific Kotlin types and handle any errors that may occur.

Conclusion

In this blog post, I showed you how to use Apollo GraphQL in your Android Kotlin project and how to perform queries, mutations and subscriptions. Apollo GraphQL is a powerful and type-safe GraphQL client that makes it easy to work with GraphQL APIs. You can learn more about Apollo GraphQL from their official documentation ¹ ² or their GitHub repository ³. I hope you enjoyed this blog post and found it useful. Happy coding! 🚀

How did I do? 😊

All-new Amazon Fire HD 10 tablet, built for relaxation, 10.1" vibrant Full HD screen, octa-core processor, 3 GB RAM, latest model (2023 release), 32 GB, Ocean

(378)

$139.99 (as of December 9, 2023 15:18 GMT -05:00 - )

havit HV-F2056 15.6"-17" Laptop Cooler Cooling Pad - Slim Portable USB Powered (3 Fans), Black/Blue

(39557)

$28.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Mac Book Air Charger Replacement for Mac Air AC 45W Power T-tip Shape Connector Power Adapter for 11 inch and 13 inch (Between 2012-2017)

(4460)

$19.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Certified Refurbished Amazon Fire HD 8 tablet, 8” HD Display, 32 GB, 30% faster processor, designed for portable entertainment, (2022 release), Black

(253)

$84.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Amazon Fire 7 tablet, 7” display, read and watch, under $60 with 10-hour battery life, (2022 release), 16 GB, Black

(12734)

$59.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Image Loading in Jetpack Compose

Jetpack Compose is a modern toolkit for building native UI on Android. It simplifies and accelerates UI development with declarative and reactive programming. One of the common tasks in UI development is to display images from various sources, such as network, local storage, assets or resources. In this blog post, we will explore how to load images in Jetpack Compose using different libraries and techniques.

Loading images from disk

To load an image from disk, such as a PNG, JPEG, WEBP or vector resource, we can use the Image composable with the painterResource API. The painterResource function takes an image reference (such as a resource ID) and returns a Painter object that can be used to draw the image on the screen. We don’t need to know the type of the asset, just use painterResource in Image or paint modifiers ¹.

For example, to load an image from a resource:

Image( painter = painterResource(id = R.drawable.dog), contentDescription = stringResource(id = R.string.dog_content_description) )

To ensure that our app is accessible, we should supply a contentDescription for visual elements on screen. TalkBack reads out the content description, so we must ensure that the text is meaningful if read out loud and translated. In the above example, we use a stringResource function to load up the translated content description from the strings.xml file. If our visual element on screen is purely for visual decoration, we can set our contentDescription to null for the screen reader to ignore it ¹.

If we need lower-level ImageBitmap specific functionality, we can use ImageBitmap.imageResource function to load up a bitmap. For more information on ImageBitmaps, read the ImageBitmap versus ImageVector section ¹.

Loading images from the internet

To load an image from the internet, there are several third-party libraries available that can help us handle the process. Image loading libraries do a lot of the heavy lifting for us; they handle both caching (so we don’t download the image multiple times) and networking logic to download the image and display it on screen ¹.

Some of the popular image loading libraries for Jetpack Compose are:

Coil: An image loading library backed by Kotlin Coroutines (Instacart)² ¹.
Glide: A fast and efficient image loading library for Android focused on smooth scrolling (Google)¹.
Fresco: An image loading library that supports a variety of image formats and sources (Facebook)³.
Landscapist: A pluggable, highly optimized Jetpack Compose image loading solution that fetches and displays network images with Glide, Coil, and Fresco. This library supports tracing image loading states, composing custom implementations, and some valuable animations, such as crossfades, blur transformation, and circular reveals (skydoves)² ³.

To use any of these libraries in our Android app, we need to add the corresponding dependency to our build.gradle file. Then, we can use their provided composables or extensions to load an image from a URL.

For example, to load an image with Coil:

AsyncImage( model = "https://example.com/image.jpg", contentDescription = "Translated description of what the image contains" )

To load an image with Glide:

GlideImage( model = "https://example.com/image.jpg", contentDescription = "Translated description of what the image contains" )

To load an image with Fresco:

FrescoImage( model = "https://example.com/image.jpg", contentDescription = "Translated description of what the image contains" )

To load an image with Landscapist:

NetworkImage( imageUrl = "https://example.com/image.jpg", contentDescription = "Translated description of what the image contains" )

We can also configure the requests with optional parameters or lambdas to customize the loading behavior and appearance of the images.

Code examples

Here are some code examples of using different libraries to load images from the internet in Jetpack Compose:

Loading an image with Coil

AsyncImage( model = "https://coil-kt.github.io/coil/logo.svg", contentDescription = "Coil logo", modifier = Modifier.size(200.dp), loading = { Box(Modifier.matchParentSize()) { CircularProgressIndicator(Modifier.align(Alignment.Center)) } }, error = { Image( painter = painterResource(id = R.drawable.error), contentDescription = "Error image" ) } )

Loading an image with Glide

GlideImage( model = "https://coil-kt.github.io/coil/logo.svg", contentDescription = "Coil logo", modifier = Modifier.size(200.dp), requestBuilder = { crossfade(true) placeholder(R.drawable.placeholder) error(R.drawable.error) } )

Loading an image with Fresco

FrescoImage( model = "https://coil-kt.github.io/coil/logo.svg", contentDescription = "Coil logo", modifier = Modifier.size(200.dp), controllerBuilder = { autoPlayAnimations(true) placeholderImage(R.drawable.placeholder) failureImage(R.drawable.error) } )

Loading an image with Landscapist

NetworkImage( imageUrl = "https://coil-kt.github.io/coil/logo.svg", contentDescription = "Coil logo", modifier = Modifier.size(200.dp), loading = { ShimmerParams( baseColor = Color.LightGray, highlightColor = Color.White, dropOff = 0.65f ) }, failure = { Image( painter = painterResource(id = R.drawable.error), contentDescription = "Error image" ) }, success = { RevealCircularTransition( durationMillis = 600, delayMillis = 100 ) } )

Bekayshad Stickers for Water Bottles, 100 Pack/PCS Cute Vsco Vinyl Aesthetic Waterproof Stickers Laptop Hydroflask Skateboard Computer Stickers for Teens Kids Girls

(9185)

$8.99 (as of December 9, 2023 15:18 GMT -05:00 - )

TP-Link AX1800 WiFi 6 Router (Archer AX21) – Dual Band Wireless Internet Router, Gigabit Router, Easy Mesh, Works with Alexa - A Certified for Humans Device

(16671)

$74.99 (as of December 9, 2023 15:18 GMT -05:00 - )

USB 3.0 Hub, VIENON 4-Port USB Hub USB Splitter USB Expander for Laptop, Xbox, Flash Drive, HDD, Console, Printer, Camera,Keyborad, Mouse

(9504)

$7.99 (as of December 9, 2023 15:18 GMT -05:00 - )

300pcs VSCO Stickers for Water Bottle, Cool Laptop Stickers for Kids Teens, Trendy Graffiti Cute Vinyl Aesthetic Waterproof Stickers Pack for Skateboard Luggage, Colorful Funny Stickers

(642)

$6.99 (as of December 9, 2023 15:18 GMT -05:00 - )

havit HV-F2056 15.6"-17" Laptop Cooler Cooling Pad - Slim Portable USB Powered (3 Fans), Black/Blue

(39557)

$28.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Structural Design Patterns in Android Kotlin

Structural design patterns are all about how you compose objects and classes to obtain new functionality. They help you simplify the design by finding a simple way of realizing relationships between entities ¹. In this blog post, we will cover three common structural design patterns: adapter, decorator and facade. We will also see how to implement them in Kotlin using some of its features such as extension functions, data classes and delegation.

Adapter Pattern

The adapter pattern allows you to convert the interface of a class into another interface that clients expect. It lets you make incompatible classes work together by wrapping one of them with an adapter class that implements the desired interface ². For example, suppose you have a class that represents a book:data class Book(val title: String, val author: String, val pages: Int) Copy

And you have another class that represents a library:class Library { private val books = mutableListOf<Book>() fun addBook(book: Book) { books.add(book) } fun getBooks(): List<Book> { return books } } Copy

Now, suppose you want to use a third-party library that provides a function to print a list of books in a nice format. However, this function expects a list of objects that implement the Printable interface:interface Printable { fun print(): String } Copy

How can you make your Book class compatible with this function? One way is to use the adapter pattern. You can create an adapter class that implements Printable and wraps a Book object:class BookAdapter(private val book: Book) : Printable { override fun print(): String { return "Title: ${book.title}, Author: ${book.author}, Pages: ${book.pages}" } } Copy

Then, you can use this adapter class to convert your list of books into a list of printable objects:val library = Library() library.addBook(Book("The Lord of the Rings", "J.R.R. Tolkien", 1178)) library.addBook(Book("Harry Potter and the Philosopher's Stone", "J.K. Rowling", 223)) library.addBook(Book("The Hitchhiker's Guide to the Galaxy", "Douglas Adams", 180)) val printables = library.getBooks().map { book -> BookAdapter(book) } printBooks(printables) // This is the third-party function that expects a list of Printable objects Copy

Alternatively, you can use an extension function to achieve the same result without creating an adapter class:fun Book.toPrintable(): Printable { return object : Printable { override fun print(): String { return "Title: ${this@toPrintable.title}, Author: ${this@toPrintable.author}, Pages: ${this@toPrintable.pages}" } } } val printables = library.getBooks().map { book -> book.toPrintable() } printBooks(printables) Copy

The advantage of using an extension function is that it reduces the amount of code and classes needed. However, it may not be suitable for complex scenarios where you need more control over the adaptation logic.

Decorator Pattern

The decorator pattern allows you to add new behavior or functionality to an existing object without modifying its structure or subclassing it. It lets you wrap an object with another object that implements the same interface and delegates all the requests to the original object while adding some extra logic before or after ². For example, suppose you have an interface that represents a coffee:interface Coffee { fun cost(): Double fun description(): String } Copy

And you have a concrete class that implements this interface:class Espresso : Coffee { override fun cost(): Double { return 1.5 } override fun description(): String { return "Espresso" } } Copy

Now, suppose you want to add some extra ingredients to your coffee, such as milk, whipped cream or caramel. One way is to use the decorator pattern. You can create an abstract class that implements Coffee and wraps another Coffee object:abstract class CoffeeDecorator(private val coffee: Coffee) : Coffee { override fun cost(): Double { return coffee.cost() } override fun description(): String { return coffee.description() } } Copy

Then, you can create concrete subclasses that extend this abstract class and add their own logic:class Milk(private val coffee: Coffee) : CoffeeDecorator(coffee) { override fun cost(): Double { return super.cost() + 0.5 } override fun description(): String { return "${super.description()}, Milk" } } class WhippedCream(private val coffee: Coffee) : CoffeeDecorator(coffee) { override fun cost(): Double { return super.cost() + 0.7 } override fun description(): String { return "${super.description()}, Whipped Cream" } } class Caramel(private val coffee: Coffee) : CoffeeDecorator(coffee) { override fun cost(): Double { return super.cost() + 0.8 } override fun description(): String { return "${super.description()}, Caramel" } } Copy

Then, you can use these decorator classes to create different combinations of coffee:val espresso = Espresso() println("${espresso.description()} costs ${espresso.cost()}") // Espresso costs 1.5 val espressoWithMilk = Milk(espresso) println("${espressoWithMilk.description()} costs ${espressoWithMilk.cost()}") // Espresso, Milk costs 2.0 val espressoWithMilkAndWhippedCream = WhippedCream(espressoWithMilk) println("${espressoWithMilkAndWhippedCream.description()} costs ${espressoWithMilkAndWhippedCream.cost()}") // Espresso, Milk, Whipped Cream costs 2.7 val espressoWithMilkAndWhippedCreamAndCaramel = Caramel(espressoWithMilkAndWhippedCream) println("${espressoWithMilkAndWhippedCreamAndCaramel.description()} costs ${espressoWithMilkAndWhippedCreamAndCaramel.cost()}") // Espresso, Milk, Whipped Cream, Caramel costs 3.5 Copy

Alternatively, you can use delegation instead of inheritance to implement the decorator pattern in Kotlin. You can create an interface that represents a decorator:interface Decorator<T> : T { val delegate: T } Copy

Then, you can create concrete classes that implement this interface and delegate all the requests to the wrapped object while adding their own logic:class Milk(override val delegate: Coffee) : Decorator<Coffee>, Coffee by delegate { override fun cost(): Double { return delegate.cost() + 0.5 } override fun description(): String { return "${delegate.description()}, Milk" } } class WhippedCream(override val delegate: Coffee) : Decorator<Coffee>, Coffee by delegate { override fun cost(): Double { return delegate.cost() + 0.7 } override fun description(): String { return "${delegate.description()}, Whipped Cream" } } class Caramel(override val delegate: Coffee) : Decorator<Coffee>, Coffee by delegate { override fun cost(): Double { return delegate.cost() + 0.8 } override fun description(): String { return "${delegate.description()}, Caramel" } } Copy

Then, you can use these decorator classes to create different combinations of coffee as before:val espresso = Espresso() println("${espresso.description()} costs ${espresso.cost()}") // Espresso costs 1.5 val espressoWithMilk = Milk(espresso) println("${espressoWithMilk.description()} costs ${espressoWithMilk.cost()}") // Espresso, Milk costs 2.0 val espressoWithMilkAndWhippedCream = WhippedCream(espressoWithMilk) println("${espressoWithMilkAndWhippedCream.description()} costs ${espressoWithMilkAndWhippedCream.cost()}") // Espresso, Milk, Whipped Cream costs 2.7 val espressoWithMilkAndWhippedCreamAndCaramel = Caramel(espressoWithMilkAndWhippedCream) println("${espressoWithMilkAndWhippedCreamAndCaramel.description()} costs ${espressoWithMilkAndWhippedCreamAndCaramel.cost()}") // Espresso, Milk, Whipped Cream, Caramel costs 3.5 Copy

The advantage of using delegation is that it avoids creating unnecessary subclasses and makes the code more concise and readable.

Facade Pattern

The facade pattern simplifies the interaction with a complex system or library by providing a unified and easy-to-use interface. It hides the details and implementation of the system from the clients and exposes only the essential functionality. For example, suppose you have a complex library that offers various functions for image processing:class ImageProcessingLibrary { fun loadBitmap(path: String): Bitmap { ... } fun resizeBitmap(bitmap: Bitmap, width: Int, height: Int): Bitmap { ... } fun cropBitmap(bitmap: Bitmap, x: Int, y: Int, width: Int, height: Int): Bitmap { ... } fun applyFilter(bitmap: Bitmap, filter: Filter): Bitmap { ... } fun saveBitmap(bitmap: Bitmap, path: String) { ... } // ... more functions } Copy

Using this library directly may be cumbersome and error-prone for the clients. They need to know how to use each function correctly and in what order. For example, if they want to load an image from a file, resize it, apply a filter and save it back to another file, they need to write something like this:val library = ImageProcessingLibrary() val bitmap = library.loadBitmap("input.jpg") val resizedBitmap = library.resizeBitmap(bitmap, 300, 300) val filteredBitmap = library.applyFilter(resizedBitmap, Filter.GRAYSCALE) library.saveBitmap(filteredBitmap, "output.jpg") Copy

To make this task easier and more convenient, you can use the facade pattern. You can create a class that acts as a facade for the library and provides a simple interface for common operations:class ImageProcessor(private val library: ImageProcessingLibrary) { fun processImage(inputPath: String, outputPath: String, width: Int, height: Int, filter: Filter) { val bitmap = library.loadBitmap(inputPath) val resizedBitmap = library.resizeBitmap(bitmap, width, height) val filteredBitmap = library.applyFilter(resizedBitmap, filter) library.saveBitmap(filteredBitmap, outputPath) } // ... more functions for other operations } Copy

Then, the clients can use this facade class to perform the same operation with less code and complexity:val processor = ImageProcessor(ImageProcessingLibrary()) processor.processImage("input.jpg", "output.jpg", 300, 300, Filter.GRAYSCALE) Copy

The advantage of using the facade pattern is that it reduces the coupling between the clients and the system or library. It also improves the readability and maintainability of the code by encapsulating the logic and details of the system or library in one place.

Conclusion

In this blog post, we have learned about three common structural design patterns: adapter, decorator and facade. We have seen how they can help us simplify the design and implementation of our Android applications by composing objects and classes in different ways. We have also seen how to implement them in Kotlin using some of its features such as extension functions, data classes and delegation. We hope you have enjoyed this post and found it useful. If you have any questions or feedback, please feel free to leave a comment below. Happy coding!

Olansit 200 PCS Water Bottle Stickers for Kids Teens, Cute Vinyl Waterproof Laptop Skateboard Stickers, Aesthetic Car Decals Computer Hydroflask Stickers for Adults Teens Kids Girls (200 pcs)

(1756)

$7.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Mac Book Pro Charger - 118W USB C Charger Fast Charger for USB C Port MacBook pro/Air, ipad Pro, Samsung Galaxy and All USB C Device, Include Charge Cable（7.2ft/2.2m）

(2720)

$37.99 (as of December 9, 2023 15:18 GMT -05:00 - )

USB 3.0 Hub, VIENON 4-Port USB Hub USB Splitter USB Expander for Laptop, Xbox, Flash Drive, HDD, Console, Printer, Camera,Keyborad, Mouse

(9504)

$7.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Amazon Fire HD 8 Kids tablet, ages 3-7. Top-selling 8" kids tablet on Amazon - 2022 | ad-free content with parental controls included, 13-hr battery, 32 GB, Blue

(5012)

$84.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Dell Laptop Charger 65W Watt USB Type C AC Power Adapter LA65NM190/HA65NM190/DA65NM190 Include Power Cord for Dell XPS 12 9250, XPS 13 9350 Compatible with XPS Series and Latitude 5000 Series

(733)

$24.00 (as of December 9, 2023 15:18 GMT -05:00 - )

Creational Design Patterns in Kotlin Android

Creational design patterns are a set of solutions to common software development problems that deal with how objects are being created. Using such patterns will ensure that your code is flexible and reusable, and that you avoid hard-coded dependencies and tight coupling between classes.

In this blog post, I will show you some of the most important and widely used creational design patterns in Kotlin Android. You will learn how to apply these patterns to your projects and how they can help you write better and more maintainable code. I will cover four creational design patterns:

Factory and abstract factory (provider model) method
Singleton
Builder
Dependency injection

Factory and abstract factory (provider model) method

The factory method pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. The abstract factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

These patterns are useful when you want to decouple the creation of objects from their usage, or when you want to provide different implementations of the same interface depending on some conditions. For example, you can use these patterns to create different types of views or fragments based on the device configuration or user preferences.

In Kotlin, you can use the provider model to implement these patterns. The provider model is a way of creating objects using lambda expressions or function references that act as factories. For example, you can use a provider function to create different types of fragments based on a parameter:

// An interface for fragments that display some content interface ContentFragment { fun showContent(content: String) } // A concrete implementation of ContentFragment that shows content in a text view class TextFragment : Fragment(), ContentFragment { private lateinit var textView: TextView override fun onCreateView( inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle? ): View? { return inflater.inflate(R.layout.text_fragment, container, false) } override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) textView = view.findViewById(R.id.text_view) } override fun showContent(content: String) { textView.text = content } } // Another concrete implementation of ContentFragment that shows content in a web view class WebFragment : Fragment(), ContentFragment { private lateinit var webView: WebView override fun onCreateView( inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle? ): View? { return inflater.inflate(R.layout.web_fragment, container, false) } override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) webView = view.findViewById(R.id.web_view) } override fun showContent(content: String) { webView.loadUrl(content) } } // A provider function that returns a ContentFragment based on a parameter fun provideContentFragment(type: String): ContentFragment = when (type) { "text" -> TextFragment() "web" -> WebFragment() else -> throw IllegalArgumentException("Unknown type: $type") }

Singleton

The singleton pattern ensures that a class has only one instance and provides a global point of access to it. This pattern is useful when you want to have a single source of truth for some data or functionality in your app. For example, you can use this pattern to create a repository that handles data access from different sources.

In Kotlin, you can use the object declaration to create a singleton class. The object declaration combines a class declaration and a single instance of that class into one expression. For example, you can use an object declaration to create a news repository that fetches data from a remote data source:

// A singleton class that acts as a repository for news data object NewsRepository { // A reference to the remote data source private val newsRemoteDataSource = // getDataSource() // A flow that emits the latest news from the remote data source val latestNews: Flow<List<ArticleHeadline>> = newsRemoteDataSource.latestNews // A function that returns the details of an article by its id suspend fun getArticleDetails(id: String): ArticleDetails { return newsRemoteDataSource.getArticleDetails(id) } }

Builder

The builder pattern separates the construction of a complex object from its representation so that the same construction process can create different representations. This pattern is useful when you want to create objects with many optional parameters or when you want to have more control over how the object is constructed. For example, you can use this pattern to create an alert dialog with various options.

In Kotlin, you can use named arguments and default values to implement this pattern. Named arguments allow you to specify the name of a parameter when calling a function, which makes the code more readable and avoids errors when there are many parameters. Default values allow you to omit some parameters when calling a function if they have a predefined value. For example, you can use named arguments and default values to create an alert dialog builder class:

// A class that represents an alert dialog with various options class AlertDialog( val title: String, val message: String, val positiveButton: String = "OK", val negativeButton: String? = null, val icon: Int? = null, val onPositiveClick: () -> Unit = {}, val onNegativeClick: () -> Unit = {} ) { // A function that shows the alert dialog on the screen fun show() { // Create and display an alert dialog using the Android SDK ... } } // A builder class that creates an AlertDialog instance using named arguments and default values class AlertDialogBuilder { // A function that returns an AlertDialog instance with the given parameters fun build( title: String, message: String, positiveButton: String = "OK", negativeButton: String? = null, icon: Int? = null, onPositiveClick: () -> Unit = {}, onNegativeClick: () -> Unit = {} ): AlertDialog { return AlertDialog( title = title, message = message, positiveButton = positiveButton, negativeButton = negativeButton, icon = icon, onPositiveClick = onPositiveClick, onNegativeClick = onNegativeClick ) } }

Dependency injection

The dependency injection pattern is a technique whereby one object supplies the dependencies of another object. A dependency is an object that can be used (a service). An injection is the passing of a dependency to a dependent object (a client) that would use it.

This pattern is useful when you want to reduce coupling and increase testability between classes by delegating the responsibility of creating and providing dependencies to another object or framework. For example, you can use this pattern to inject dependencies into your activities or view models.

In Kotlin Android, you can use frameworks like Dagger or Koin to implement this pattern. These frameworks provide annotations or DSLs to define dependencies and inject them into your classes. For example, you can use Koin to inject dependencies into your view model:

// A class that represents a user profile view model with some dependencies class UserProfileViewModel( private val userRepository: UserRepository, private val analyticsService: AnalyticsService ) : ViewModel() { // Some view model logic using userRepository and analyticsService ... } // A module that defines dependencies using Koin DSL val appModule = module { // Define UserRepository as a singleton using factory function single<UserRepository> { UserRepositoryImpl(get()) } // Define AnalyticsService as a singleton using constructor injection single<AnalyticsService> { AnalyticsServiceImpl() } // Define UserProfileViewModel using constructor injection viewModel { UserProfileViewModel(get(), get()) } } // Start Koin with appModule in Application class class MyApp : Application() { override fun onCreate() { super.onCreate() startKoin { androidContext(this@MyApp) modules(appModule) } } } // Get UserProfileViewModel instance using Koin extension function in Activity class class UserProfileActivity : AppCompatActivity() { // Inject UserProfileViewModel private val viewModel by viewModel<UserProfileViewModel>() override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_user_profile) // Use viewModel ... } }

Conclusion

In this blog post, you learned how to use creational design patterns in Kotlin Android. You learned how to apply these patterns to your projects and how they can help you write better and more maintainable code. You learned how to use factory and abstract factory (provider model) method, singleton, builder, and dependency injection patterns.

If you want to learn more about design patterns and other Kotlin features for Android development, check out these resources:

I hope you enjoyed this blog post and found it useful. Happy coding! 😊

All-new Amazon Fire HD 10 tablet, built for relaxation, 10.1" vibrant Full HD screen, octa-core processor, 3 GB RAM, latest model (2023 release), 32 GB, Ocean

(378)

$139.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Mac Book Air Charger Replacement for Mac Air AC 45W Power T-tip Shape Connector Power Adapter for 11 inch and 13 inch (Between 2012-2017)

(4460)

$19.99 (as of December 9, 2023 15:18 GMT -05:00 - )

USB 3.0 Hub, VIENON 4-Port USB Hub USB Splitter USB Expander for Laptop, Xbox, Flash Drive, HDD, Console, Printer, Camera,Keyborad, Mouse

(9504)

$7.99 (as of December 9, 2023 15:18 GMT -05:00 - )

45W USB C Chromebook Charger Replacement Compatible with HP, Dell, Lenovo, Acer, Asus, Samsung, Google Type C Laptop Charger, Hp Chromebook X360 11 13 14 14A HP Spectre X360 13 Elite X2 Power Cord

(400)

$9.98 (as of December 9, 2023 15:18 GMT -05:00 - )

Charger for HP Laptop Computer 65W 45W Smart Blue Tip Power Adapter

(2080)

$9.90 (as of December 9, 2023 15:18 GMT -05:00 - )

How to use Flow in Android Programming

Flow is a stream processing API in Kotlin developed by JetBrains ¹. It’s an implementation of the Reactive Stream specification, an initiative whose goal is to provide a standard for asynchronous stream processing ¹. Jetbrains built Kotlin Flow on top of Kotlin Coroutines, which means that you can use suspend functions to produce and consume values asynchronously ².

In this blog post, I will show you how to use Flow in your Android project to handle live data updates and endless streams of data. You will learn how to create flows, modify them, collect them, and use StateFlow and SharedFlow to share state and events across your app.

Creating a flow

To create flows, use the flow builder APIs. The flow builder function creates a new flow where you can manually emit new values into the stream of data using the emit function ². For example, you can use a flow to receive live updates from a network API:

class NewsRemoteDataSource( private val newsApi: NewsApi, private val refreshIntervalMs: Long = 5000 ) { val latestNews: Flow<List<ArticleHeadline>> = flow { while(true) { val latestNews = newsApi.fetchLatestNews() emit(latestNews) // Emits the result of the request to the flow delay(refreshIntervalMs) // Suspends the coroutine for some time } } } // Interface that provides a way to make network requests with suspend functions interface NewsApi { suspend fun fetchLatestNews(): List<ArticleHeadline> }

The flow builder is executed within a coroutine. Thus, it benefits from the same asynchronous APIs, but some restrictions apply:

Flows are sequential. As the producer is in a coroutine, when calling a suspend function, the producer suspends until the suspend function returns ².
Flows are cold. This means that the flow builder is called every time a terminal operator is applied to the flow ². Terminal operators are functions that start collecting values from the flow, such as collect or first.

Modifying the stream

You can use various operators to transform or filter the values emitted by a flow. For example, you can use map to apply a function to each value, filter to remove unwanted values, or combine to merge two flows into one ². For example, you can use map to convert the list of article headlines into a list of article titles:

val latestNewsTitles: Flow<List<String>> = latestNews.map { headlines -> headlines.map { headline -> headline.title } }

You can also use operators that are specific to flows, such as debounce or distinctUntilChanged. These operators help you deal with flows that emit values too frequently or unnecessarily ². For example, you can use debounce to ignore values that are emitted in quick succession:

val debouncedNewsTitles: Flow<List<String>> = latestNewsTitles.debounce(1000) // Ignores values that are emitted less than 1000 ms apart

Collecting from a flow

To start receiving values from a flow, you need to collect it. Collecting is a terminal operation that triggers the execution of the flow and invokes a given action for every value emitted by the flow ². You need to collect flows from a coroutine or a suspend function. For example, you can collect the debounced news titles from an activity:

class LatestNewsActivity : AppCompatActivity() { private val newsRemoteDataSource = // getDataSource() override fun onCreate(savedInstanceState: Bundle?) { ... // Start a coroutine in the lifecycle scope lifecycleScope.launch { // repeatOnLifecycle launches the block in a new coroutine every time the // lifecycle is in the STARTED state (or above) and cancels it when it's STOPPED. repeatOnLifecycle(Lifecycle.State.STARTED) { // Trigger the flow and start listening for values. newsRemoteDataSource.debouncedNewsTitles.collect { titles -> // Update UI with new titles } } } } }

Note that collecting from a flow can be a suspending operation if the flow is infinite or slow. This means that you should not collect from multiple flows sequentially in the same coroutine, as this will block the execution of the next collect until the previous one finishes. Instead, you should launch multiple coroutines or use other operators like zip or flatMapMerge to collect from multiple flows concurrently ².

StateFlow and SharedFlow

StateFlow and SharedFlow are Flow APIs that enable flows to optimally emit state updates and emit values to multiple consumers ³.

StateFlow is a state-holder observable flow that emits the current and new state updates to its collectors. The current state value can also be read through its value property. To update state and send it to the flow, assign a new value to the value property of the MutableStateFlow class ³.

In Android, StateFlow is a great fit for classes that need to maintain an observable mutable state. For example, you can use StateFlow to expose UI state from a ViewModel:

class LatestNewsViewModel( private val newsRepository: NewsRepository ) : ViewModel() { // Backing property to avoid state updates from other classes private val _uiState = MutableStateFlow(LatestNewsUiState.Success(emptyList())) // The UI collects from this StateFlow to get its state updates val uiState: StateFlow<LatestNewsUiState> = _uiState init { viewModelScope.launch { newsRepository.favoriteLatestNews // Update View with the latest favorite news // Writes to the value property of MutableStateFlow, // adding a new element to the flow and updating all // of its collectors .collect { favoriteNews -> _uiState.value = LatestNewsUiState.Success(favoriteNews) } } } } // Represents different states for the LatestNews screen sealed class LatestNewsUiState { data class Success(val news: List<ArticleHeadline>): LatestNewsUiState() data class Error(val exception: Throwable): LatestNewsUiState() }

Unlike a cold flow built using the flow builder, a StateFlow is hot: collecting from the flow doesn’t trigger any producer code. A StateFlow is always active and in memory, and it becomes eligible for garbage collection only when there are no other references to it from a garbage collection root. When a new consumer starts collecting from the flow, it receives the last state in the stream and any subsequent states. You can find this behavior in other observable classes like LiveData ³.

SharedFlow is an observable hot flow that emits values only when active collectors are present. Unlike StateFlow, SharedFlow does not have any initial value nor does it store any value at all. To emit values into SharedFlow use its emit function ³.

In Android, SharedFlow is useful for sharing events among multiple consumers without having any initial value or state associated with them. For example, you can use SharedFlow to broadcast user input events across your app:

class UserInputManager { // Creates an instance of MutableSharedFlow with zero replay buffer size, // meaning that only new events will be emitted by this SharedFlow. private val _userInputEvents = MutableSharedFlow<UserInputEvent>() // Exposes only SharedFlow interface so other classes cannot modify it. val userInputEvents: SharedFlow<UserInputEvent> = _userInputEvents fun onUserInput(event: UserInputEvent) { viewModelScope.launch { _userInputEvents.emit(event) // Emits event into SharedFlow } } } // Represents different types of user input events sealed class UserInputEvent { data class Tap(val x: Float, val y: Float): UserInputEvent() data class Swipe(val direction: Direction): UserInputEvent() }

To collect from StateFlow or SharedFlow, you can use any terminal operator like collect or first as with any other flow.

Conclusion

In this blog post, you learned how to use Flow in your Android project to handle live data updates and endless streams of data. You learned how to create flows, modify them, collect them, and use StateFlow and SharedFlow to share state and events across your app.

If you want to learn more about Flow and other Kotlin features for Android development, check out these resources:

I hope you enjoyed this blog post and found it useful. Happy coding! 😊

All-new Amazon Fire HD 10 tablet, built for relaxation, 10.1" vibrant Full HD screen, octa-core processor, 3 GB RAM, latest model (2023 release), 32 GB, Lilac

(378)

$139.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Amazon Fire HD 8 tablet, 8” HD Display, 32 GB, 30% faster processor, designed for portable entertainment, (2022 release), Black

(10964)

$99.99 (as of December 9, 2023 15:18 GMT -05:00 - )

50 Pcs The Grinch Stickers Christmas Stickers for Car Laptop PVC Backpack Water Bottle Pad Bicycle Waterproof Decal Sticker Kids Toy/Grinch

(220)

$6.99 (as of December 9, 2023 15:18 GMT -05:00 - )

USB 3.0 Hub, VIENON 4-Port USB Hub USB Splitter USB Expander for Laptop, Xbox, Flash Drive, HDD, Console, Printer, Camera,Keyborad, Mouse

(9504)

$7.99 (as of December 9, 2023 15:18 GMT -05:00 - )

All-new Amazon Fire HD 10 tablet, built for relaxation, 10.1" vibrant Full HD screen, octa-core processor, 3 GB RAM, latest model (2023 release), 32 GB, Ocean

(378)

$139.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Kotlin Nullability with extension functions and examples

Nullability and Common Extension Functions in Kotlin Explained with Code Examples

Kotlin is a statically typed programming language that was designed to be a safer alternative to Java. One of the ways it achieves this safety is through nullability, which allows developers to prevent null pointer exceptions at runtime by making them compile-time errors. In this blog post, we will explore nullability in Kotlin and common extension functions that can help you work with null values more efficiently.

Nullability in Kotlin

Nullability is a concept in programming that refers to the ability of a variable or object to hold a null value. In Kotlin, nullability is controlled with two types: nullable and non-nullable. A nullable type can hold a null value, while a non-nullable type cannot.

To make a variable or object nullable in Kotlin, you simply add a question mark after its type. For example, the following code creates a nullable String:

var nullableString: String? = null

To make a variable or object non-nullable in Kotlin, you do not add a question mark after its type. For example, the following code creates a non-nullable String:

val nonNullableString: String = “Hello, World!”

If you try to assign a null value to a non-nullable type, the compiler will give you an error:

val nonNullableString: String = null // Error: Null can not be value of a non-null type String

Common Extension Functions for Nullability

There are several extension functions in Kotlin that can help you work with null values more efficiently. Let’s look at some of the most common ones:

1. safeCall

The safeCall function allows you to execute a method or property on a nullable object without the risk of a null pointer exception. If the object is null, the function returns null.

For example, the following code uses the safeCall function to print the length of a nullable String:

val nullableString: String? = null
println(nullableString?.length) // Prints null

2. Elvis Operator

The Elvis operator allows you to assign a default value to a nullable variable or object. If the value is null, the operator returns the default value instead.

For example, the following code uses the Elvis operator to assign a default value to a nullable String:

val nullableString: String? = null
val length = nullableString?.length ?: -1
println(length) // Prints -1

3. Let Function

The let function allows you to execute a block of code if a nullable variable or object is not null. Inside the block, the variable or object is called with the it keyword.

For example, the following code uses the let function to print the length of a nullable String if it is not null:

val nullableString: String? = “Hello, World!”
nullableString?.let { println(it.length) } // Prints 13

4. Nullable Type Conversion

The toIntOrNull and toDoubleOrNull functions allow you to convert a nullable String to an Int or Double, respectively. If the String is null or cannot be parsed, the functions return null.

For example, the following code converts a nullable String to an Int using the toIntOrNull function:

val nullableString: String? = “123”
val nullableInt: Int? = nullableString?.toIntOrNull()
println(nullableInt) // Prints 123

In conclusion, nullability is an essential concept in Kotlin that helps prevent null pointer exceptions. By using common extension functions like safeCall, Elvis operator, Let function, and nullable type conversion, you can work with null values more efficiently and safely. We hope this blog post has been helpful in understanding nullability in Kotlin and its common extension functions.

Charger for HP Laptop Computer 65W 45W Smart Blue Tip Power Adapter

(2080)

$9.90 (as of December 9, 2023 15:18 GMT -05:00 - )

Dell Laptop Charger 65W Watt USB Type C AC Power Adapter LA65NM190/HA65NM190/DA65NM190 Include Power Cord for Dell XPS 12 9250, XPS 13 9350 Compatible with XPS Series and Latitude 5000 Series

(733)

$24.00 (as of December 9, 2023 15:18 GMT -05:00 - )

TP-Link AX1800 WiFi 6 Router (Archer AX21) – Dual Band Wireless Internet Router, Gigabit Router, Easy Mesh, Works with Alexa - A Certified for Humans Device

(16671)

$74.99 (as of December 9, 2023 15:18 GMT -05:00 - )

50 Pcs The Grinch Stickers Christmas Stickers for Car Laptop PVC Backpack Water Bottle Pad Bicycle Waterproof Decal Sticker Kids Toy/Grinch

(220)

$6.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Amazon Fire Max 11 tablet, vivid 11” display, all-in-one for streaming, reading, and gaming, 14-hour battery life, optional stylus and keyboard, 64 GB, Gray

(3735)

$159.99 (as of December 9, 2023 15:18 GMT -05:00 - )

Genie Lamp Free a silly app for android!!!

Genie Lamp Free is a funny voice recognition app where you rub the lamp and make a wish to a genie and the genie gives a reply based on what you say. The app has over 5,000 downloads on google play store. Genie Lamp Free is where you can go to try the game. Its awesome because its free and you might get a few kicks out of it.

So go download GenieLampFree and leave a review for the developer jacs@pps on google play store. As far as I know its the only genie in a lamp app that you can actually talk to. They have a lot of great apps on there who knows what those guys are up to. The app is just for entertainment purposes and only available for android devices so I guess that’s too bad for all the apple gurus out there. Thanks for reading and go download that app. 😉

Excalibur Strength is awesome!!!

This post is about a game that is available on the Play Store and it is free with in app purchases. The game is called Excalibur Strength and you can get it here Link to Excalibur Strength. Presently the game has 4 and a half stars but I personally give it a 5. The story behind the game is that the sword, Excalibur by it self is in the afterlife and it has to fend off all of the envious souls that couldn’t lift the sword from the stone in life and that is where Excalibur gets the strength and why it is known as one of the most powerfull weapons in the universe. Excalibur Strength is a classic hoard game with unlimited waves. The game has 7 special moves and the monetary system is bones. You can use bones to unlock new weapons and special features. You can unlock the whole game for a purchase of 20 dollars worth of bones, or you can just play the game until you have earned enough bones to unlock what youd like. Personally I love the back story of the game about envious souls and the strength of Excalibur being derived from eternally battling the souls. Its a decent game with pretty good graphics and audio. The audio is very good, you can switch between 3 different songs to play while your playing. So go download the game and rate it. Its only for android and it is a great all around action game. You’ll love it.

What are composable functions?

How to preview composable functions in Android Studio?

How to use different types of composable functions?

Conclusion

Share this:

Like this:

Setting up Apollo GraphQL

Writing and executing queries

Writing and executing mutations

Writing and executing subscriptions

Conclusion

Share this:

Like this:

Loading images from disk

Loading images from the internet

Code examples

Loading an image with Coil

Loading an image with Glide

Loading an image with Fresco

Loading an image with Landscapist

Share this:

Like this:

Adapter Pattern

Decorator Pattern

Facade Pattern

Conclusion

Share this:

Like this:

Factory and abstract factory (provider model) method

Singleton

Builder

Dependency injection

Conclusion

Share this:

Like this:

Creating a flow

Modifying the stream

Collecting from a flow

StateFlow and SharedFlow

Conclusion

Share this:

Like this:

Share this:

Like this:

Share this:

Like this:

Share this:

Like this: