DEV Community: Hossain Khan

Fixing GitHub Coding Agent’s Firewall Issue for Android Projects

Hossain Khan — Sun, 03 Aug 2025 04:19:23 +0000

Ever since GitHub coding agent is released, I have been big fan of async agentic work. I have been primarily working and Android projects and one of the issue constantly bothering me was the Gradle build issue.

Everyone agent goes off to work, it almost always encounters this issue:

* What went wrong:
Plugin [id: 'com.android.application', version: '8.12.0', apply: false] was not found in any of the following sources:

- Gradle Core Plugins (plugin is not in 'org.gradle' namespace)
- Included Builds (No included builds contain this plugin)
- Plugin Repositories (could not resolve plugin artifact 'com.android.application:com.android.application.gradle.plugin:8.12.0')
  Searched in the following repositories:
    Google
    MavenRepo
    Gradle Central Plugin Repository

BUILD FAILED in 29s

In the PR that is created by agent you will see something like:

 <summary>Firewall rules blocked me from connecting to one or more addresses</summary>

 #### I tried to connect to the following addresses, but was blocked by firewall rules:

 - `developer.android.com`
   - Triggering command: `curl -s REDACTED` (dns block)
 - `dl.google.com`
   - Triggering command: `/usr/lib/jvm/temurin-17-jdk-amd64/bin/java --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.prefs/java.util.prefs=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.prefs/java.util.prefs=ALL-UNNAMED --add-opens=java.base/java.nio.charset=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.xml/javax.xml.namespace=ALL-UNNAMED -Xmx2048m -Dfile.encoding=UTF-8 -Duser.country -Duser.language=en -Duser.variant -cp /home/REDACTED/.gradle/wrapper/dists/gradle-8.14.3-bin/cv11ve7ro1n3o1j4so8xd9n66/gradle-8.14.3/lib/gradle-daemon-main-8.14.3.jar -javaagent:/home/REDACTED/.gradle/wrapper/dists/gradle-8.14.3-bin/cv11ve7ro1n3o1j4so8xd9n66/gradle-8.14.3/lib/agents/gradle-instrumentation-agent-8.14.3.jar org.gradle.launcher.daemon.bootstrap.GradleDaemon 8.14.3` (dns block)

 If you need me to access, download, or install something from one of these locations, you can either:

 - Configure [Actions setup steps](https://gh.io/copilot/actions-setup-steps) to set up my environment, which run before the firewall is enabled
 - Add the appropriate URLs or hosts to the custom allowlist in this repository's [Copilot coding agent settings](https://github.com/hossain-khan/android-compose-app-template/settings/copilot/coding_agent) (admins only)

Here is a preview of how it looks on your PR!

Preview when firewall blocks connection to Google’s maven repo

The fix is as simple as reading the warning with patience and follow the link to agent settings in the GitHub repo. Once you go to settings, you just have to add the domains you want to whitelist. Here is screenshot of those steps for reference.

Go to Coding Agent settings and click “Custom allowlist”

Finally add the domain that you want to whitelist / allow

That’s it, next time the agent runs, it should be able to continue with Gradle build system that depends on google maven repo or Gradle plugin artifacts that are hosted at Google domains.

Related resources

https://docs.github.com/en/copilot/how-tos/use-copilot-agents/coding-agent/customize-the-agent-firewall

‘Vibe Coding’ to ‘Blind Coding’

Hossain Khan — Wed, 11 Jun 2025 04:37:07 +0000

TL;DR: I let AI write a JSON5 parser for me using just test cases and vibes. No deep knowledge, just TDD and Agentic AIs. Shockingly, it worked!

Can you be irresponsibly responsible? ^_^

That was the experiment I wanted to do with a plethora of Agentic AI available for code assist.

I am sure I don’t need to define Vibe Coding to you — but, what is “Blind Coding” you ask!? I think you have guessed it by now — It’s about almost blindly accepting AI-generated code.

Sounds very irresponsible, right? But there is a twist and that is part of my experiment 🧪

I wanted to explore if I could do TDD (Test Driven Development) with AI on a topic with minimal understanding of what the suggested code does.
However, I would have a very good understanding of expected input & output such that I can have well-defined test cases that I can feed AI Agents to work with.

Test Subject — Build a JSON5 Parser

For this experiment I chose JSON5 that I recently came across. This is an extension of JSON with the option to add comment and more, making it suitable for configuration definitions (like YAML).

Since JSON5 has a well-defined grammar and specification, it would be easy for me to point to those and build a library that parses JSON5 files using Kotlin language.

Results First 📊

Before I dive deep into the ‘Blind Coding’ strategy, let me reveal what was achieved first using LLM based Agentic AI 🤖

Fully functional JSON5 de/serializer of Kotlin Data classes using kotlinx.serialization
Fully functional JSON5 parser that complies with specification and provides parsed data

Here is benchmark of generated library vs two relevant contender 💪

JSON5-AI — AI generated library built with ‘Blind Coding’
kotlinx.serialization — JetBrains library used only for JSON serialization and deserialization. Which has less complexity compared to JSON5.
Syntaxerror’sJSON5 Java Library — an actively maintained implementation of JSON5. Marked as ‘3P-External-JSON5’ in the chart below.

Total processing time by library

Total time spent for each test category

Regardless of the generated library being ~4x and ~1.5x less performant compared to kotlinx.serialization and Syntaxerror’s Java library respectively, the experiment is a ✅ success in my book! Because it’s functional and has very acceptable performance for initial phase.

If you are interested to look under the hood, take a look into lib module in this GitHub project.

GitHub - hossain-khan/json5-kotlin: JSON5 implementation for Kotlin/JVM

Behind the Scenes

Believe it or not, JSON5 has been around since 2012 and has all the implementation details and specification on their GitHub repos (https://github.com/json5).

All I had to do was import their JavaScript based implementation and specification and iteratively ask agents to build functionalities.

⏳ How long did it take to build the JSON5 library?

About 4 days of weekend and after work sessions (roughly 10–12 hours)

😅 Was there challenges along the way?

Yes, some of the parsing tests were failing and agent was repeatedly failing to fix it. I almost lost hope. Then GitHub Copilot Agent rescued me.

🤖 What are the Agents that were used to achieve this?

Claude Sonnet 3.7 (Agent Mode — IDE integration)
GPT 4.1 (Agent Mode — IDE integration)
Google Jules (async agent)
GitHub Copilot Agent (async agent — used for majority of the project)

🎉 So, what’s the verdict?

I had absolute blast just watching agents do magical stuff that I couldn’t have done by myself. Even the benchmarking solution was build by Agent.

Seeing the benchmark result also gave me hope and sense of accomplishment. Sure, I might not be able to build the next Dagger, or OkHttp or anything of that sort, however anything simple should clearly be within reach with the limited time we have in our lives. That is a huge win for me! 🏆

Now, on to something more useful! 🤓 Feel free to reach out or ask question. Cheers! ✌🏽

Using AI to build modern Android apps — are we there yet?

Hossain Khan — Tue, 18 Feb 2025 13:55:04 +0000

Using AI to build modern Android apps — are we there yet?

Building is more fun with AI 🤖

I’ve had my GitHub Copilot subscription for over a year now, but I haven’t leveraged the service until very recently I decided to build some tools and Android apps using it.

I have extensively used ChatGPT 4o & o1, Google Gemini, and Claude Sonnet to build an app related to weather even though I am very aware of the following phrase:

“If all you have is a hammer, everything looks like a nail.”

The Rationale Behind the App

You get many amazing things living in Canada, one of them is snow in winter. After moving to a home, I needed a way for me to be better prepared for snow days where I have to clean my driveway and potentially neighbour’s if the snowblower has enough charge.

So, I saw a “nail” that I can hammer, I built a single purpose Android app that notifies me if there will be enough snow, a threshold set by me. This allows me to make sure I charge the snowblower batteries and park the cars inside the garage. Profit!

Sure, there are some outstanding weather apps including Google’s own that can provide similar info, however the tinkering engineer wants to use the hammer! 😂

The AI Code Assist Experience

It’s been absolutely fun working with AI to come up with solutions, in this case the Compose UI Screens, Presenters, and unit tests for them. From my experience, the LLM provided solution are 80–98% correct and can just be copy pasted with some imports to fix. Sometimes I do have to refactor or move things around, but it gets me 80% there and I just finish the last 20% to make a finished app screen.

I feel like, this will be an essential tool for all kinds of engineers to reduce the cognitive load and iterate on the products they want to build.

Is the AI/LLM Ready to Print Out Full App?

Short answer, NO (based on my experience).

I have encountered some YouTube videos where they showcase building beautiful iOS apps using LLMs. It’s possible that I was not a good prompt engineer or GitHub Copilot is not the right product to build fully functional app.

Another limitation I noticed is, when asked to build full app, the LLM is likely limited by the length of response (tokens), so it responds in shorter chunks for each component of the app and does not provide fully detailed implementation. When asked in smaller chunks with specific steps, it can provide detailed code.

It might get there soon enough. Or, maybe if we use multi-modal LLM and provide fully designed mocks of the app, it will be able to build it.

Regardless, I am very happy to use LLM and learn from it through the process of building small apps.

The Learning Opportunity

One of the best part of leveraging AI and looking at the response is that you get to learn new function, tools and so on.

Along the way building the app, I got to 🧑‍💻 exercise my knowledge, learn and grow. Here are some of the cool stuff I have done while building the app

Extensively leverage AI powered code assist, namely GitHub Copilot, ChatGPT, Google Gemini 🤖. I think more than 50% of the code is done by AI.
Learn ⚡ Circuit, a modern Android app architecture from Slack (that’s what we also use at Slack)
Use Jetpack Room database for app, and also the SQLite (Kotlin Multiplatform) library for bundling city database used in the app
Jetpack Compose for building modern UI that follows Material 3 guidelines with dark and light mode support
Go through lengthy Google Play publishing process 😅
And all the other usual suspects like Retrofit, OkHttp, Dagger Anvil, Moshi, Firebase and more.

Here is the app that is available on GitHub

GitHub - hossain-khan/android-weather-alert: A simple app to provide configured weather alert so that you are ready for next hour or day! Built using Android Jetpack Compose and Circuit UDF.

It’s also available on Google Play, if the use-case mentioned talks to you :-)

Android remote logging to Airtable using Timber

Hossain Khan — Tue, 10 Sep 2024 04:03:01 +0000

Have you ever needed to save your Android Logcat logs for later analysis?

I recently built a service-based Android app, and I needed to monitor its activity to validate its correctness. For that I could not sit in front of the computer monitor for 24+ hours, I needed a way to store the logs with app behavior to validate it’s performing as it should.

I leveraged the following 2 tools to accomplish this task

Timber: A logger with a small, extensible API which provides utility on top of Android’s normal Log class.
Airtable: Airtable is a hybrid solution that mixes the intuitiveness of spreadsheets and the power and functionalities of databases.

Airtable service can be replaced by any other similar service that allows REST API to add records that can be viewed online.

Why Airtable?

It provides an easy interface to view data in a spreadsheet-like experience.
It has REST API to easily add data from Android app.

If you are not familiar with the amazing Android Timber library, I suggest you spend a few minutes reading the documentation. We will be building an AirtableLoggingTree that sends all the logs logged via Timber to the Airtable spreadsheet/database using their REST API.

Here are some pseudo task we need to accomplish this

Save all the logs to a queue to process and send to REST API
Format the logs and send a batched request (to avoid rate limit)
Make the REST call based on API specification for creating a record.

First, let’s build a Kotlin data class to capture some log info that should be sent to Airtable.

data class LogMessage(
    val priority: Int,
    val tag: String?,
    val message: String,
    val throwable: Throwable?,
    val logTime: Instant = Instant.now(),
    val device: String = Build.MODEL,
)

Next, let’s create the AirtableLoggingTree that queues the logs and sends logs in batches using REST API via OkHttp client.

💁Inline comments have been added where applicable.

class AirtableLoggingTree(
    // Create your token from https://airtable.com/create/tokens
    private val authToken: String,
    // Example: https://api.airtable.com/v0/appXXXXXXXXX/Table%20Name
    private val endpointUrl: String,
) : Timber.Tree() {
    private val client = OkHttpClient()
    private val logQueue = ConcurrentLinkedQueue<LogMessage>()
    private var flushJob: Job? = null

    companion object {
        /**
         * The API is limited to 5 requests per second per base.
         */
        private const val MAX_LOG_COUNT_PER_SECOND = 5

        /**
         * The API is limited to 10 records per request.
         * - https://airtable.com/developers/web/api/create-records
         */
        private const val MAX_RECORDS_PER_REQUEST = 10
    }

    init {
        startFlushJob()
    }

    override fun log(priority: Int, tag: String?, message: String, t: Throwable?) {
        // Adds the log to queue for batch processing
        logQueue.add(LogMessage(priority, tag, message, t))

        if (flushJob == null || flushJob?.isCancelled == true) {
            // If there is enough log, it will start sending them 
            startFlushJob()
        }
    }

    private fun startFlushJob() {
        flushJob =
            CoroutineScope(Dispatchers.IO).launch {
                while (isActive) {
                    flushLogs()

                    // Wait long enough before sending next request 
                    // https://airtable.com/developers/web/api/rate-limits
                    delay(1_100L)
                }
            }
    }

    private fun createLogMessage(logs: List<LogMessage>): String? {
        if (logs.isEmpty()) {
            return null
        }

        // Builds the JSON payload structure with multiple messages based on API spec
        val records = JSONArray().apply { logs.forEach { put(it.toLogRecord()) } }
        return JSONObject().apply {
            put("records", records)
        }.toString()
    }

    private fun getMaximumAllowedLogs(): List<LogMessage> {
        val logs = mutableListOf<LogMessage>()
        while (logQueue.isNotEmpty() && logs.size < MAX_RECORDS_PER_REQUEST) {
            val log = logQueue.poll()
            if (log != null) {
                logs.add(log)
            }
        }
        return logs
    }

    private suspend fun flushLogs() {
        var sentLogCount = 0

        // Collects all the queued logs and sends them in batches
        // Based on rate-limit a total of 5x10 = 50 reconds can be sent per second
        while (sentLogCount < MAX_LOG_COUNT_PER_SECOND) {
            val jsonPayload = createLogMessage(getMaximumAllowedLogs())
            if (jsonPayload != null) {
                sendLogToApi(jsonPayload)
                sentLogCount++

                // This delay is added to ensure the order of log is maintained.
                // However, there is no guarantee that the log will be sent in order.
                delay(100L)
            }
        }

        if (logQueue.isEmpty()) {
            flushJob?.cancel()
        }
    }

    // Finally, this is the OkHttp client that sends HTTP POST request to add those log records
    private fun sendLogToApi(logPayloadJson: String) {
        val mediaType = "application/json; charset=utf-8".toMediaTypeOrNull()
        val body = logPayloadJson.toRequestBody(mediaType)
        val request =
            Request.Builder()
                .url(endpointUrl)
                .addHeader("Authorization", "Bearer $authToken")
                .post(body)
                .build()

        client.newCall(request).enqueue(
            object : okhttp3.Callback {
                override fun onFailure(
                    call: okhttp3.Call,
                    e: IOException,
                ) {
                    Timber.e("Failed to send log to API: ${e.localizedMessage}")
                }

                override fun onResponse(
                    call: okhttp3.Call,
                    response: okhttp3.Response,
                ) {
                    response.use { // This ensures the response body is closed
                        if (!response.isSuccessful) {
                            Timber.e(
                                "Log is rejected: HTTP code: ${response.code}, " +
                                    "message: ${response.message}, body: ${response.body?.string()}",
                            )
                        }
                    }
                }
            },
        )
    }
}

Everything is great except there is one piece of missing code that uses the API LogMessage.toLogRecord() in the AirtableLoggingTree. The snipped is shown below for clarity.

val records = JSONArray().apply { logs.forEach { put(it.toLogRecord()) } }

This function implementation will be very specific to how you have setup your Airtable spreadsheet.

For my case, I have two columns for the table in the Airtable base:

"Device" — to store the device model. Single-line text.
"Log" — to store the log message. Multiline text.

fun toLogRecord(): JSONObject {
    val logMessage =
        buildString {
            append("Priority: ${priority}\n")
            if (tag != null) append("Tag: $tag\n")
            append("Message: $message\n")
            if (throwable != null) append("Throwable: ${throwable.localizedMessage}")
            append("App Version: ${BuildConfig.VERSION_NAME}\n")
            append("Log Time: ${logTime}\n")
        }

    val fields =
        JSONObject().apply {
            put("Device", device)
            put("Log", logMessage)
        }
    return JSONObject().apply {
        put("fields", fields)
    }
}

You could essentially have multiple columns for each of the properties.

✅ And that’s it. You have a working Timber tree that can send all logcat logs to the Airtable base (spreadsheet) that adheres to their API rate limit.

See it in action

You can take a look at the fully implemented tree in the following project

GitHub - hossain-khan/android-keep-alive: A simple app to keep alive specific apps

Here is a screenshot of how the log looks in the Airtable

Demo of remotly logged messages in the Airtable

How to update a Docker Container using Portainer

Hossain Khan — Sat, 10 Aug 2024 20:30:52 +0000

ℹ️ This is part of the self-learning log as I explore Docker and Portainer.

Recently, I have been playing with Portainer — a Container Management system for Docker. Because of my curiosity, I constantly try different containers for different solutions and sometimes stick to some useful apps.

Once in a while, I keep seeing Docker containerized app notification that there is an update available. However, It was tricky for me to figure out how to update the container using Portainer. It turns out, it’s as simple as just pressing edit container and update container image. Here is a visual guide for my future self :-)

Updating Docker Container

First, go to your list of containers and select the container that needs to be updated.

Select “Duplicate/Edit” option.

Once you select “Edit”, you will have option for container image version.

Select the container image version here.

In the “Image” section you can specify the version or keep latest or stable to get the latest image based on the container you are using. If you are unsure, go to the docker hub or source of the container to get the exact tag.

Finally, click on the “Deploy the container”.

Once done, deployment will trigger the image update.

This will pull the latest image and re-deploy the container with latest image.

⚠️ A few important caveats to keep in mind

This assumes that the container configuration is persisted in the host machine, so that when it redeploys it will be able to resume from where you left off with the container app.
Downgrading may have unintended consequences.
Always look at the project/app documentation on upgrading if there is something special that needs to be done to migrate your app.

Using SQLDelight 2.0 with PostgreSQL for JVM

Hossain Khan — Wed, 06 Sep 2023 23:06:26 +0000

Recently I wanted to do some experiments with saving JSON data into a database and found out that PostgreSQL supports JSON as a data type.

I also wanted to use the fantastic SQLDelight library that creates type-safe models and queries for any database (it’s also multi-platform supported).

While trying to follow the recently released SQLDelight 2.0 guide, I stumbled into missing pieces to make the PostgreSQL work with it.

In this post, I will try to fill in the gaps and build a sample project showcasing both working together ✌️

PostgreSQL and SQLDelight. Source: https://kinsta.com/

A few of the missing pieces that I had to figure out were:

Create DataSource (“hikari” or other connection managers were mentioned in the guide)
Using HikariCP as data source to connect to PostgreSQL
Write all the glue pieces to use the SQLDelight code to perform CRUD operations on the PostgreSQL Database

Use HikariCP to create PostgreSQL DataSource

First import the hikari and PostgreSQL library into your JVM project

// https://github.com/brettwooldridge/HikariCP#artifacts
implementation("com.zaxxer:HikariCP:5.0.1")

// This is needed for the PostgreSQL driver
// https://mvnrepository.com/artifact/org.postgresql/postgresql
implementation("org.postgresql:postgresql:42.6.0")

Then you need to build the HikariConfig with the right data set to connect to the database and then create the HikariDataSource which is what is needed for the SQLDelight

Here is a snippet taken from the sample project

/**
 * Creates a [DataSource] using [HikariDataSource].
 */
private fun getDataSource(): DataSource {
    // https://jdbc.postgresql.org/documentation/use/
    val config = HikariConfig().apply {
        jdbcUrl = "jdbc:postgresql://localhost:5432/dbname"
        driverClassName = "org.postgresql.Driver"
        username = "dbusername"
        password = "dbpassword"
        maximumPoolSize = 3
        isAutoCommit = false
        transactionIsolation = "TRANSACTION_REPEATABLE_READ"
        validate()
    }
    return HikariDataSource(config)
}

That’s it, now you can follow the official SQLDelight guide on creating databse to create tables and do CRUD operations.

For example, here is a simplified snippet to give the whole picture

val dataSource: DataSource = getDataSource(appConfig)

val driver: SqlDriver = dataSource.asJdbcDriver()

// NOTE: The `SportsDatabase` and `PlayerQueries` are from SQLDelight
val database = SportsDatabase(driver)
val playerQueries: PlayerQueries = database.playerQueries

val hockeyPlayers = playerQueries.selectAll().executeAsList()
println("Existing ${hockeyPlayers.size} records: $hockeyPlayers")
// Prints following 👇
// - - - - - - - - - -
// Existing 15 records: 
// [HockeyPlayer(player_number=10, full_name=Corey Perry), ...]

The full snippet is available here.

See the GitHub project for a complete example with gradle dependencies and SQLDelight configuration needed to make it work.

GitHub - hossain-khan/SQLDelight-PostgreSQL-JVM-sample: A sample project exercising PostgreSQL with SQLDelight 2.0

Happy to hear feedback or any corrections to do this in a better way.

EDIT: After I wrote the article, I found similar article about it (which could have saved me ton of time), so do take a look at it too 😊

SQLDelight for PostgreSQL on Kotlin JVM

Kotlin coroutines error handling strategy — `runCatching` and `Result` class

Hossain Khan — Sun, 02 May 2021 20:45:33 +0000

Kotlin coroutines error handling strategy — `runCatching` and `Result` class

I am trying to learn Kotlin coroutines, and was trying to learn more about how to handle errors from suspended functions. One of the recommended way by Google is to create a “Result” class like the following:

sealed class Result<out R> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
}

This allows us to take advantage of Kotlin’s when like following:

when (result) {  
 is Result.Success<LoginResponse> -> // Happy path  
 else -> // Show error in UI  
}

However, I have recently stumbled into Kotlin’s runCathing {} API that makes use of Result class available in standard lib since 1.3

Here I will try to explore how the native API can replace the recommended example in the Android Kotlin training guide for simple use cases.

Here is a basic idea of how runCatching {} can be used from Android ViewModel.

Based on Kotlin standard lib doc, you can use runCatching { } in 2 different ways. I will focus on one of them, since the concept for other one is similar.

To handle a function that may throw an exception in coroutines or regular function use this:

val statusResult: Result<String> = runCatching {
    // function that may throw exception that needs to be handled
    repository.userStatusNetworkRequest(username)
}.onSuccess { status: String -> 
  println("User status is: $status")
}.onFailure { error: Throwable ->  
  println("Go network error: ${error.message}")
}

// Assuming following supposed* long running network API
suspend fun userStatusNetworkRequest(username: String) = "ACTIVE"

Notice the ‘Result’ returned from the runCatching this is where the power comes in to write semantic code to handle errors.

The onSuccess and onFailrue callback is part of Result class that allows you to easily handle both cases.

How to handle Exceptions

In addition to nice callbacks, the Result class provides multiple ways to recover from the error and provide a default value or fallback options.

Using getOrDefault() and getOrNull() API

val status: String = statusResult.getOrDefault("STATUS_UNKNOWN")

// Or if nullable data is acceptable use:
val status: String? = statusResult.getOrNull()

Since the onSuccess and onFailure returns Result you can chain most of these API calls like following

val status: String = runCatching { 
  repository.userStatusNetworkRequest("username")
}
.onSuccess {}
.onFailure {}
.getOrDefault("STATUS_UNKNOWN")

2. Using recover { } API

The recover API allows you to handle the error and recover from there with a fallback value of the same data type. See the following example.

val status: Result<String> = runCatching { 
  repository.userStatusNetworkRequest("username")
}
.onSuccess {}
.onFailure {}
.recover { error: Throwable -> "STATUS_UNKNOWN" }  

println(status.isSuccess) // Prints "true" when error is received

3. Using fold {} API to map data

The fold extension function allows you to map the error to a different data type you wish. In this example, I kept the user status as String.

val status: String = runCatching {
  repository.userStatusNetworkRequest("username")
} 
.onSuccess {} 
.onFailure {} 
.fold(
    onSuccess = { status: String -> status },
    onFailure = { error: Throwable -> "STATUS_UNKNOWN" } 
)

Aside from these, there are some additional useful functions and extension functions for Result , take a look at official documentation for more APIs.

I hope this was useful or a new discovery for you as it was for me 😊

Source code syntax highlighting on Android — Taking full control

Hossain Khan — Sat, 18 Jul 2020 22:13:00 +0000

Source code syntax highlighting on Android — Taking full control

Android and it’s community has evolved a lot over past decade. Now a days we can find open-source libraries to do almost anything — Zoomable ImageView, CameraX, RecyclerView Sticky Header, Tooltip, and many more.

Photo by Shahadat Rahman on Unsplash

Syntax highlighting is one of them and there are few libraries for that too. If this is a solved problem, then why am I writing about another solution then?

Well, some of the libraries I have explored are outdated, and some of them might not be as feature rich. So, I wanted to explore how to do-it-myself and write about it so that anybody can take full advantage of well-know JavaScript libraries for syntax highlighting in their Android app.

👍 Pros

Complete control over how JS plugin is used in the app
Complete control over the Android code that renders it using WebView

👎 Cons

You need to have some understanding of web technologies, namely HTML, CSS and JavaScript
You need to build your own Android CustomView or Fragment to render highlighted syntax. (No worries — this is where this article comes in to help you do that _🤗)_

With the pros and cons in mind, lets explore some well-established and proven syntax highlighting libraries

PrismJS — Very light weight 2KB-100+KB with extensive plugin collection “Lightweight, robust, elegant syntax highlighting.”
highlight.js — Fully loaded 25KB-100KB and simple syntax highlighting “Syntax highlighting for the Web”
Rainbow — Another popular lightweight 6KB-25KB highlighter “Rainbow is a code syntax highlighting library written in Javascript.”

There are many more libraries that does the job, however for rest of the example I will be using PrismJS because of it’s highly modular nature. Note that, the process of using different library will be almost the same.

💡 TIP: All the example code provided here is available in great detail in the GitHub repository mentioned below👇.

Setting up PrismJS Template

We will be leveraging Android’sWebView to load syntax highlighting library with the source code that we want to be highlighted.

This setup is going to be specific to library of your choice. Since we are focusing on PrimsJS, we will follow it’s official guideline.

After you download the library JS and CSS file, you essentially need following HTML to render the highlighted source.

<!DOCTYPE html>
<html>
  <head>
    <link href="themes/prism.css" rel="stylesheet" />
    <script src="prism.js"></script>
  </head>
  <body>
    <pre><code class="language-kotlin">
    data class Student(val name: String)
    </code></pre>
  </body>
</html>

TIP: You can download different CSS theme, and you can choose list of language and plugin you want to support (eg. Kotlin, Show line number)

Put the downloaded files in your Android app’s assets directory, ideally in www subfolder, like — src/main/assets/www/

Now that we have a baseline for the template, next part is to convert it to Kotlin function that can take additional parameter to customize different plugin options. Here is template with some additional data needed for mobile.

fun prismJsHtmlContent (
    formattedSourceCode: String,
    language: String,
    showLineNumbers: Boolean = true
): String {
    return """<!DOCTYPE html>
<html>
<head>
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <link href="www/prism.css" rel="stylesheet"/>
    <script src="www/prism.js"></script>
</head>
<body>
<pre class="${if ( showLineNumbers ) "line-numbers" else ""}">
<code class="language-${language}">${formattedSourceCode}</code>
</pre>
</body>
</html>
"""
}

Defining Syntax Highlighting Custom-View

Making your own custom view is a great way to enhance capabilities. In this case we want to make our custom-view extend from WebView so that we can load the template we just defined with source code at runtime.

package your.app.code

class SyntaxHighlighterWebView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : WebView (context, attrs, defStyleAttr) {
    companion object {
        private const val ANDROID_ASSETS_PATH = "file:///android_asset/"
    }

  // Our exposed function to show highlighted syntax
  fun bindSyntaxHighlighter (
        formattedSourceCode: String,
        language: String,
        showLineNumbers: Boolean = false
    ) {
        settings.javaScriptEnabled = true

         loadDataWithBaseURL(
            ANDROID_ASSETS_PATH /* baseUrl */,
            prismJsHtmlContent (
               formattedSourceCode, 
               language, 
               showLineNumbers
            ) /* html-data */,
            "text/html" /* mimeType */,
            "utf-8" /* encoding */,
            "" /* failUrl */
        )
    }
}

Using the Custom-View in App

Now that we have our SyntaxHighlighterWebView custom-view with bindSyntaxHighlighter() function, we can use it from Activity or Fragment layout.

All we need to do is use the view in XML layout like following:

<your.app.code.SyntaxHighlighterWebView
  android:id="@+id/syntax_highlighter_webview"
  android:layout_width="match_parent"
  android:layout_height="match_parent" />

And from your Activity or Fragment get reference to the view and bind the source code like following

val highlighter: SyntaxHighlighterWebView = findViewById(R.id.syntax_highlighter_webview)

highlighter.bindSyntaxHighlighter(
   formattedSourceCode = "data class Student(val name: String)",
   language = "kotlin",
   showLineNumbers = true
)

Highlighted Syntax Loaded via SyntaxHighlighterWebView

That’s it, once you load the app you should see highlighted syntax on the screen where you have put the custom-view.

All the example source code provided here is available in following GitHub repository. As bonus, I have also provided example of how to use highlight.js too.

If you find any issue, leave a comment here or report an issue at GitHub repository. Hope it helps somebody. ✌️

amardeshbd/android-syntax-highlighter

Set of screenshots taken from the demo app

Setup Android Gradle based Firebase App Distribution with GitHub Actions CI

Hossain Khan — Tue, 16 Jun 2020 12:50:37 +0000

Setup Android Gradle based Firebase App Distribution with Github Actions CI

This is a quick guide on how you can easily set up Github Actions CI workflow to automatically post APK to Firebase App Distribution on merge to release or master (or soon to be known as main) branch.

Firebase already has an excellent guide 🏆 on how to set up the Gradle task on your Android project to post APK to App Distribution. However, I will quickly touch those areas using the easiest path ✌️.

PREREQUISITE : You already have Firebase project setup for the app with google-services.json file in your Android app project.

Setup Gradle for the App

On your root build.gradle file add the Gradle plugin

dependencies {
    // .. other existing deps here
    classpath 'com.google.firebase:firebase-appdistribution-gradle:2.0.0'
}

Next, apply the plugin in your Android app’s build.gradle and distribution properties. See the official guide for the full list of supported parameters.

apply plugin: 'com.google.firebase.appdistribution'

android {
    buildTypes {
        release { // NOTE: `debug` can have different cofigs
            firebaseAppDistribution {
                releaseNotes="Release notes at bit.ly/notes"
                groups="qa" // see docs for more options 
            }
        }
    }
}

Generate Firebase Token

Firebase has 3 different documented ways you can authenticate to be able to upload the APK. Generating the token is one of the easiest that I will focus on with snapshot images so that you can easily relate to it.

From the root of your android app project, run following Gradle command which will give you a URL to authenticate for the Firebase project that app uses.

./gradlew appDistributionLogin

Copy the URL https://accounts.google.com/o/..../auth/cloud-platform and paste it in browser and login with the Google account which has write access to the Firebase project.

Once authorized, you should get FIREBASE_TOKEN in the console. Save it for later use.

Setup Secrets for GitHub CI Workflow

Go to your GitHub project and the FIREBASE_TOKEN as secret property.

Setup GitHub Actions CI Workflow

Based on git-flow, we want to setup the CI job such that whenever we merge commit to master branch it triggers the release build. You can obviously customize the behavior based on your need.

name: Firebase App Distribution

on:
  push:
    branches:
      - master

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2
      - name: set up JDK 1.8
        uses: actions/setup-java@v1
        with:
          java-version: 1.8

      - name: Firebase App Distribute
        env:
          FIREBASE_TOKEN: ${{ secrets.FIREBASE_TOKEN }}
        run: ./gradlew assembleRelease appDistributionUploadRelease

That’s it, you should have a working GitHub workflow that automatically sends APK to Firebase App Distribution as soon as there is a commit on master branch.

See pull-request I made to add support for this in one of my side projects.

If you find any issues please let me know I will try to help. Good luck 👍

Additional Resources

Firebase App Distribution — https://firebase.google.com/docs/app-distribution
GitHub Actions — https://help.github.com/en/actions
Pull Request to support Firebase App Distribution — https://github.com/amardeshbd/android-police-brutality-incidents/pull/117/files

Android app to browse and share incidents during protest for George Floyd

Hossain Khan — Thu, 11 Jun 2020 19:17:30 +0000

In the midst of COVID-19, the past 2 weeks have been horrific from many fronts, especially after the murder of #GeorgeFloyd on May 25h. It gives me hope to see how the issue resonated among Americans and Canadians. It IS time to speak up, to be silent is to be complicit.

As an engineer, I am overwhelmed to see how communities came together both online and offline. One online community that is trying to actively document and preserve all #PoliceBrutality incidents during peaceful protest is on Reddit at r/2020PoliceBrutality/

I also wanted to participate in spreading the words #BlackLivesMatter #JusticeForGeorgeFloyd by making a simple Android app that uses data collected by the subreddit r/2020PoliceBrutality/ community. I hope more people become aware and take smaller actions towards making the world a better place.

Currently, the app is pending approval to be published in Google Play store, however, if you want to test drive it, it's available on GitHub to manually download and install on your phone.

https://github.com/amardeshbd/android-police-brutality-incidents/releases

How to take your beginner Android skills to the next level by studying open-source Android Apps

Hossain Khan — Thu, 02 Apr 2020 03:06:58 +0000

This list of open-source Android apps may come in handy if you have grasped all necessary concepts to develop Android application and you think you are ready to work on an application that follows industry standards. By industry standards, I mean, an app that has good architecture, is scalable and maintainable in the long run.

FYI: Google has an 📚official architecture guide for Android application which captures what most of the sample application does. I highly recommend you read that article first before studying any open-source applications.

⚙️ Android Architecture Blueprints v2

This is Google’s official app that showcases the usage of some of the key Jetpack components to make a sustainable app. This is a good starting point to get an understanding of how to architect an app.

They do have a vanilla implementation in master branch, however, I will focus on dagger-android branch that has dagger support (see README).

Language: Kotlin
Architecture: MVVM
Dependency Injection: Dagger
Navigation: Jetpack Navigation
Unit Tests: JUnit and Espresso
Source: https://github.com/android/architecture-samples

👔 Plaid 2.0 — Showcasing Material Design

In early days Plaid 1.0 application (created in 2014) was Nick Butcher’s app where he showcased how material design and animation can bring joy and life to an Android application. After years of improving, the Plaid app has come to a point where it makes perfect sense to make this app a reference app that showcases how an ideal Android application can be built using material design and fluid animation. So, in 2019, Nick did exactly that, they have moved the Plaid Github repo to Google’s official repository — here is the article explaining the move and goal (I highly recommend to read it).

NOTE: The Plaid 2.0 is still under heavy development, which as a bonus, gives you an opportunity to learn how an application is migrated to modern architecture and Kotlin. See the Github project page with different technical articles explaining how the app is being migrated to 2.0

Key Features: Material Design, Android Theming, Dark Mode, Multi-Module, Animation
Language: Kotlin
Architecture: MVVM
Dependency Injection: Dagger
Navigation: Plain (intent based)
Unit Tests: JUnit and Espresso
Source: https://github.com/android/plaid

🌻 Sunflower — Showcasing Android Jetpack

This is another Google’s official app that showcases many Jetpack components in one application.

This is a minimal application that is great for learning.

Key Features: Dark Mode, Animation, Room (Database), WorkManager
Language: Kotlin
Architecture: MVVM (LiveData, ViewModel, Lifecycle, Data Binding)
Dependency Injection: Dagger
Navigation: Jetpack Navigation (Single Activity)
Unit Tests: JUnit and Espresso
Source: https://github.com/android/sunflower

Sunflower — Demo Screenshots

🔖 CatchUp — All in one

This app aggregates articles and posts from different services like Hackernews, Medium, Reddit, Slashdot, Dribble, Uplabs and so on. This is a very recent app from Zac Sweers who has put a significant amount of time to develop this app. The app architecture is inspired by Plaid and U+2020 app. CatchUp is being actively developed, you can clone and build locally to try it out.

Please note, this is kinda large scale complex application that is well done and contains many advanced techniques. So, if you are a beginner, I would postpone looking into the application towards the end of your study ^_^

ps. I, myself have found this application recently. Personally I like how the Gradle script is organized using Kotlin based Gradle scripts (kts), and how the dagger is used extensively to manage dependencies of different component and service implementations.

Key Features: Dark Mode, Animation, Advanced Dagger,
Language: Kotlin
Architecture: — (Not sure, I need to study this app more)
Dependency Injection: Dagger (Advanced usage)
Navigation: Basic (Intent Based)
Unit Tests: Some JUnit tests exist (not priority).
Source: https://github.com/ZacSweers/CatchUp

CatchUP — Demo Screenshots

Honorable mention

Here are some open-source apps that are worth mentioning:

🎤 Google I/O Annual Conference App

Since 2011 the Google I/O companion application has been the spotlight application by Google that showcases the latest Android features. It recently incorporated Android Wear and Auto variants too.

Historically the source code of the app is released 3–5 months after the conference. Still, it is a great complete application for studying.

Key Features: Multiform factor (Mobile, Tablet, Wear OS, Auto, TV), Firebase, WorkManager, Dark Mode (2019)
Language: Kotlin (2018-2019+), Java (2011–2017)
Architecture: MVVM (2019)
Dependency Injection: Dagger
Navigation: Jetpack Navigation (2019)
Unit Tests: JUnit and Espresso
Source: https://github.com/google/iosched

Google I/O 2019 — Demo Screenshots

📺 Tivi — Track Show Tracking

Tivi app is currently in the early stages developed by Chris Banes, a member of the Android Developer Relations team. He closely works with Nick Butcher, author of Plaid.

The app uses all the latest libraries and recommendations from Google. This app has a very modular structure, almost everything is divided into modules (about 29 modules as of writing). This app will be a good study material when the app goes into the beta stage. Now, it’s too early to recommend as main study material.

Key Features: Dark Mode, Multi-Module, Multi-Service (Trakt, TMDb), Room (Database), RxJava 2
Language: Kotlin
Architecture: MVVM + Lifecycle + LiveData
Dependency Injection: Dagger
Navigation: Jetpack Navigation
Unit Tests: JUnit (Under active development)
Source: https://github.com/chrisbanes/tivi

Tivi — Demo Screenshots

I will continue to extend this article to include more community projects. Feel free to share projects that are ideal for learning. Thanks 🙏

Clickable link text for Android TextView — Kotlin Extension

Hossain Khan — Thu, 02 Jan 2020 00:53:57 +0000

Clickable link text for Android TextView — Kotlin Extension

Recently I have had to create UI that required user tappable/clickable text in the same text view. I know this is kind of unusual as the touch target for the view will likely be smaller compared to a button with no outline style. However, I wanted to share a quick Kotlin extension function that is dynamic and well tested.

Android TextView where “Register Now” is a tappable link with a callback.

Here is an example usage for generating clickable link within the same TextView

So, if your project requires something like this take a look at the following extension function for android.widget.TextView.

You should be able to easily convert this to Java if needed. Let me know if you find this useful. Cheers ✌️

DEV Community: Hossain Khan

Fixing GitHub Coding Agent’s Firewall Issue for Android Projects

‘Vibe Coding’ to ‘Blind Coding’

Test Subject — Build a JSON5 Parser

Results First 📊

Behind the Scenes

Using AI to build modern Android apps — are we there yet?

Using AI to build modern Android apps — are we there yet?

The Rationale Behind the App

The AI Code Assist Experience

Is the AI/LLM Ready to Print Out Full App?

The Learning Opportunity

Android remote logging to Airtable using Timber

Why Airtable?

See it in action

How to update a Docker Container using Portainer

Updating Docker Container

Using SQLDelight 2.0 with PostgreSQL for JVM

Kotlin coroutines error handling strategy — `runCatching` and `Result` class

Kotlin coroutines error handling strategy — runCatching and Result class

How to handle Exceptions

Source code syntax highlighting on Android — Taking full control

Source code syntax highlighting on Android — Taking full control

Setting up PrismJS Template

Defining Syntax Highlighting Custom-View

Using the Custom-View in App

Setup Android Gradle based Firebase App Distribution with GitHub Actions CI

Setup Android Gradle based Firebase App Distribution with Github Actions CI

Setup Gradle for the App

Generate Firebase Token

Setup Secrets for GitHub CI Workflow

Setup GitHub Actions CI Workflow

Additional Resources

Android app to browse and share incidents during protest for George Floyd

How to take your beginner Android skills to the next level by studying open-source Android Apps

⚙️ Android Architecture Blueprints v2

👔 Plaid 2.0 — Showcasing Material Design

🌻 Sunflower — Showcasing Android Jetpack

🔖 CatchUp — All in one

Honorable mention

🎤 Google I/O Annual Conference App

📺 Tivi — Track Show Tracking

Clickable link text for Android TextView — Kotlin Extension

Clickable link text for Android TextView — Kotlin Extension

Kotlin coroutines error handling strategy — `runCatching` and `Result` class