标签：#Kotlin

The atmosphere in the room was dense, the kind where every whisper echoes. I was sitting in the third row of a local community center during a Friday prayer session, my head bowed in reflection. Suddenly, a high-pitched, synthetic ringtone shattered the silence. My pocket vibrated violently, sending a jolt of anxiety through my chest. I scrambled to silence it, but the damage was done; a dozen heads turned in my direction. I wasn't just embarrassed; I was frustrated with myself for the thousandth time for forgetting the simple task of toggling a silent switch. This wasn't an isolated incident. I found myself constantly caught in a cycle of human error. I would arrive at the office, launch into a deep-work sprint, and realize two hours later that my phone had been chirping with notifications through three separate meetings. Then, I would leave the office and forget to turn the ringer back on, missing urgent calls from family throughout the evening. The friction wasn't in the hardware; it was in the expectation that a human should perfectly manage a state machine that they interact with hundreds of times a day. I realized that my phone was intelligent enough to track my location, calculate prayer times, and sync my schedule, yet it remained stubbornly passive regarding its own audio profile. Most existing automation tools were either too heavy, draining the battery within hours, or relied on cloud-based triggers that failed the moment I lost signal. I wanted something that lived on the device, respected the user's privacy, and handled the transition between 'Silent', 'Vibrate', and 'Normal' states without me ever needing to touch the screen. The goal was simple: build a background service that watches the world and adjusts the phone's volume automatically. I needed an architecture that could handle geofencing, calendar events, and time-based triggers without turning the device into a space heater. When I started building the geofencing engine for Muffle, the immediate

What is ZeroDroid? ZeroDroid is an open-source Android toolkit that exposes the radios, sensors and connected-device capabilities already present in a phone. GitHub: https://github.com/theabhishekchandra/ZeroDroid What problems does it address? The app contains 29 tools across five areas: Wireless: Wi-Fi, BLE, NFC, Bluetooth Classic and peer-to-peer connections RF and signals: IR, UWB, SDR-device detection and ultrasonic analysis Sensors: GPS/GNSS, QR analysis, device sensors and magnetic anomalies Network: USB inspection, cell-tower information and wardriving Security: tracker scanning, hidden-camera indicators, rogue-AP detection, network scanning and deauthentication indicators Architecture ZeroDroid uses Kotlin, Jetpack Compose, Material 3, MVVM, StateFlow, Hilt and Room. Services are lazy-loaded, and scanning begins only when the user starts a tool. Important limitations A smartphone cannot guarantee that it has found every camera, tracker, bug or network threat. Several detections are heuristic and may produce false positives or miss threats. Hardware availability also differs between Android devices. The project is intended only for education, defensive security and testing devices or networks you own or are authorized to assess. Feedback wanted I am looking for: Compatibility reports from different Android phones Feedback about permission handling False-positive reports Contributions, tests and documentation improvements Repository: https://github.com/theabhishekchandra/ZeroDroid

If you are building an iOS app with Kotlin Multiplatform (KMP) or Compose Multiplatform, you might have opened your generated Shared.h header at some point and wondered why it is 20,000+ lines long. I ran into this recently while optimizing one of my personal KMP apps. I kept seeing Objective-C classes generated for every single theme color, dimension constant, and internal state model, even though my Swift code never touched any of them. To get a clear picture of what was actually going on, I built a small Gradle plugin called kmprofiler . It parses the generated Objective-C header, scans your Swift source files, and highlights which exported declarations have zero call sites in Swift. The numbers on my app caught me off guard, but cleaning it up took just a few minutes. Why does Kotlin/Native export so much? In Kotlin, declarations are public by default. When targeting iOS, the Kotlin/Native compiler looks at every public class, top-level function, and property in your shared module and creates an Objective-C class interface and runtime method trampolines in the framework binary. The compiler cannot dead-strip these automatically because Objective-C relies on dynamic dispatch. It has to assume Swift or Objective-C could call them at runtime. If your UI is built with Compose Multiplatform or your Swift app only interacts with a couple of high-level bridge interfaces, most of those exported Objective-C wrappers end up being dead weight. The Audit: 459 Exports, 282 Unused When I ran kmprofiler on my app (Framed), it gave me this breakdown: ### 📊 KMP iOS Export Profile Export surface: 459 Kotlin declarations exported to Objective-C. No direct Swift call site found for 282 of them (61.4% uncalled). The unused exports mostly fell into three buckets: File Facades ( *Kt classes): Top-level properties in files like Dimens.kt (38 spacing constants) or Color.kt generated synthetic Objective-C classes like DimensKt with static getters for every single constant. Internal UI St

What if adding Kotlin and Java compilation to your application didn't mean building an entire compilation pipeline yourself? What if you could add Bytesmith, configure the filesystem once, provide your source files and output destination, and simply compile? That's the idea behind Bytesmith . Bytesmith is a Kotlin and Java compiler toolkit designed for JVM and Android applications. It provides a unified API for Kotlin, Java, and mixed-language compilation, while also supporting filesystem abstraction, custom classpaths, boot classpaths, compiler plugins, packaging, and diagnostics. Configure the environment, provide the source, specify the output, and compile. The problem Compiler tooling can become surprisingly difficult when it is tightly coupled to the environment in which it was originally designed to run. You might need to deal with: Kotlin compiler versions Kotlin standard libraries Java compilation Bootclasspath configuration Dependency classpaths Source discovery Output handling Android storage Storage Access Framework URIs Packaging Compiler diagnostics And then there is the question of where those files actually live. On a desktop JVM, you might have traditional filesystem paths: /home/user/project/src/Main.kt On Android, you might be working with application storage or files selected through the Storage Access Framework: content://... If your compiler API directly depends on java.io.File , your compilation code becomes coupled to one filesystem model. Bytesmith takes a different approach. Adding Bytesmith The goal is to make compilation something you can plug into an application. With Gradle: implementation ( "io.github.sifisofakude.bytesmith:bytesmith-common:1.0.0" ) After adding Bytesmith, configure the filesystem your application wants to use. For a JVM application: FileSystems . current = JvmFileSystem () For Android: FileSystems . current = AndroidSafFileSystem ( context ) Once the filesystem is configured, the rest of the compilation layer can opera

It was the final ten minutes of a high-stakes client presentation. I was mid-sentence, explaining a complex system migration, when my phone erupted with a loud, aggressive ringtone. The room went silent, but my phone did not. I scrambled to silence it, accidentally hitting the volume buttons while fumbling with the screen. That moment of pure, unadulterated embarrassment followed me for days. It was not the first time this had happened, but it was the time I decided I had finally had enough of relying on my own memory to toggle sound profiles before entering sensitive environments. Most of us live in a state of perpetual concern regarding our devices. We walk into movie theaters, attend religious services, or sit through medical consultations, constantly checking our pockets to ensure we have toggled the mute switch. If we forget, we face the social friction of a disruption. The existing solutions were either too manual—requiring a conscious effort I rarely possessed in the moment—or too intrusive, demanding constant location permissions and draining the battery to perform simple state changes. I wanted something that functioned as a set-and-forget background utility. I needed a system that understood the context of my environment without requiring me to interact with an interface every time my routine shifted. To build this, I had to architect a background service that could survive the aggressive power-management constraints of modern Android, specifically Doze mode. The primary challenge was ensuring that my sound-toggling logic fired precisely when a rule was triggered, even if the device had been sitting idle for hours. I initially experimented with a standard Service , but Android’s lifecycle management quickly killed it to save resources. I shifted to using a ForegroundService with a persistent notification, which is the standard approach for long-running tasks, but that only solved the visibility part. The real hurdle was the timing accuracy required for eve

It happened during a quiet, solemn moment at a funeral. I felt the vibration in my pocket, and for a split second, I panicked. I had silenced my phone before entering, but I had accidentally toggled it back to normal mode while checking an email earlier that morning. In that room, the sound of a notification ping felt like a gunshot. The embarrassment was immediate and visceral. It was a clear signal that I needed a better way to manage my device's sound profile, a system that didn't rely on my flawed human memory. We live in an era of hyper-connectivity, yet our phones are surprisingly dumb when it comes to context awareness. I found myself constantly manually adjusting volume sliders. Meetings, gym sessions, prayer times, movie theaters—the list of places requiring silence is endless. Most existing solutions were either too heavy, requiring complex IFTTT integrations that lagged, or they were privacy-invasive, requiring constant cloud syncing. I wanted something that lived locally on my device, respected my data privacy, and didn't turn my phone into a brick by noon. The core problem wasn't just the silencing; it was the cognitive load of having to remember to revert those changes, which is how you end up missing important calls for the rest of the day. To build Muffle, I had to solve the geofencing puzzle. The temptation for any Android developer is to fire up a LocationRequest with high-accuracy settings and just poll the GPS coordinates. That is the fastest way to destroy battery life and get your app killed by the Android system's battery optimizations. Instead, I leaned into the GeofencingClient API. It is designed precisely for this use case: it lets the system handle the heavy lifting of location monitoring at the hardware level, rather than keeping the radio awake in my application process. I configured the GeofencingRequest using GEOFENCE_TRANSITION_ENTER and GEOFENCE_TRANSITION_EXIT triggers. The magic happens in the PendingIntent that gets fired when th

This is a submission for DEV's Summer Bug Smash : Smash Stories. TL;DR. I bounded a database read to make my analyzer faster. I derived the bound carefully, wrote the reasoning into the KDoc, and shipped it behind five passing tests. The bound was wrong in a way none of those tests could see. The result: if a lifter deloaded once in the middle of a stall, which is the correct thing for a lifter to do, my app stopped telling them they had plateaued. No crash. No error. No log line. The feature just quietly stopped being true for the people using the app correctly. The setup WhyRep analyzes your training rather than just recording it. The core promise is that it tells you when you have stalled and what to change about it, and that every verdict traces back to a methodology document rather than to something a language model made up. The architecture decision underneath that promise is that nothing is precomputed . Verdicts are derived from raw set logs on read, every time, so there is no cached judgement to go stale when the rules change. Which means every read walked the lifter's entire history for every exercise in the session. That is fine at ten sessions. It is not fine at three hundred. The obvious optimization is to bound the read. The obvious bound is "it only needs the last two weeks." That was my first wrong answer, and it is worth thirty seconds before I get to the interesting one. The plateau rules are not measured in calendar time. They are consecutive-miss counts, and the count varies by lifter tier and by whether the movement is a big or small joint action. The widest window in the signed methodology is an elite lifter on a small joint action: 14 consecutive sessions without progress. Train a lateral raise once a week and 14 sessions is over three months of data. A 14-day cutoff could never have fired a plateau for anyone above beginner tier. It would not have thrown. It would have quietly stopped detecting the exact thing the product exists to detect. Th

GitHub热门项目 | Visualize your year in travel using your Google Location History (Timeline) data | Stars: 2,184 | 1,040 stars today | 语言: Kotlin

At Whoz , we build a SaaS platform that helps professional services companies manage their talent staffing. At the heart of our product lies a concept called a worklog — a record of time spent by a user on a given activity. Every consultant, every day, on every project, generates worklogs. It sounds simple. And for years, it was. Then the numbers caught up with us. The Problem: A Collection That Never Stops Growing Our worklog MongoDB collection had reached 530 million documents , representing just over 32 GB of data. And the growth rate was accelerating — not just because we were onboarding more clients, but because users were increasingly splitting their activity into finer-grained entries, generating more worklogs per person per day than ever before. A worklog document looks roughly like this: { "date" : "2024-03-15" , "talentId" : "abc123" , "workspaceId" : "ws456" , "duration" : 0.5 , "activityType" : "TASK" , "taskId" : "task789" } Simple enough. But at 530 million of them, even the most routine operations become painful: Backup : nearly 1 hour Restore : up to 4 hours Schema migrations : we hadn't dared run one at full scale yet — and that alone was a warning sign Every year, the collection grows faster than the year before. The backup and restore windows were becoming operationally risky. We needed to act. Exploring Our Options We identified three potential approaches before settling on a solution. Option 1 — MongoDB Sharding Sharding is MongoDB's native horizontal scaling mechanism. It distributes a collection across multiple shards, each backed by its own replica set. On paper, it looked like a match. In practice, we ran into a fundamental mismatch with our actual needs. Our core issue wasn't query throughput — worklogs from three years ago are rarely queried, and when they are, performance expectations are low. Our issue was operational overhead : backup time, restore time, and the cost of running large batch operations over the full dataset. Sharding woul

Opening hook The silence in the room was absolute, save for the rhythmic scratching of pens against paper during a final exam. I was three rows back, feeling confident, until my phone decided to vibrate against the wooden desk. It wasn't a subtle hum; it was a rhythmic, aggressive buzz that echoed like a snare drum in a cathedral. Every single head turned in my direction. I scrambled to silence the device, but in my panic, I fumbled the power button. That moment of pure, unadulterated embarrassment was the catalyst for everything I have built since. The problem We live in an age where our devices are supposed to be smart, yet they consistently fail at the most basic context-aware tasks. We have high-end processors, sophisticated neural engines, and sophisticated sensor arrays, but we still have to manually toggle a 'silent' switch before entering a meeting, a lecture, or a mosque. The friction isn't just the act of flipping a switch; it is the cognitive load of remembering to do it and, more importantly, remembering to turn it back on afterward. I spent months living with the anxiety of a phone that might ring at the worst possible time. I tried existing automation tools, but they were either bloated, relied on cloud-based tracking that hammered my battery, or lacked the granular control I needed for specific locations. Most apps that promised location-based sound management were either imprecise or drained my battery by keeping the GPS radio active around the clock. I didn't want a heavy-duty tracking app; I wanted a silent, background-native utility that respected the hardware constraints of the Android platform while solving the specific problem of environmental sound management. The technical decision / implementation When I started building Muffle, my primary constraint was the battery. Android users are rightfully protective of their background processes, and if my app showed up as a primary battery consumer in settings, it was effectively useless. I had to de

Opening hook It happened during a quiet Friday Jumu'ah prayer. The imam had just reached the most solemn part of the khutbah when a high-pitched, insistent ringtone echoed through the entire hall. Heads turned, whispers started, and the person responsible scrambled to silence their device, only to fumble and drop it in their haste. I sat there, mortified for them, knowing exactly how that sinking feeling felt. It is the universal experience of the modern digital age: the gap between our intentions to be polite and our actual ability to manage our phone's state in public spaces. The problem We live in a world of constant notification, yet we lack a standard way to govern our devices based on our physical context. Android provides AudioManager and NotificationManager , but these are reactive tools that require manual input. I tried using standard alarm-based triggers, but they lacked the spatial awareness I needed. If I am at the office, I want my phone on vibrate. If I am at home, I want it back to normal. If I am at a medical clinic, I need it on silent. Most existing solutions rely on heavy GPS polling, which drains the battery within hours. They treat location services as a raw stream of coordinate data rather than a state-based trigger. I wanted something that functioned entirely in the background, survived system reboots, and operated without a constant drain on the user's battery life. The friction wasn't just about silence; it was about the cognitive load of having to remember to switch profiles. I wanted my phone to handle the context switching for me, autonomously and reliably, without becoming a battery-draining nightmare. The technical decision / implementation To solve this, I moved away from manual polling and adopted the GeofencingClient within the Google Play Services location APIs. The decision to use this over raw LocationManager updates was rooted in battery efficiency. The GeofencingClient pushes the heavy lifting to the OS level. It uses a combina

It happened during a quiet Friday sermon at the local masjid. The room was dense with silence, the kind that feels heavy and intentional. Suddenly, a jarring ringtone shattered the atmosphere—someone’s phone, vibrating against the hardwood floor. It wasn't my phone, but the collective wince of the entire room was visceral. A hundred people stopped mid-thought, turning their heads toward the source of the noise. I sat there, my own phone tucked in my pocket, realizing that I had almost been that person just a week prior. It was a moment of pure, avoidable human friction. We live in an age where our devices are supposed to be smart, yet they consistently fail at the most basic context-awareness. I found myself manually toggling my sound profile before every meeting, lecture, or appointment. It is a recurring cognitive tax. If I remembered, great. If I forgot, I risked social embarrassment. Even worse, once the meeting ended, I would inevitably leave my phone on silent for the rest of the day, missing important calls from family or clients. Existing solutions often felt like overkill—they required account creation, constant background sync to a cloud server, or permissions that felt invasive for a task as simple as changing a volume setting. I wanted something that lived entirely on the device, functioning as a silent, invisible utility that didn't need to 'phone home' to function. When I started building Muffle, I decided early on that the entire architecture would be zero-cloud. This wasn't just a philosophical choice; it was a technical constraint I imposed to ensure the app remained performant and trustworthy. By forcing myself to avoid backend dependencies, I had to rely heavily on Android’s AlarmManager and ForegroundService patterns. The biggest challenge was the 'Prayer Time' trigger. Most developers would reach for a Firebase Cloud Function to calculate these times based on the user's location. Instead, I integrated the Adhan library locally. I had to handle c

Picture a field technician standing in a basement with zero signal, trying to get an app to summarize a maintenance log and flag anything that looks like a safety issue. Or a language app that needs to correct pronunciation in real time, mid-commute, on a subway with no connectivity at all. A few years ago, both of those scenarios meant either building a degraded offline mode or just telling the user to try again later. Neither answer felt great. That's the actual reason on-device AI has become a real conversation in Android development in 2026, not because it's the trendy thing to bolt onto a feature list. Running inference locally solves specific, concrete problems: it keeps sensitive data off the network, it removes the round-trip latency of a cloud call, it works when there's no connectivity at all, and it gives you more predictable operating costs since you're not paying per-token for every user interaction. None of that means cloud AI is going away, and I'd be skeptical of anyone telling you it is. Most production apps in 2026 end up running a mix of both. But there's now a real, practical case for pushing certain workloads onto the device itself, and that's what this article is actually about - where local inference genuinely helps, where it falls short, and what it takes to build it properly in Kotlin. What Is On-Device AI? On-device AI means running a machine learning model directly on the user's phone, using the device's own CPU, GPU, or NPU, instead of sending a request to a server somewhere and waiting for a response. The model, or at least the parts of it needed for inference, lives on the device. Cloud AI still has the advantage in raw model size and reasoning depth - nobody's running a 70-billion-parameter model on a phone, at least not yet. But for narrower, well-defined tasks, on-device models have become genuinely capable, and the trade-offs are worth understanding side by side. Factor On-Device AI Cloud AI Inference location Runs on the user's dev

I've always found reading hard. Long documents slide off my attention, and I lose my place constantly. What I really wanted was something that would read to me and show me the words as it went — so my eyes and ears stayed in sync. Nothing did exactly that, so I built it. It's called ReadAloud , it's on Google Play, and this post is the "why" and the interesting bits of the "how." The moment it became real The first person I showed a rough build to was my Sister, Praise . She'd come to town to officiate a Women's Premier League match at Auntie Aku Astro Turf Park, and I pulled out my phone between everything else. She watched a paragraph read itself aloud with each word lighting up and got genuinely excited — that was the push I needed. She became tester #1. My colleague Reggie became tester #2. Between them they found the rough edges I'd stopped seeing, and the app settled into something stable. What it is A text-to-speech reader for PDFs, EPUB, DOCX, plain text and web articles . It reads aloud in natural voices, highlights each word as it speaks , and auto-scrolls to follow along. There's offline listening, English/French/Spanish, speed-reading (RSVP), a vocabulary builder, and reading stats. The stack: Kotlin, Jetpack Compose + Material 3, MVVM + Clean Architecture, Hilt, Room, DataStore, WorkManager , minSdk 26 . Now the parts that were actually interesting to build. 1. Word-by-word highlighting This is the whole product, so it had to be right. On-device voices are easy — Android's TextToSpeech gives you onRangeStart (API 26+), which fires per spoken range: override fun onRangeStart ( utteranceId : String , start : Int , end : Int , frame : Int ) { // highlight the substring [start, end) in the reader _currentRange . value = start to end } The catch: the natural cloud voices people actually want don't emit onRangeStart . So for cloud synthesis I wrap each word in an SSML <mark> and ask Google Cloud TTS to return timepoints : <speak><mark name= "w0" /> Every <mar

The Silent Disruptor The silence in the room was absolute, broken only by the rhythmic scraping of pens on paper during a high-stakes meeting. Then, it happened. My pocket erupted into a frantic, brassy ringtone that seemed to last an eternity before I could fumble to silence it. My face turned crimson as the room’s focus shifted from the presentation to my vibrating trouser pocket. I had remembered to check my calendar, but I had completely forgotten to toggle my phone to silent mode. That moment of pure, concentrated embarrassment was the catalyst for me building Muffle. The Friction of Manual Control We live in an age of automation, yet our phones—the very devices meant to assist us—remain stubbornly manual when it comes to basic social etiquette. Every day, millions of people walk into mosques for prayer, classrooms for lectures, or medical offices for consultations, and every day, a percentage of them forget to silence their devices. This isn't just a minor annoyance; it is a persistent source of social friction. Before I started building Muffle, I looked for existing solutions. Most apps were either bloated with unnecessary permissions, required invasive cloud accounts, or simply failed to trigger at the right time. The fundamental problem wasn't just the lack of features like GPS-based prayer times or calendar-specific automation; it was the lack of reliability. If an automation app fails once, the user loses trust in it forever. If I am in a meeting, I cannot afford for the app to 'sleep' because the system decided to save battery at the expense of my configured routine. I needed something that could handle these state changes consistently, regardless of whether the phone was in my pocket, sitting on a desk, or buried in a bag. Architecting for Reliability When I began writing the core logic for Muffle, I immediately hit the wall that every Android developer eventually faces: Doze Mode. Android’s aggressive power management is designed to preserve battery by

It happened during a medical appointment. I was sitting in the quiet waiting room, my thoughts occupied by the upcoming consultation, when my phone erupted with a loud, aggressive ringtone. The entire room turned to look at me, and I fumbled to silence it, accidentally hitting the volume up button instead of the mute toggle in my panic. I felt that specific, burning embarrassment that comes from being the person who disrupts a quiet space. I realized then that I had spent years writing code for others, yet I couldn't solve my own basic problem of managing my phone's profile. We live in a world of constant notifications and persistent demands on our attention. The real friction isn't just that phones ring; it's that we are expected to remember to manually toggle settings in a dozen different contexts every single day. Whether it is a classroom, a house of worship, or a professional meeting, the human element of remembering to flip a switch is the point of failure. I wanted an app that handled this silently, without me having to open an interface or even think about the current state of my device. I needed a system that functioned as an extension of my environment rather than an additional task. Building Muffle required me to confront the reality of modern Android background execution. Initially, I thought a simple BroadcastReceiver listening for time changes or geofence triggers would suffice. I was wrong. As soon as the phone entered Doze mode—the power-saving state introduced in Android 6.0—my triggers would either be delayed significantly or killed entirely by the system’s restrictive task scheduler. I had to architect a solution that could survive these aggressive optimizations while remaining battery-efficient. The core of the application resides in a ForegroundService that maintains a persistent notification. While many developers avoid these because of the UI footprint, it is the only way to signal to the OS that your process is performing an essential, user-v

We just bumped four dependencies in the app. Here's what each one brings. implementation 'androidx.constraintlayout:constraintlayout:2.2.2' implementation platform ( 'com.google.firebase:firebase-bom:34.17.0' ) implementation 'io.intercom.android:intercom-sdk:18.6.0' implementation 'com.auth0.android:auth0:4.0.1' ConstraintLayout 2.2.2 The library's in maintenance mode now — Google's steering everyone toward Compose for new UI — so releases here are small, focused patches. This one carries forward a binary compatibility fix in constraintlayout-core that landed in the 2.2.x line. Firebase BoM 34.17.0 The BoM pins compatible versions across every Firebase library you pull in. This release lands close behind: Firebase AI Logic (17.14.0) — new factory methods exposing thoughtSignature / isThought on response parts, plus automatic function calling for LiveGenerativeModel Authentication (24.2.0) — fixed an auth timeout on dual-stack Wi-Fi, where long IPv6 timeouts were blocking IPv4 fallback Cloud Firestore (26.4.1) — now caches documents over 1MB by chunk-reading from local SQLite; fixed a debug-logging OOM caused by large payloads Cloud Messaging (25.1.1) — fixed a re-registration bug tied to Firebase installation ID changes Crashlytics (20.1.0) — on API 37+, fatal event reports now carry OOM/anomaly context from the ProfilingManager API Firebase Installations (19.1.2) — internal storage moved from SharedPreferences to DataStore Performance Monitoring (22.0.6) — fixed _app_start traces getting incorrectly suppressed on API 34+ SQL Connect (17.3.2) — several fixes to realtime query subscriptions around auth-token refresh and expiry Intercom Android SDK 18.6.0 Pinch-to-zoom, double-tap-to-zoom, and pan on full-screen image attachments Fixed an ANR during Intercom.initialize() caused by Keystore and persisted-identity reads blocking the calling thread Fixed the keyboard covering form fields in Canvas Kit sheets — IME insets are now handled correctly Fixed a crash from a nu

This tutorial builds a starter "Hello World" style agent using Kotlin and the native Kotlin version of the Agent Development Kit (ADK). The full sample project is available on GitHub: xbill9 / adk-hello-world-kotlin Kotlin ADK and MCP Hello World This project is a runnable Kotlin Agent Development Kit (ADK) demo. A Kotlin LlmAgent uses Gemini to decide when to call a greet tool discovered from a local Kotlin Model Context Protocol (MCP) server. The project has two Gradle modules: agent : the Kotlin ADK agent, Gemini model configuration, MCP toolset, and interactive ReplRunner ; server : the Ktor MCP server that exposes greet . Technology Stack Kotlin: 2.3.0 Kotlin ADK SDK: com.google.adk:google-adk-kotlin-core (v0.6.0) MCP Kotlin SDK: io.modelcontextprotocol:kotlin-sdk-jvm (v0.8.1) Ktor Framework: 3.0.0 (Netty, SSE, ContentNegotiation, CORS) JDK: Java 25 Build System: Gradle 9.2.1 (Kotlin DSL) Prerequisites Java 25 A Gemini Developer API key The Gradle wrapper is included. Configure Gemini Create the local environment file: cp .env.example .env Set GOOGLE_API_KEY in .env , then load it: source ./set_env.sh The file is ignored by Git. Run the Demo Start the Kotlin MCP server in one… View on GitHub What Is Kotlin? Kotlin is a modern, statically typed programming language created by JetBrains. It runs on the Java Virtual Machine (JVM), works alongside existing Java libraries, and is widely used for Android, backend, and multiplatform development. Static typing is especially useful when building agents. Agent configuration, tool schemas, and tool results can all be checked by the compiler before a prompt reaches the model. Installing Java This sample uses Java 25 . If Java is not installed, SDKMAN! is a convenient way to install and switch between JDK versions on Linux and macOS: Home | SDKMAN! the Software Development Kit Manager SDKMAN! is a tool for managing parallel versions of multiple Software Development Kits on most Unix based systems. sdkman.io After installing

Elena van Engelen discusses how to eliminate serverless vendor lock-in without sacrificing native cloud capabilities. She explains how to structure FaaS applications using Clean Architecture, Spring Cloud Function, and Gradle modules to isolate business logic. Finally, she shares a live demo deploying portable Kotlin services across AWS and Azure using Terraform CDK for multi-cloud IaC. By Elena van Engelen

Most Android media apps solve only one part of the problem. A video player plays videos. A music player handles songs. A PDF reader displays documents. A text-to-speech app reads text. A vault hides private files. But real media libraries are not separated that neatly. My phone may contain downloaded movies, music, lecture notes, ebooks, PDFs, recordings, subtitles, and files I do not want exposed in the normal gallery. Constantly moving between different apps creates friction and breaks playback or reading continuity. That is why I built Nexo Player : an offline-first Android media app that brings local playback, document reading, audiobook generation, text-to-speech, and private storage into one experience. What Nexo Player does Nexo Player currently supports: Local video and audio playback PDF and EPUB reading PDF, EPUB, and text narration Background audiobook generation MP3, M4B, and ZIP export Multiple narrator voices Resume playback and reading progress Equalizer, sleep timer, subtitles, and playback-speed controls Picture-in-Picture Secure Vault protected with PIN or biometrics The app is built natively for Android using Kotlin , Jetpack Compose , and Android Media3 . The main product idea: local-first media The core rule behind the app is simple: A local file should remain local unless the user explicitly chooses otherwise. This rule influenced the entire product. Opening a downloaded video should not require an account. Reading a PDF should not require uploading it to a server. Listening to a generated audiobook should remain possible without a permanent internet connection. Private files should not leak into normal galleries, thumbnails, or recent-history screens. Offline-first is not only about caching data. It means the main workflow must remain useful, understandable, and recoverable without depending on the network. Building the playback layer For video and audio playback, I used Android Media3 as the foundation. The visible player looks simple, but a