Photo by Barn Images on Unsplash

Creating reusable tools is part of being a professional Android developer. Over time, many of us accumulate utility classes, wrappers, and internal helpers that could easily be shared between projects — yet they often stay buried in the utils folder of a single app.

Publishing a proper SDK sounds like something for big companies or platform teams, but it doesn’t have to be

The goal of this article is to walk through the full process of building and publishing your own SDK — from idea to public usage. No magic, no scripts, no hidden steps.

We’ll build a small but practical SDK — a lightweight TimeTracker — and use it to explore:

• Creating a clean library module
• Designing a reusable public API
• Publishing the SDK to GitHub + JitPack
• Integrating it into a real Compose-based app
• Writing documentation and examples

For publishing, I’m using JitPack, which builds your SDK directly from a GitHub repository. It’s perfect for internal tools, side projects, open-source libraries, or even production SDKs that don’t require the full rigor of Maven Central.

If you’re building something bigger or for wide distribution, then Maven Central is the more scalable and enterprise-ready option — but it comes with more setup and release overhead.

This article focuses on clarity and practicality. Whether you’re new to SDK development or just never had the time to set it up before, this is a working, repeatable example you can build upon.

Step 1 — Setting Up the Project and Library Module

The first step is to create a new Android project where we’ll build our SDK.
In real-world cases, you might extract SDK functionality from an existing app, but here we’ll start clean to focus purely on structure.

We’ll use Android Studio to:

• Create a new Android project
• Add a separate library module that will become our SDK
• Keep our SDK code fully isolated and reusable

Tip: Using a library module helps keep concerns separated — your app remains the consumer, and your SDK becomes the provider.

1. Create a new Android project

Open Android Studio and choose “New Project” → No Activity.
You can name the project something like TimeTrackerSDK.

Use Kotlin as the language and set minSdk to 21 or higher.

2. Add a new module: Android Library

Once the base project is created:

• Go to File > New > New Module…
• Select Android Library
• Set the module name to timetracker
• Set the package name to something like com.example.timetracker
• Click Finish

This creates a separate module that can be compiled into a .aar file and published independently.

Bonus: You can keep this SDK inside a monorepo or extract it into its own GitHub repository later. Both approaches are valid, depending on your project needs.

timetracker/src/main/java/com/example/timetracker/TimeTracker.kt

package com.example.timetracker

import android.util.Log

/**
 * TimeTracker is a lightweight utility for measuring execution time of code blocks or operations.
 * It can be used in both development and production environments.
 */
object TimeTracker {

    private val startTimes = mutableMapOf<String, Long>()
    private val durations = mutableMapOf<String, Long>()

    /** Enable or disable tracking globally. */
    var isEnabled: Boolean = true

    /**
     * Optional custom logger.
     * Default: logs to Logcat with tag "TimeTracker"
     */
    var logger: ((String, String) -> Unit)? = { tag, message ->
        Log.d(tag, message)
    }

    /** Starts tracking a tag */
    fun start(tag: String) {
        if (!isEnabled) return
        startTimes[tag] = System.currentTimeMillis()
        logger?.invoke("TimeTracker", "Started timer for [$tag]")
    }

    /** Stops tracking a tag and calculates duration */
    fun stop(tag: String) {
        if (!isEnabled) return
        val startTime = startTimes[tag]
        if (startTime != null) {
            val duration = System.currentTimeMillis() - startTime
            durations[tag] = duration
            logger?.invoke("TimeTracker", "Stopped timer for [$tag], duration: ${duration}ms")
        } else {
            logger?.invoke("TimeTracker", "No start time found for tag: $tag")
        }
    }

    /** Returns duration in milliseconds for a tag, or null if not available */
    fun getDuration(tag: String): Long? {
        return if (isEnabled) durations[tag] else null
    }

    /** Logs all recorded durations */
    fun printAllDurations() {
        if (!isEnabled) return
        durations.forEach { (tag, duration) ->
            logger?.invoke("TimeTracker", "[$tag] took ${duration}ms")
        }
    }

    /** Clears all start times and durations */
    fun reset() {
        startTimes.clear()
        durations.clear()
        logger?.invoke("TimeTracker", "All timers cleared")
    }

    /**
     * Measures execution time of a code block automatically.
     * Usage:
     * TimeTracker.measure("load_data") {
     *     // Your logic
     * }
     */
    inline fun <T> measure(tag: String, block: () -> T): T {
        start(tag)
        val result = block()
        stop(tag)
        return result
    }
}

Now that your SDK is working locally, the next step is to make it reusable in other projects.
There are multiple ways to publish an Android SDK — you can push to an internal Maven repo, upload to Maven Central, or distribute a .aar manually.

But for open-source or lightweight public libraries, JitPack is by far the easiest and fastest way to publish directly from GitHub — with zero boilerplate.

What is JitPack?

JitPack is a free service that builds your GitHub repository on demand and serves it as a Maven/Gradle dependency. You tag a release, JitPack builds it, and anyone can import it via:

implementation 'com.github.username:repository:tag'

It’s ideal for:

• Open-source utilities and tools
• Demo libraries
• Internal SDKs
• Quick experiments that don’t need Maven Central

1. Push your SDK to GitHub

If you haven’t already, create a new GitHub repository and push your SDK project to it:

git init
git remote add origin https://github.com/yourname/TimeTrackerSDK.git
git add .
git commit -m "Initial commit"
git push -u origin main

Make sure your TimeTracker.kt lives in a proper library module (not the app module).

2. Tag a release

JitPack builds your library based on tags. Once your code is on GitHub, create a release tag:

git tag v1.0.0
git push origin v1.0.0

This tag will be used as the version in Gradle.

3. Open your project on JitPack

Go to https://jitpack.io
Paste your GitHub repo URL, and hit “Look Up”.

You should see your latest tag and a green “Published” status.

4. Add JitPack to your consumer project

In the app where you want to use the SDK, update your build.gradle:

repositories {
    maven { url 'https://jitpack.io' }
}

Then add the dependency:

dependencies {
    implementation("com.github.yourname:TimeTrackerSDK:v1.0.0")
}

5. Done. You’re using your own SDK!

You can now call TimeTracker.start(), TimeTracker.measure(), etc. in any project — just like any other dependency.

This setup is fully reproducible. Every time you push a new tag, JitPack will build and serve a new version automatically.

For production-scale libraries or SDKs intended for wide public distribution (like on Maven Central), you’ll want a more formal setup — with artifact signing, metadata, and hosting. But for most cases, JitPack is more than enough.

Step 4 — Using the SDK in a Real Compose-Based App

With the SDK published and available via JitPack, it’s time to test it in a real-world project.

In this step, we’ll:

• Create a simple Jetpack Compose app
• Import the SDK as a dependency
• Use TimeTracker to measure screen setup time and logic execution
• Log the results using Logcat

1. Create a new Android project with Jetpack Compose

In Android Studio:

• Select New Project → Empty Compose Activity
• Use Kotlin and set minSdk to 21+
• Name the project TimeTrackerDemoApp (or whatever you like)

Once the project is created, open the root-level build.gradle (or settings.gradle.kts) and make sure you have:

repositories {
    google()
    mavenCentral()
    maven { url 'https://jitpack.io' } // Add this line
}

2. Add the SDK dependency

Open app/build.gradle and add:

dependencies {
    implementation("com.github.yourname:TimeTrackerSDK:v1.0.0")
}

Replace yourname with your actual GitHub username.

Sync the project.

3. Use the SDK in your MainActivity.kt

Here’s an example of how you might use TimeTracker inside a Compose activity to measure screen setup time:

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Enable tracking in debug mode only
        TimeTracker.isEnabled = BuildConfig.DEBUG
        TimeTracker.logger = { tag, msg -> Log.d(tag, msg) }

        // Measure how long the screen takes to set up
        TimeTracker.measure("MainScreenSetup") {
            setContent {
                TimeTrackerDemoAppTheme {
                    Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                        Greeting(
                            name = "Compose",
                            modifier = Modifier.padding(innerPadding)
                        )
                    }
                }
            }
        }
    }
}

When you run the app, you should see output like this in Logcat:

4. Optional: Use inside a Composable

If you want to measure time inside a @Composable, wrap the logic in a LaunchedEffect block:

@Composable
fun Greeting(name: String) {
    LaunchedEffect(Unit) {
        TimeTracker.measure("GreetingRender") {
            delay(100) // simulate some rendering logic
        }
    }

    Text("Hello $name!")
}

This article was previously published on proandroiddev.com.