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 💪

1. JSON5-AI — AI generated library built with ‘Blind Coding’
2. kotlinx.serialization — JetBrains library used only for JSON serialization and deserialization. Which has less complexity compared to JSON5.
3. Syntaxerror’s JSON5 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
*JSON5 implementation for Kotlin/JVM. Built by Coding AI Agents.*github.com

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! ✌🏽

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…
A simple app to provide configured weather alert so that you are ready for next hour or day! github.com

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

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

1. Save all the logs to a queue to process and send to REST API

2. Format the logs and send a batched request (to avoid rate limit)

3. 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:

1. "Device" — to store the device model. Single-line text.

2. "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.

Planting your AirtableLoggingTree 🌳

In your app’s application class you can decide when to add the remote logging tree. Here is an example where remote logging is enabled regardless of DEBUG or RELEASE build.

if (BuildConfig.DEBUG) {
    Timber.plant(Timber.DebugTree())
}

// Add your remote logging tree with configs
Timber.plant(
    AirtableLoggingTree(
        authToken = "yourAuthTokenXXXXXXXXXXXXXXXX",
        endpointUrl = "https://api.airtable.com/v0/appXXXXXXXXX/RemoteLogs",
    )
)

✅ 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.

Continue to log using Timber as usual, all logs will be also sent to Airtable

Timber.tag("Cart").d("New item added to cart")

// Log will show in Airtable as follows (based on formatting we used in `toLogRecord()`)
// | Device | Log |
// | Pixel 8 | Priority: 3, Tag: Cart, Message: New item added to cart, App Version: v1.24, Log Time: 2024-09-10T05:28:04.113910Z

See it in action

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

GitHub - hossain-khan/android-keep-alive

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

Demo of remotely logged messages in the Airtable

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.

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 native Result<T> class already available in standard lib since Kotlin v1.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<T> class that allows you to easily handle both cases.

How to handle Exceptions

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

1. 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<T> 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" even if error is thrown

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<T> , 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 😊

UPDATE #1: As Gabor has mentioned below, there is an unintended consequence about using it in coroutines. I will look into it and provide more updates on the usage soon. Thanks to Garbor for mentioning it.

Android’s ProgressBar widget comes with lot of customization controls and flexibility to set custom animated drawable. However, setting AnimatedVectorDrawable is not one of the option.

So, this is a quick trick on how to use custom ImageView to create indeterminate progress indicator using Animated Vector Drawable (AVD).

class AvdLoadingProgressBar @JvmOverloads constructor*(
    *context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
*) *: AppCompatImageView*(*context, attrs, defStyleAttr*) {
    *private val avd = AnimatedVectorDrawableCompat.create*(*context, R.drawable.avd_anim*)*!!

    init *{
        *setImageDrawable*(*avd*)
        *avd.registerAnimationCallback*(*object : Animatable2Compat.AnimationCallback*() {
            *override fun onAnimationEnd*(*drawable: Drawable?*) {
                *post **{ **avd.start*() ***}
            ***}
        })
        *avd.start*()
    }
}*

import android.content.Context
import android.graphics.drawable.Drawable
import android.util.AttributeSet
import androidx.appcompat.widget.AppCompatImageView
import androidx.vectordrawable.graphics.drawable.Animatable2Compat
import androidx.vectordrawable.graphics.drawable.AnimatedVectorDrawableCompat

/**
 * Custom loading indicator using Animated vector drawable.
 *
 * ## External Resources
 * - https://medium.com/androiddevelopers/animation-jump-through-861f4f5b3de4
 * - https://gist.github.com/nickbutcher/97143b3240682e5c5851fe45b49fde93
 * - https://medium.com/androiddevelopers/re-animation-7869722af206
 * - https://gist.github.com/nickbutcher/b1806905c6bc0ef29f545fd580935bd3
 */
class AvdLoadingProgressBar @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : AppCompatImageView(context, attrs, defStyleAttr) {
    /*
     * NOTE: It can only return null if parsing error is found.
     * So, using `!!` operator should expose any issue with the AVD XML file in API 23 or lower.
     */
    private val avd = AnimatedVectorDrawableCompat.create(context, R.drawable.avd_anim_kijiji_loading)!!

    init {
        setImageDrawable(avd)
        avd.registerAnimationCallback(object : Animatable2Compat.AnimationCallback() {
            override fun onAnimationEnd(drawable: Drawable?) {
                post { avd.start() }
            }
        })
        avd.start()
    }
}

<animated-vector
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:aapt="http://schemas.android.com/aapt">
    <aapt:attr name="android:drawable">
        <vector
            android:name="vector"
            android:width="204dp"
            android:height="33dp"
            android:viewportWidth="204"
            android:viewportHeight="33">
            <group android:name="group">
                <path
                    android:name="a"
                    android:pathData="M 33 17 C 33 25.83 25.83 33 17 33 C 8.17 33 1 25.83 1 17 C 1 8.17 8.17 1 17 1 C 25.83 1 33 8.17 33 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
            <group android:name="group_2">
                <path
                    android:name="b"
                    android:pathData="M 75.59 17 C 75.59 25.83 68.42 33 59.59 33 C 50.76 33 43.59 25.83 43.59 17 C 43.59 8.17 50.76 1 59.59 1 C 68.42 1 75.59 8.17 75.59 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
            <group android:name="group_4">
                <path
                    android:name="c"
                    android:pathData="M 118.28 17 C 118.28 25.83 111.11 33 102.28 33 C 93.45 33 86.28 25.83 86.28 17 C 86.28 8.17 93.45 1 102.28 1 C 111.11 1 118.28 8.17 118.28 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
            <group android:name="group_6">
                <path
                    android:name="d"
                    android:pathData="M 160.78 17 C 160.78 25.83 153.61 33 144.78 33 C 135.95 33 128.78 25.83 128.78 17 C 128.78 8.17 135.95 1 144.78 1 C 153.61 1 160.78 8.17 160.78 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
            <group android:name="group_8">
                <path
                    android:name="e"
                    android:pathData="M 203.78 17 C 203.78 25.83 196.61 33 187.78 33 C 178.95 33 171.78 25.83 171.78 17 C 171.78 8.17 178.95 1 187.78 1 C 196.61 1 203.78 8.17 203.78 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
        </vector>
    </aapt:attr>
    <target android:name="a">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="52"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#f8aa17"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="650"
                    android:duration="100"
                    android:valueFrom="#f8aa17"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
    <target android:name="b">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="173"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#f1454f"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="750"
                    android:duration="100"
                    android:valueFrom="#f1454f"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
    <target android:name="c">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="300"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#2681db"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="850"
                    android:duration="100"
                    android:valueFrom="#2681db"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
    <target android:name="d">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="424"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#37a864"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="950"
                    android:duration="100"
                    android:valueFrom="#37a864"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
    <target android:name="e">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="550"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#9b44ad"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="1050"
                    android:duration="100"
                    android:valueFrom="#9b44ad"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
</animated-vector>

<animated-vector
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:aapt="http://schemas.android.com/aapt">
    <aapt:attr name="android:drawable">
        <vector
            android:name="vector"
            android:width="204dp"
            android:height="33dp"
            android:viewportWidth="204"
            android:viewportHeight="33">
            <group android:name="group">
                <path
                    android:name="a"
                    android:pathData="M 33 17 C 33 25.83 25.83 33 17 33 C 8.17 33 1 25.83 1 17 C 1 8.17 8.17 1 17 1 C 25.83 1 33 8.17 33 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
            <group android:name="group_2">
                <path
                    android:name="b"
                    android:pathData="M 75.59 17 C 75.59 25.83 68.42 33 59.59 33 C 50.76 33 43.59 25.83 43.59 17 C 43.59 8.17 50.76 1 59.59 1 C 68.42 1 75.59 8.17 75.59 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
            <group android:name="group_4">
                <path
                    android:name="c"
                    android:pathData="M 118.28 17 C 118.28 25.83 111.11 33 102.28 33 C 93.45 33 86.28 25.83 86.28 17 C 86.28 8.17 93.45 1 102.28 1 C 111.11 1 118.28 8.17 118.28 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
            <group android:name="group_6">
                <path
                    android:name="d"
                    android:pathData="M 160.78 17 C 160.78 25.83 153.61 33 144.78 33 C 135.95 33 128.78 25.83 128.78 17 C 128.78 8.17 135.95 1 144.78 1 C 153.61 1 160.78 8.17 160.78 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
            <group android:name="group_8">
                <path
                    android:name="e"
                    android:pathData="M 203.78 17 C 203.78 25.83 196.61 33 187.78 33 C 178.95 33 171.78 25.83 171.78 17 C 171.78 8.17 178.95 1 187.78 1 C 196.61 1 203.78 8.17 203.78 17 Z"
                    android:fillColor="#373373"
                    android:strokeWidth="1"/>
            </group>
        </vector>
    </aapt:attr>
    <target android:name="a">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="52"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#f8aa17"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="650"
                    android:duration="100"
                    android:valueFrom="#f8aa17"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
    <target android:name="b">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="173"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#f1454f"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="750"
                    android:duration="100"
                    android:valueFrom="#f1454f"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
    <target android:name="c">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="300"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#2681db"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="850"
                    android:duration="100"
                    android:valueFrom="#2681db"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
    <target android:name="d">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="424"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#37a864"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="950"
                    android:duration="100"
                    android:valueFrom="#37a864"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
    <target android:name="e">
        <aapt:attr name="android:animation">
            <set>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="550"
                    android:duration="100"
                    android:valueFrom="#373373"
                    android:valueTo="#9b44ad"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
                <objectAnimator
                    android:propertyName="fillColor"
                    android:startOffset="1050"
                    android:duration="100"
                    android:valueFrom="#9b44ad"
                    android:valueTo="#373373"
                    android:valueType="colorType"
                    android:interpolator="@android:interpolator/fast_out_slow_in"/>
            </set>
        </aapt:attr>
    </target>
</animated-vector>

NOTE: The idea of repeated indefinite AVD is heavily borrowed from Nick Butcher’s medium article on AVD. I highly recommend you read them to know more tips and ticks with AVD.

That’s it. You can now use this in your layout as usual view and show it when data is loading from network or any long running async request is happening.

*<*androidx.constraintlayout.widget.ConstraintLayout>

  <dev.hossain.avdprogress.AvdLoadingProgressBar
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    app:srcCompat="@drawable/avd_anim_kijiji_loading" />

</androidx.constraintlayout.widget.ConstraintLayout>

Here is preview of the AVD in https://shapeshifter.design/

Further reading

Animation: Jump-through *Recently a call for help caught my eye; asking how to implement a fancy ‘getting location’ animation on Android:*medium.com Re-animation *In a previous article, I described a technique for creating vector animations on Android:*medium.com

Photo by Shahadat Rahman on Unsplash

Syntax highlighting is one of them and there are fewlibrariesforthat 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 *Yet Another Android Syntax Highlighter (YAASH). Example of how to use any JavaScript library to enable syntax highlighting in your android app.*github.com

Set of screenshots taken from the demo app

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 {
// .. more existing dependencies here
classpath 'com.google.firebase:firebase-appdistribution-gradle:2.0.0' // see official guide for latest versions
}

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

I have a hobby of taking a lot of pictures, and some of the pictures do turn out nice (at least to me 😊). So, I’ve also created a web portal to showcase those pictures 🖼️.

As an Android engineer, I was aware of **Muzei Live Wallpaper** app created by Roman Nurik back in 2014. Recently I’ve seen some updates from Ian Lake who took over the project while ago, so I decided to make a plugin for Muzei to use my pictures as wallpaper on my Android phone.

ps. If you simply want to use the plugin, see README for instruction 🤗

The objective of this post is to showcase how easy it was for me to work on this ⏰ 1-day hackathon project to create the plugin for Muzei by following guidelines and examples provided in the Muzei GitHub repository.

Essentially, I had to do 2 major tasks to create the Android plugin

1. Download a list of image URLs+metadata and convert them into Artwork object.

2. Declare a content provider on AndroidManifest.xml to expose the images for Muzei Live Wallpaper app.

Download Image Metadata

You can use any library of your choice to do that, I’ve followed the unsplash example and used Retrofit+WorkManager to download metadata and convert the images into Artwork objects. See source code snapshot from GitHub.

Expose Content Provider

Based on MuzeiArtProvider documentation, I extended my [HkVisionArtProvider](https://github.com/amardeshbd/android-hk-vision-muzei-plugin/blob/master/app/src/main/java/com/hossainkhan/vision/muzei/HkVisionArtProvider.kt) from it and defined following provider specification in AndroidManifest.xml

Source code available at the GitHub repository

That’s it. Once you build and install the APK, the source will show up in the Muzei Live Wallpaper app which allows you to choose a wallpaper from a list of photos that was added to Muzei artwork provider client.

I have released the plugin app on Google Play as a public release. If you are interested, then get it on Google Play. If you do like the wallpapers, feel free to drop a line here.✌️

💻 Source code of the Android project is available at GitHub repo below: amardeshbd/android-hk-vision-muzei-plugin Muzei Live Wallpaper app’s photo data source plugin for vision.hossainkhan.com website. github.com

On April 14th, 2020 GitHub announced a major change in their plans to allow free private repositories. It’s a good time to make use of their free CI/CD known as “Actions”. Private repositories have 2000mins/month and public repositories have unlimited minutes (see pricing).

This is a quick write-up on how you can leverage Actions CI Workflow to do any task using supported node.js modules from npm.

NOTE: If you are new to GitHub Actions, I highly recommend reading their ‘Getting Started’ guide first.

The concept is simple, you setup node environment on CI machine, install required CLI-based node modules, and run your tests.

NOTE: Use node package manager portal at npmjs.com to find your node-module to run on GitHub Actions CI job.

Use case #1: Use XML Validator module to validate XML. See workflow file.

• name: Setup NodeJS
  uses: actions/setup-node@v1
  with:
  node-version: 12.x

• name: Install XML Validator
  run: npm install -g fast-xml-parser

• name: Validate AndroidManifest.xml
  run: xml2js -V app/src/main/AndroidManifest.xml

Use case #2: Validate JSON file using JSON-Schema specification (source).

• name: Setup NodeJS
  uses: actions/setup-node@v1
  with:
  node-version: 12.x

• run: npm install -g ajv-cli

• run: ajv validate -s photos-schema.json -d photos.json

That’s it, now you have your own workflow to validate or do other tasks on GitHub repository.

Here is the list of open-source apps in this article:

• Android Architecture Blueprints v2 — Google’s official recommended app

• Plaid 2.0 — Google’s official recommended app with focus on Material Design

• Sunflower — Google’s official recommended app with more focus on many Jetpack components

• CatchUp — Community app with multi-module and multi-api-service

• Showcase — Community app with multi-module and clean architecture

• Google I/O — Google’s official annual conference app

• Tivi — Community app with a focus on multi-module architecture and Jetpack

  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](https://github.com/android/plaid)

Snapshot of Plaid 1.0 — The latest 2.0 app is still under heavy development.

🌻 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: None (Dagger not used to keep it simple)

• Navigation: Jetpack Navigation (Single Activity)

• Unit Tests: JUnit and Espresso

• Source: [https://github.com/android/sunflower](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 Hilt (Advanced usage)

• Navigation: Basic (Intent Based)

• Unit Tests: Some JUnit tests exist (not priority).

• Source: [https://github.com/ZacSweers/CatchUp](https://github.com/ZacSweers/CatchUp)

CatchUP — Demo Screenshots

NOTE: As per Zac, he recently tweeted “standard disclaimer that CatchUp is not necessarily a template of patterns I endorse or recommend. It’s a laboratory not a representative sample”

Showcase — clean architecture

This is another community sample that I discovered recently. The sample app is developed by Igor Wojda, author of “Android Development with Kotlin” book.

The showcase app incorporates many best practices, here is the project summary on Igor’s own words:

Android application following best practices: Kotlin, coroutines, Clean Architecture, feature modules, tests, MVVM, static analysis.

• Key Features: Kotlin and Coroutines, Gradle KTS, Static Code Analysis

• Language: Kotlin

• Architecture: Clean Architecture

• Dependency Injection: None (Manual)

• Navigation: Jetpack Navigation

• Unit Tests: JUnit

• Source: [https://github.com/igorwojda/android-showcase](https://github.com/igorwojda/android-showcase)

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 Hilt

• 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 Hilt

• 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 🙏

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 ✌️

DISCLAIMER: This is a non-technical just-for-fun post!

In the past few years, the Android ecosystem has exploded with lots of tools, libraries, and architecture guidelines. Recently, with I/O 2017 announcement of Kotlin support, it just added another dimension.

Today, I am going to show you quickest way of becoming an Android Developer regardless of language and plethora of libraries, all you need is a physical Android device.

Becoming Android developer

On your device, go to Settings > About and find “Build Number”

p.s. The “Build Number” may be burried under additional sub section based on device manufacturer like LG, Samsung, HTC and so on. You just need to find it 🤓.

Now, all you need to do is keep tapping the build number value until it says you have become a developer. And that’s it!

Here is how I became a developer using my Pixel 2 XL device:

A short clip showcasing how to enable ‘Developer options’

If you made this far, you know this is a joke 🙈! By now, every Android devs know how to activate the developer options on any Android device.

However, back in the days, there was no tapping required to activate it, it was always there. So, when they added this feature, I’ll be honest, I did have to Google for it 😁.

Under the hood

As I was curious, I wanted to see how the logic works in the Android settings screen. I found that all these logic of activating the developer options is in BuildNumberPreferenceController.java (AOSP) source code.

First, the most important constant that defines how many times we have to tap to become the ‘developer’ is:

static final int TAPS_TO_BE_A_DEVELOPER = 7;

Why 7? Maybe because it’s considered a lucky number? ¯\_(ツ)_/¯

Pre-conditions

Here some of the pre-conditions that have to be met before developer settings can be activated by tapping 7 times on the build number.

• Admin user of the device (using UserManager)
• Device Provisioning is complete
• Tapping is not done by monkey-runner
• Debugging feature is not disabled by Device Owner/Work Profile

After these requirements are met, all there is left to do is count-down the number of taps. Here is a simplified code snapshot with some added inline comments:

if (mDevHitCountdown > 0) {
mDevHitCountdown--;
if (mDevHitCountdown == 0 && !mProcessingLastDevHit) {
// Open the lock screen validation screen before activating
mProcessingLastDevHit = helper.launchConfirmationActivity();
if (!mProcessingLastDevHit) {
// Activates developer settings after lock verification
enableDevelopmentSettings();
}
} else if (mDevHitCountdown > 0
&& mDevHitCountdown < (TAPS_TO_BE_A_DEVELOPER - 2)) {

// Show - "You are X taps away from being developer."
mDevHitToast = Toast.makeText(getQuantityString(
R.plurals.show_dev_countdown,
mDevHitCountdown,
mDevHitCountdown),
Toast.LENGTH_SHORT);
mDevHitToast.show();
}
} else if (mDevHitCountdown < 0) {
// This means, you have already tapped 7 times, you're a DEV!
mDevHitToast = Toast.makeText(R.string.show_dev_already,
Toast.LENGTH_LONG);
mDevHitToast.show();
}

That’s it, mystery solved 🎉

Here are 2 key steps to setup your GitHub pages enabled project to use your custom domain.

⚙️Step 1 — Set domain in GitHub project

Go to your GitHub Pages site’s repository settings. Under “Custom domain”, add or remove your custom domain and click “Save”.

Setting “custom domain” creates a file named **CNAME** in the same repository. Don’t delete it.

⚙️Step 2 — Set custom resource record for domain

This step is specific to your domain name register (like GoDaddy, Domain.com, Google Domains, etc). All you need to do is set **A** & **CNAME** records for the selected domain.

This is a sample screenshot taken from the Google Domains portal.

For **A** record, set 185.199.108.153, 185.199.109.153, 185.199.110.153 and 185.199.111.153. To redirect **www** subdomain to the original domain, add a **CNAME** record with your GitHub pages profile URL with a .(dot) in the end, for example, ‘*YOUR-GITHUB-USERNAME.github.io.*’.

Official References*: For most up to date IP Addresses, use GitHub’s [official documentation](https://help.github.com/articles/setting-up-an-apex-domain/) and for setting up CNAME use this [documentation](https://help.github.com/articles/setting-up-a-www-subdomain/).*

That’s it, both www.your-domain.com and your-domain.com will now go to your selected GitHub pages site (may need to wait up to 24 hours). If you want to see a live example, you may visit my portfolio “hossainkhan.com” hosted via GitHub pages repository ✌️.

UPDATE #1: The IP addresses for DNS A record is updated. The new IP addresses are required to use the free HTTPS support for GitHub pages.

UPDATE #2: Some people said this change is not working, it is actually because the DNS update can take upto 24 hours to propagate. So, I guess try hitting your domain next day 🤓

NOTE #1: Even though it’s very obvious, you should replace *YOUR-GITHUB-USERNAME* and your-domain.com with your personal github username and domain name you are trying to use respectively.