{ "version": "https://jsonfeed.org/version/1", "title": "Hunga1ok's blog", "home_page_url": "https://hunga1ok.github.io/blog/", "feed_url": "https://hunga1ok.github.io/blog/feed.json", "description": "just a minimalist, personal blog", "icon": "https://hunga1ok.github.io/blog/apple-touch-icon.png", "favicon": "https://hunga1ok.github.io/blog/favicon.ico", "expired": false, "author": { "name": "hunga1ok", "url": null, "avatar": null }, "items": [ { "id": "https://hunga1ok.github.io/blog/2023/09/24/android-logging-with-timber", "title": "Android logging with Timber", "summary": "Android logging with timber and how to implement", "content_text": "Android logging with TimberTriển khai TimberLogging là một vấn đề không còn xa lạ với các lập trình viên. Hôm nay mình cũng sẽ trình bày về cách implement logging sử dụng thư viện Timber.Đầu tiên thì Timber là một API cho class Log của Android. Nó bổ trợ và nâng cấp cho chức năng log của Android. Ta làm việc đó bằng cách trồng (plant) một đối tượng Tree. Để sử dụng Timber, ta khai báo việc implement timber vào build.gradlerepositories { mavenCentral()}implementation 'com.jakewharton.timber:timber:5.0.1'Việc cài đặt timber rất dễ dàng chúng ta chỉ cần tạo một Timber Tree. Tree ở đây là một dạng cây hỗ trợ việc triển khai cách ghi log vào hệ thống mà ta có thể tự tuỳ chỉnh hoặc dùng tree default là DebugTree. Ví dụ:class MyApplication: Application() { override fun onCreate() { super.onCreate() Timber.plant(Timber.DebugTree()) } override fun onTerminate() { super.onTerminate() Timber.uprootAll() }}Trên đây là một cách cài đặt đợt giản, chúng ta nên cài đặt Timber sớm nhất có thể. Khi dùng chúng ta có thể dùng như log bình thường:Timber.v(\"content to log\")Timber.i(\"content to log\")Timber.d(\"content to log\")Tạo một cây tuỳ chỉnh với TimberSau đây mình cùng tiến hành tạo một Timber Tree cho mình, ta cần override lại function log :class LoggingCustom : Timber.Tree() { override fun log(priority: Int, tag: String?, message: String, t: Throwable?) { TODO(\"Not yet implemented\") }}Dưới đây mình có một ví dụ về lưu custom Tree dùng với logger để lưu log vào file: tạo 1 file FileLoggingCustom.ktclass FileLoggingCustom private constructor( context: Context, fileDir: String, fileName: String, sizeLimit: Int, fileLimitCount: Int, isAppendable: Boolean, tag: String, levelLog: Level): Timber.Tree() { private var myLogger: Logger init { val path: String = File(context.getExternalFilesDir(fileDir), fileName).absolutePath val fileHandler: FileHandler val logger: Logger = MyLogger(tag) logger.level = levelLog if (logger.handlers.isEmpty()) { fileHandler = FileHandler(path, sizeLimit, fileLimitCount, isAppendable) fileHandler.formatter = SimpleFormatter() logger.addHandler(fileHandler) } else { fileHandler = logger.handlers[0] as FileHandler logger.addHandler(fileHandler) } myLogger = logger } override fun log(priority: Int, tag: String?, message: String, t: Throwable?) { myLogger.log(fromPriorityToLevel(priority), message) } private fun fromPriorityToLevel(priority: Int): Level { return when (priority) { Log.VERBOSE -> Level.FINER Log.DEBUG -> Level.FINE Log.INFO -> Level.INFO Log.WARN -> Level.WARNING Log.ERROR -> Level.SEVERE Log.ASSERT -> Level.SEVERE else -> Level.FINEST } } data class Builder( val context: Context, private var fileDir: String = \"LogDir\", private var fileName: String = \"File%g.log\", private var sizeLimit: Int = 1000_000, private var fileLimitCount: Int = 3, private var isAppendable: Boolean = true, private var tag: String = \"FileLoggerTree\", private var levelLog: Level = Level.ALL ) { fun fileDir(dir: String) = apply { this.fileDir = dir } fun fileName(name: String) = apply { this.fileName = name } fun sizeLimit(limit: Int) = apply { this.sizeLimit = limit } fun fileLimit(limit: Int) = apply { this.fileLimitCount = limit } fun isAppendable(append: Boolean) = apply { this.isAppendable = append } fun tag(tag: String) = apply { this.tag = tag } fun levelLog(level: Level) = apply { this.levelLog = level } fun build() = FileLoggingCustom(context, fileDir, fileName, sizeLimit, fileLimitCount, isAppendable, tag, levelLog) }}Khi khởi tạo Tree:val t: Tree = FileLoggingCustom.Builder(this).build()Timber.plant(t)ta có thể custom lại các thông số của Logging:val t: Tree = FileLoggingCustom.Builder(this) .fileDir(\"DirFile\") .fileName(\"file%g.log\") .tag(\"CustomTag\") .sizeLimit(1000_000_000) // ~1MB .fileLimit(3) // create limit 3 file .levelLog(Level.ALL) // receive all log .isAppendable(true) // true: append log to file, false: create new file .build() Timber.plant(t)File log sẽ được lưu vào pathsdcard/Android/data/your package name/DirFile/filei.logTrên đây là một cách triển khai Timber và timber log to file.Dưới đây là source code: Source Code", "content_html": "

Android logging with Timber

Triển khai Timber

Logging là một vấn đề không còn xa lạ với các lập trình viên. Hôm nay mình cũng sẽ trình bày về cách implement logging sử dụng thư viện Timber.

Đầu tiên thì Timber là một API cho class Log của Android. Nó bổ trợ và nâng cấp cho chức năng log của Android. Ta làm việc đó bằng cách trồng (plant) một đối tượng Tree. Để sử dụng Timber, ta khai báo việc implement timber vào build.gradle

repositories {  mavenCentral()}implementation 'com.jakewharton.timber:timber:5.0.1'

Việc cài đặt timber rất dễ dàng chúng ta chỉ cần tạo một Timber Tree. Tree ở đây là một dạng cây hỗ trợ việc triển khai cách ghi log vào hệ thống mà ta có thể tự tuỳ chỉnh hoặc dùng tree default là DebugTree. Ví dụ:

class MyApplication: Application() {    override fun onCreate() {        super.onCreate()        Timber.plant(Timber.DebugTree())    }    override fun onTerminate() {        super.onTerminate()        Timber.uprootAll()    }}

Trên đây là một cách cài đặt đợt giản, chúng ta nên cài đặt Timber sớm nhất có thể. Khi dùng chúng ta có thể dùng như log bình thường:

Timber.v(\"content to log\")Timber.i(\"content to log\")Timber.d(\"content to log\")

Tạo một cây tuỳ chỉnh với Timber

Sau đây mình cùng tiến hành tạo một Timber Tree cho mình, ta cần override lại function log :

class LoggingCustom : Timber.Tree() {    override fun log(priority: Int, tag: String?, message: String, t: Throwable?) {        TODO(\"Not yet implemented\")    }}

Dưới đây mình có một ví dụ về lưu custom Tree dùng với logger để lưu log vào file:

class FileLoggingCustom private constructor(    context: Context,    fileDir: String,    fileName: String,    sizeLimit: Int,    fileLimitCount: Int,    isAppendable: Boolean,    tag: String,    levelLog: Level): Timber.Tree() {    private var myLogger: Logger    init {        val path: String = File(context.getExternalFilesDir(fileDir), fileName).absolutePath        val fileHandler: FileHandler        val logger: Logger = MyLogger(tag)        logger.level = levelLog        if (logger.handlers.isEmpty()) {            fileHandler = FileHandler(path, sizeLimit, fileLimitCount, isAppendable)            fileHandler.formatter = SimpleFormatter()            logger.addHandler(fileHandler)        } else {            fileHandler = logger.handlers[0] as FileHandler            logger.addHandler(fileHandler)        }        myLogger = logger    }    override fun log(priority: Int, tag: String?, message: String, t: Throwable?) {        myLogger.log(fromPriorityToLevel(priority), message)    }    private fun fromPriorityToLevel(priority: Int): Level {        return when (priority) {            Log.VERBOSE -> Level.FINER            Log.DEBUG -> Level.FINE            Log.INFO -> Level.INFO            Log.WARN -> Level.WARNING            Log.ERROR -> Level.SEVERE            Log.ASSERT -> Level.SEVERE            else -> Level.FINEST        }    }    data class Builder(        val context: Context,        private var fileDir: String = \"LogDir\",        private var fileName: String = \"File%g.log\",        private var sizeLimit: Int = 1000_000,        private var fileLimitCount: Int = 3,        private var isAppendable: Boolean = true,        private var tag: String = \"FileLoggerTree\",        private var levelLog: Level = Level.ALL    ) {        fun fileDir(dir: String) = apply { this.fileDir = dir }        fun fileName(name: String) = apply { this.fileName = name }        fun sizeLimit(limit: Int) = apply { this.sizeLimit = limit }        fun fileLimit(limit: Int) = apply { this.fileLimitCount = limit }        fun isAppendable(append: Boolean) = apply { this.isAppendable = append }        fun tag(tag: String) = apply { this.tag = tag }        fun levelLog(level: Level) = apply { this.levelLog = level }        fun build() = FileLoggingCustom(context, fileDir, fileName, sizeLimit, fileLimitCount, isAppendable, tag, levelLog)    }}

Khi khởi tạo Tree:

val t: Tree = FileLoggingCustom.Builder(this).build()Timber.plant(t)

ta có thể custom lại các thông số của Logging:

val t: Tree = FileLoggingCustom.Builder(this)                    .fileDir(\"DirFile\")                    .fileName(\"file%g.log\")                    .tag(\"CustomTag\")                    .sizeLimit(1000_000_000) // ~1MB                    .fileLimit(3) // create limit 3 file                    .levelLog(Level.ALL) // receive all log                    .isAppendable(true) // true: append log to file, false: create new file                    .build()                Timber.plant(t)

File log sẽ được lưu vào path

sdcard/Android/data/your package name/DirFile/filei.log

Trên đây là một cách triển khai Timber và timber log to file.

Dưới đây là source code: Source Code

", "url": "https://hunga1ok.github.io/blog/2023/09/24/android-logging-with-timber", "tags": ["android","logging"], "date_published": "2023-09-24T00:00:00+02:00", "date_modified": "2023-09-24T00:00:00+02:00", "author": { "name": "hunga1ok", "url": null, "avatar": null } }, { "id": "https://hunga1ok.github.io/blog/2023/06/26/architecture-learning-journey", "title": "Architecture Learning Journey", "summary": "android app architecture", "content_text": "Architecture Learning JourneyIn this learning journey you will learn about the Now in Android app architecture: its layers, key classes and the interactions between them.Goals and requirementsThe goals for the app architecture are: Follow the official architecture guidance as closely as possible. Easy for developers to understand, nothing too experimental. Support multiple developers working on the same codebase. Facilitate local and instrumented tests, both on the developer’s machine and using Continuous Integration (CI). Minimize build times.Architecture overviewThe app architecture has three layers: a data layer, a domain layer and a UI layer.The architecture follows a reactive programming model with unidirectional data flow. With the data layer at the bottom, the key concepts are: Higher layers react to changes in lower layers. Events flow down. Data flows up.The data flow is achieved using streams, implemented using Kotlin Flows.Example: Displaying news on the For You screenWhen the app is first run it will attempt to load a list of news resources from a remote server (when the prod build flavor is selected, demo builds will use local data). Once loaded, these are shown to the user based on the interests they choose.The following diagram shows the events which occur and how data flows from the relevant objects to achieve this.Here’s what’s happening in each step. The easiest way to find the associated code is to load the project into Android Studio and search for the text in the Code column (handy shortcut: tap ⇧ SHIFT twice). Step Description Code 1 On app startup, a WorkManager job to sync all repositories is enqueued. Sync.initialize 2 The ForYouViewModel calls GetUserNewsResourcesUseCase to obtain a stream of news resources with their bookmarked/saved state. No items will be emitted into this stream until both the user and news repositories emit an item. While waiting, the feed state is set to Loading. Search for usages of NewsFeedUiState.Loading 3 The user data repository obtains a stream of UserData objects from a local data source backed by Proto DataStore. NiaPreferencesDataSource.userData 4 WorkManager executes the sync job which calls OfflineFirstNewsRepository to start synchronizing data with the remote data source. SyncWorker.doWork 5 OfflineFirstNewsRepository calls RetrofitNiaNetwork to execute the actual API request using Retrofit. OfflineFirstNewsRepository.syncWith 6 RetrofitNiaNetwork calls the REST API on the remote server. RetrofitNiaNetwork.getNewsResources 7 RetrofitNiaNetwork receives the network response from the remote server. RetrofitNiaNetwork.getNewsResources 8 OfflineFirstNewsRepository syncs the remote data with NewsResourceDao by inserting, updating or deleting data in a local Room database. OfflineFirstNewsRepository.syncWith 9 When data changes in NewsResourceDao it is emitted into the news resources data stream (which is a Flow). NewsResourceDao.getNewsResources 10 OfflineFirstNewsRepository acts as an intermediate operator on this stream, transforming the incoming PopulatedNewsResource (a database model, internal to the data layer) to the public NewsResource model which is consumed by other layers. OfflineFirstNewsRepository.getNewsResources 11 GetUserNewsResourcesUseCase combines the list of news resources with the user data to emit a list of UserNewsResources. GetUserNewsResourcesUseCase.invoke 12 When ForYouViewModel receives the saveable news resources it updates the feed state to Success. ForYouScreen then uses the saveable news resources in the state to render the screen. Search for instances of NewsFeedUiState.Success Data layerThe data layer is implemented as an offline-first source of app data and business logic. It is the source of truth for all data in the app.Each repository has its own models. For example, the TopicsRepository has a Topic model and the NewsRepository has a NewsResource model.Repositories are the public API for other layers, they provide the only way to access the app data. The repositories typically offer one or more methods for reading and writing data.Reading dataData is exposed as data streams. This means each client of the repository must be prepared to react to data changes. Data is not exposed as a snapshot (e.g. getModel) because there’s no guarantee that it will still be valid by the time it is used.Reads are performed from local storage as the source of truth, therefore errors are not expected when reading from Repository instances. However, errors may occur when trying to reconcile data in local storage with remote sources. For more on error reconciliation, check the data synchronization section below.Example: Read a list of topicsA list of Topics can be obtained by subscribing to TopicsRepository::getTopics flow which emits List<Topic>.Whenever the list of topics changes (for example, when a new topic is added), the updated List<Topic> is emitted into the stream.Writing dataTo write data, the repository provides suspend functions. It is up to the caller to ensure that their execution is suitably scoped.Example: Follow a topicSimply call UserDataRepository.toggleFollowedTopicId with the ID of the topic the user wishes to follow and followed=true to indicate that the topic should be followed (use false to unfollow a topic).Data sourcesA repository may depend on one or more data sources. For example, the OfflineFirstTopicsRepository depends on the following data sources: Name Backed by Purpose TopicsDao Room/SQLite Persistent relational data associated with Topics NiaPreferencesDataSource Proto DataStore Persistent unstructured data associated with user preferences, specifically which Topics the user is interested in. This is defined and modeled in a .proto file, using the protobuf syntax. NiaNetworkDataSource Remote API accessed using Retrofit Data for topics, provided through REST API endpoints as JSON. Data synchronizationRepositories are responsible for reconciling data in local storage with remote sources. Once data is obtained from a remote data source it is immediately written to local storage. The updated data is emitted from local storage (Room) into the relevant data stream and received by any listening clients.This approach ensures that the read and write concerns of the app are separate and do not interfere with each other.In the case of errors during data synchronization, an exponential backoff strategy is employed. This is delegated to WorkManager via the SyncWorker, an implementation of the Synchronizer interface.See the OfflineFirstNewsRepository.syncWith for an example of data synchronization.Domain layerThe domain layer contains use cases. These are classes which have a single invocable method (operator fun invoke) containing business logic.These use cases are used to simplify and remove duplicate logic from ViewModels. They typically combine and transform data from repositories.For example, GetUserNewsResourcesUseCase combines a stream (implemented using Flow) of NewsResources from a NewsRepository with a stream of UserData objects from a UserDataRepository to create a stream of UserNewsResources. This stream is used by various ViewModels to display news resources on screen with their bookmarked state.Notably, the domain layer in Now in Android does not (for now) contain any use cases for event handling. Events are handled by the UI layer calling methods on repositories directly.UI LayerThe UI layer comprises: UI elements built using Jetpack Compose Android ViewModelsThe ViewModels receive streams of data from use cases and repositories, and transforms them into UI state. The UI elements reflect this state, and provide ways for the user to interact with the app. These interactions are passed as events to the ViewModel where they are processed.Modeling UI stateUI state is modeled as a sealed hierarchy using interfaces and immutable data classes. State objects are only ever emitted through the transform of data streams. This approach ensures that: the UI state always represents the underlying app data - the app data is the source-of-truth. the UI elements handle all possible states.Example: News feed on For You screenThe feed (a list) of news resources on the For You screen is modeled using NewsFeedUiState. This is a sealed interface which creates a hierarchy of two possible states: Loading indicates that the data is loading Success indicates that the data was loaded successfully. The Success state contains the list of news resources.The feedState is passed to the ForYouScreen composable, which handles both of these states.Transforming streams into UI stateViewModels receive streams of data as cold flows from one or more use cases or repositories. These are combined together, or simply mapped, to produce a single flow of UI state. This single flow is then converted to a hot flow using stateIn. The conversion to a state flow enables UI elements to read the last known state from the flow.Example: Displaying followed topicsThe InterestsViewModel exposes uiState as a StateFlow<InterestsUiState>. This hot flow is created by obtaining the cold flow of List<FollowableTopic> provided by GetFollowableTopicsUseCase. Each time a new list is emitted, it is converted into an InterestsUiState.Interests state which is exposed to the UI.Processing user interactionsUser actions are communicated from UI elements to ViewModels using regular method invocations. These methods are passed to the UI elements as lambda expressions.Example: Following a topicThe InterestsScreen takes a lambda expression named followTopic which is supplied from InterestsViewModel.followTopic. Each time the user taps on a topic to follow this method is called. The ViewModel then processes this action by informing the user data repository.Further readingGuide to app architectureJetpack Compose", "content_html": "

Architecture Learning Journey

In this learning journey you will learn about the Now in Android app architecture: its layers, key classes and the interactions between them.

Goals and requirements

The goals for the app architecture are:

Architecture overview

The app architecture has three layers: a data layer, a domain layer and a UI layer.

\"Diagram

The architecture follows a reactive programming model with unidirectional data flow. With the data layer at the bottom, the key concepts are:

The data flow is achieved using streams, implemented using Kotlin Flows.

Example: Displaying news on the For You screen

When the app is first run it will attempt to load a list of news resources from a remote server (when the prod build flavor is selected, demo builds will use local data). Once loaded, these are shown to the user based on the interests they choose.

The following diagram shows the events which occur and how data flows from the relevant objects to achieve this.

\"Diagram

Here’s what’s happening in each step. The easiest way to find the associated code is to load the project into Android Studio and search for the text in the Code column (handy shortcut: tap ⇧ SHIFT twice).

Step Description Code
1 On app startup, a WorkManager job to sync all repositories is enqueued. Sync.initialize
2 The ForYouViewModel calls GetUserNewsResourcesUseCase to obtain a stream of news resources with their bookmarked/saved state. No items will be emitted into this stream until both the user and news repositories emit an item. While waiting, the feed state is set to Loading. Search for usages of NewsFeedUiState.Loading
3 The user data repository obtains a stream of UserData objects from a local data source backed by Proto DataStore. NiaPreferencesDataSource.userData
4 WorkManager executes the sync job which calls OfflineFirstNewsRepository to start synchronizing data with the remote data source. SyncWorker.doWork
5 OfflineFirstNewsRepository calls RetrofitNiaNetwork to execute the actual API request using Retrofit. OfflineFirstNewsRepository.syncWith
6 RetrofitNiaNetwork calls the REST API on the remote server. RetrofitNiaNetwork.getNewsResources
7 RetrofitNiaNetwork receives the network response from the remote server. RetrofitNiaNetwork.getNewsResources
8 OfflineFirstNewsRepository syncs the remote data with NewsResourceDao by inserting, updating or deleting data in a local Room database. OfflineFirstNewsRepository.syncWith
9 When data changes in NewsResourceDao it is emitted into the news resources data stream (which is a Flow). NewsResourceDao.getNewsResources
10 OfflineFirstNewsRepository acts as an intermediate operator on this stream, transforming the incoming PopulatedNewsResource (a database model, internal to the data layer) to the public NewsResource model which is consumed by other layers. OfflineFirstNewsRepository.getNewsResources
11 GetUserNewsResourcesUseCase combines the list of news resources with the user data to emit a list of UserNewsResources. GetUserNewsResourcesUseCase.invoke
12 When ForYouViewModel receives the saveable news resources it updates the feed state to Success. ForYouScreen then uses the saveable news resources in the state to render the screen. Search for instances of NewsFeedUiState.Success

Data layer

The data layer is implemented as an offline-first source of app data and business logic. It is the source of truth for all data in the app.

\"Diagram

Each repository has its own models. For example, the TopicsRepository has a Topic model and the NewsRepository has a NewsResource model.

Repositories are the public API for other layers, they provide the only way to access the app data. The repositories typically offer one or more methods for reading and writing data.

Reading data

Data is exposed as data streams. This means each client of the repository must be prepared to react to data changes. Data is not exposed as a snapshot (e.g. getModel) because there’s no guarantee that it will still be valid by the time it is used.

Reads are performed from local storage as the source of truth, therefore errors are not expected when reading from Repository instances. However, errors may occur when trying to reconcile data in local storage with remote sources. For more on error reconciliation, check the data synchronization section below.

Example: Read a list of topics

A list of Topics can be obtained by subscribing to TopicsRepository::getTopics flow which emits List<Topic>.

Whenever the list of topics changes (for example, when a new topic is added), the updated List<Topic> is emitted into the stream.

Writing data

To write data, the repository provides suspend functions. It is up to the caller to ensure that their execution is suitably scoped.

Example: Follow a topic

Simply call UserDataRepository.toggleFollowedTopicId with the ID of the topic the user wishes to follow and followed=true to indicate that the topic should be followed (use false to unfollow a topic).

Data sources

A repository may depend on one or more data sources. For example, the OfflineFirstTopicsRepository depends on the following data sources:

Name Backed by Purpose
TopicsDao Room/SQLite Persistent relational data associated with Topics
NiaPreferencesDataSource Proto DataStore Persistent unstructured data associated with user preferences, specifically which Topics the user is interested in. This is defined and modeled in a .proto file, using the protobuf syntax.
NiaNetworkDataSource Remote API accessed using Retrofit Data for topics, provided through REST API endpoints as JSON.

Data synchronization

Repositories are responsible for reconciling data in local storage with remote sources. Once data is obtained from a remote data source it is immediately written to local storage. The updated data is emitted from local storage (Room) into the relevant data stream and received by any listening clients.

This approach ensures that the read and write concerns of the app are separate and do not interfere with each other.

In the case of errors during data synchronization, an exponential backoff strategy is employed. This is delegated to WorkManager via the SyncWorker, an implementation of the Synchronizer interface.

See the OfflineFirstNewsRepository.syncWith for an example of data synchronization.

Domain layer

The domain layer contains use cases. These are classes which have a single invocable method (operator fun invoke) containing business logic.

These use cases are used to simplify and remove duplicate logic from ViewModels. They typically combine and transform data from repositories.

For example, GetUserNewsResourcesUseCase combines a stream (implemented using Flow) of NewsResources from a NewsRepository with a stream of UserData objects from a UserDataRepository to create a stream of UserNewsResources. This stream is used by various ViewModels to display news resources on screen with their bookmarked state.

Notably, the domain layer in Now in Android does not (for now) contain any use cases for event handling. Events are handled by the UI layer calling methods on repositories directly.

UI Layer

The UI layer comprises:

The ViewModels receive streams of data from use cases and repositories, and transforms them into UI state. The UI elements reflect this state, and provide ways for the user to interact with the app. These interactions are passed as events to the ViewModel where they are processed.

\"Diagram

Modeling UI state

UI state is modeled as a sealed hierarchy using interfaces and immutable data classes. State objects are only ever emitted through the transform of data streams. This approach ensures that:

Example: News feed on For You screen

The feed (a list) of news resources on the For You screen is modeled using NewsFeedUiState. This is a sealed interface which creates a hierarchy of two possible states:

The feedState is passed to the ForYouScreen composable, which handles both of these states.

Transforming streams into UI state

ViewModels receive streams of data as cold flows from one or more use cases or repositories. These are combined together, or simply mapped, to produce a single flow of UI state. This single flow is then converted to a hot flow using stateIn. The conversion to a state flow enables UI elements to read the last known state from the flow.

Example: Displaying followed topics

The InterestsViewModel exposes uiState as a StateFlow<InterestsUiState>. This hot flow is created by obtaining the cold flow of List<FollowableTopic> provided by GetFollowableTopicsUseCase. Each time a new list is emitted, it is converted into an InterestsUiState.Interests state which is exposed to the UI.

Processing user interactions

User actions are communicated from UI elements to ViewModels using regular method invocations. These methods are passed to the UI elements as lambda expressions.

Example: Following a topic

The InterestsScreen takes a lambda expression named followTopic which is supplied from InterestsViewModel.followTopic. Each time the user taps on a topic to follow this method is called. The ViewModel then processes this action by informing the user data repository.

Further reading

Guide to app architecture

Jetpack Compose

", "url": "https://hunga1ok.github.io/blog/2023/06/26/architecture-learning-journey", "tags": ["android","architecture"], "date_published": "2023-06-26T00:00:00+02:00", "date_modified": "2023-06-26T00:00:00+02:00", "author": { "name": "hunga1ok", "url": null, "avatar": null } }, { "id": "https://hunga1ok.github.io/blog/2022/05/12/simple-date-format", "title": "How to create a SimpleDateFormat", "summary": "Create a SimpleDateFormat is so easy ^^", "content_text": "SimpleDateFormat Table content for reference: Letter Date or Time Component Presentation Examples G Era designator Text AD y Year Year 1996; 96 Y Week year Year 2009; 09 M Month in year Month July; Jul; 07 w Week in year Number 27 W Week in month Number 2 D Day in year Number 189 d Day in month Number 10 F Day of week in month Number 2 E Day name in week Text Tuesday; Tue u Day number of week (1 = Monday, …, 7 = Sunday) Number 1 a Am/pm marker Text PM H Hour in day (0-23) Number 0 k Hour in day (1-24) Number 24 K Hour in am/pm (0-11) Number 0 h Hour in am/pm (1-12) Number 12 m Minute in hour Number 30 s Second in minute Number 55 S Millisecond Number 978 z Time zone General time zone Pacific Standard Time; PST; GMT-08:00 Z Time zone RFC 822 time zone -0800 X Time zone ISO 8601 time zone -08; -0800; -08:00 ##Some code extensions kotlin: I use JodaTime library for support handle featuresfun String?.formatHour(toPattern: String) = formatHour(\"HH:mm:ss\", toPattern)fun String?.formatHour(fromPattern: String, toPattern: String): String { if (this == null) return \"\" return try { DateTime.parse(this, DateTimeFormat.forPattern(fromPattern)).toString(toPattern) } catch (e: Exception) { \"Invalid Date\" }}fun String?.formatDate(toPattern: String): String { if (this == null) return \"\" return try { DateTime(this).toString(toPattern) } catch (e: Exception) { \"Invalid Date\" }}fun String?.formatDate(fromPattern: String, toPattern: String): String { if (this == null) return \"\" return try { DateTime.parse(this, DateTimeFormat.forPattern(fromPattern)).toString(toPattern) } catch (e: Exception) { \"Invalid Date\" }}fun String?.parseDate(pattern: String? = null): DateTime? { if (this == null) return null return try { pattern?.let { DateTime.parse(this, DateTimeFormat.forPattern(pattern)) } ?: DateTime(this) } catch (e: Exception) { null }}", "content_html": "

SimpleDateFormat

Table content for reference:

Letter Date or Time Component Presentation Examples
G Era designator Text AD
y Year Year 1996; 96
Y Week year Year 2009; 09
M Month in year Month July; Jul; 07
w Week in year Number 27
W Week in month Number 2
D Day in year Number 189
d Day in month Number 10
F Day of week in month Number 2
E Day name in week Text Tuesday; Tue
u Day number of week (1 = Monday, …, 7 = Sunday) Number 1
a Am/pm marker Text PM
H Hour in day (0-23) Number 0
k Hour in day (1-24) Number 24
K Hour in am/pm (0-11) Number 0
h Hour in am/pm (1-12) Number 12
m Minute in hour Number 30
s Second in minute Number 55
S Millisecond Number 978
z Time zone General time zone Pacific Standard Time; PST; GMT-08:00
Z Time zone RFC 822 time zone -0800
X Time zone ISO 8601 time zone -08; -0800; -08:00

##Some code extensions kotlin:

I use JodaTime library for support handle features

fun String?.formatHour(toPattern: String) = formatHour(\"HH:mm:ss\", toPattern)fun String?.formatHour(fromPattern: String, toPattern: String): String {    if (this == null) return \"\"    return try {        DateTime.parse(this, DateTimeFormat.forPattern(fromPattern)).toString(toPattern)    } catch (e: Exception) {        \"Invalid Date\"    }}fun String?.formatDate(toPattern: String): String {    if (this == null) return \"\"    return try {        DateTime(this).toString(toPattern)    } catch (e: Exception) {        \"Invalid Date\"    }}fun String?.formatDate(fromPattern: String, toPattern: String): String {    if (this == null) return \"\"    return try {        DateTime.parse(this, DateTimeFormat.forPattern(fromPattern)).toString(toPattern)    } catch (e: Exception) {        \"Invalid Date\"    }}fun String?.parseDate(pattern: String? = null): DateTime? {    if (this == null) return null    return try {        pattern?.let { DateTime.parse(this, DateTimeFormat.forPattern(pattern)) } ?: DateTime(this)    } catch (e: Exception) {        null    }}
", "url": "https://hunga1ok.github.io/blog/2022/05/12/simple-date-format", "tags": ["android","coding"], "date_published": "2022-05-12T00:00:00+02:00", "date_modified": "2022-05-12T00:00:00+02:00", "author": { "name": "hunga1ok", "url": null, "avatar": null } }, { "id": "https://hunga1ok.github.io/blog/2022/05/05/android-roadmap", "title": "Android Developer Roadmap", "summary": "This is a roadmap for android developer for beginners", "content_text": " A complete roadmap to learn Android App Development. This roadmap will help you in becoming a complete Android Developer.Roadmap to learn Android App Development Programming Java Kotlin Android Studio Android Studio IDE Overview Project Structure \t * Java/Kotlin \t * XML \t * .gradle files Android Component Activity Activity Lifecycle Tasks & Back Stack Service Broadcast Receiver Content Provider Intents Types of Intent Implicit Explicit Intent Filter Static User Interface View Button, ImageView, TextView, EditText etc ViewGroup * LinearLayout, RelativeLayout, FrameLayout, ConstraintLayout Dynamic User Interface RecyclerView ViewPager Spinner CustomView Canvas Bitmap Paint UI Resources Drawables String Styles Fragments Fragment Lifecycle Fragment Manager Support User Interface ProgressBar Dialogs Toast & Snackbar Storage Shared Preferences File Systems Database RoomDB Build Gradle Debug / Release Configuration Threading Threads Handler / Looper Debugging Memory profiling Logging Systrace Exceptions Error Handling Memory Leak Detecting and Fixing Memory Leaks Context 3rd Party Library Image Loading Glide Picasso Dependency Injection Dagger Networking Fast Android Networking Library Retrofit MultiThreading RxJava Coroutines Data Format JSON GSON Flat Buffer Protocol Buffer Android Jetpack Foundation Components AppCompat Android KTX Multidex Architecture Components LiveData ViewModel DataBinding Paging Work Manager Navigation Behaviour Components Download Manager Media Playback Notification Permissions Preference Sharing Slice UI Component Animation & Transition Android Auto Emoji Palette Android TV Android Wear Architecture MVVM MVI MVP Unit Testing\t * Local Unit Testing\t * Instrumentation Testing Firebase FCM Crashlytics Analytics Remote Config App Indexing Dynamic Link Security Encrypt / Decrypt Proguard R8 App Release .keystore file App Bundle Playstore Keep Learning and Improving", "content_html": "

A complete roadmap to learn Android App Development. This roadmap will help you in becoming a complete Android Developer.

\"Android

Roadmap to learn Android App Development

", "url": "https://hunga1ok.github.io/blog/2022/05/05/android-roadmap", "tags": ["android","coding"], "date_published": "2022-05-05T00:00:00+02:00", "date_modified": "2022-05-05T00:00:00+02:00", "author": { "name": "hunga1ok", "url": null, "avatar": null } } ] }