标签：#android

Google will start policing memory-hungry Android apps as a direct response to the RAM crisis. Spotted by TechCrunch, the company yesterday published a memo addressing the Play Store's role in enforcing new memory-usage restrictions. The post emphasizes the importance of meeting new memory usage limits for apps, in order "to help developers navigate industry-wide hardware […]

Google is setting new memory-use limits for Android apps as AI data centers contribute to hardware shortages that could leave lower-cost phones with less memory.

From Termux to a Freestyle VM: My Osintgram and HikerAPI Experiment After experimenting with Osintgram directly in Termux, I wanted to see how the same project behaved inside a Linux environment running through a Freestyle VM. The idea was not simply to reproduce the installation. I wanted to understand whether moving the project into the VM would make the HikerAPI troubleshooting any clearer. Why use a VM? Termux is capable of running many command-line tools directly on Android, but a VM provides a more conventional Linux environment. I connected to the Freestyle VM from Termux and worked with Osintgram from there. The project could start, but the API side still required investigation. The dependency confusion One of the first things I noticed was that there were multiple API-related components involved. I initially looked at the installed "hikerapi" package and its "Client" class. That alone wasn't enough to explain what Osintgram was doing. So I switched from inspecting only the Python environment to inspecting the project's source code. The HikerAPI-related code pointed me toward: src/hikercli.py This was much more informative because it showed where the client was being configured and how the access token entered the application. Checking the installed library I also checked the installed HikerAPI package rather than assuming I had the expected version. For example: python3 -m pip show hikerapi This let me verify the package that was actually installed in the VM. The important point here is that checking a package version and understanding how the application uses that package are two different troubleshooting steps. Separating authentication from Osintgram I found it useful to test the API independently instead of using Osintgram as the only diagnostic tool. For example: import requests headers = { "x-access-key": "YOUR_KEY" } r = requests.get( " https://api.hikerapi.com/v2/user/by/username?username=natgeo ", headers=headers ) print(r.json()) Again, "YOUR_KEY"

A polished update to Google’s foldable brings real improvements, but the price bump and rampant competition make it a tough sell.

It's currently only appearing on Pixels running Android 17.

With the new design of Nothing OS 5.0, app icons and widgets can use adaptive color to get color tints pulled from your wallpaper, which update whenever your wallpaper changes. Alongside Android's built-in Dynamic Colors, the company says it allows you to have specific elements change to match your wallpaper "while Nothing's predominantly monochrome character […]

Google is rolling out a new Android feature that's been proven to reduce, or even eliminate, motion sickness when using a phone inside a moving vehicle. Dubbed Motion Assist by Google, it's very similar to Apple's Motion Cues, first introduced in 2024. The Android 17 feature appears to be rolling out in phases, with some […]

GrapheneOS, an open source version of Android that prioritizes security and privacy, has detailed its plans for supporting Motorola smartphones. Official support is set to arrive next year, starting with traditional flagships, before rolling out to Motorola's foldable phones and perhaps cheaper models, eventually. In a Mastodon thread, the GrapheneOS Foundation announced that it will […]

How to get a photo below a strict KB limit Many government portals, job forms, school applications, and support websites reject an otherwise valid photo because it is larger than a fixed limit such as 100 KB or 200 KB. Standard gallery apps usually offer cropping or a quality percentage, but they do not tell you whether the final file will meet a specific upload limit. That is the problem I built FormFit to solve on Android. Why exact-KB compression is tricky File size depends on more than width and height. Image detail, color variation, output format, and compression quality all affect the result. A quality setting that works for one photo may leave another photo far above the required size. FormFit works toward a maximum KB target and adjusts the generated copy for you. The practical goal is to create a file at or below the limit while keeping it as clear as possible. Compress a photo on Android Install FormFit from Google Play . Open the photo-compression tool and select the image you need to upload. Enter the maximum file size required by the website or form. Optionally resize the image dimensions or choose JPG, PNG, or WebP for the generated copy. Run the compression, review the result, and save or share the new file. The original photo is not replaced. FormFit creates a separate output copy, so you can compare the result before uploading it. Remove metadata from generated copies Photos can contain metadata such as device or capture information. When you only need to submit the visible image, FormFit can remove metadata from the generated copy. This does not change the original file. Turn several photos into one PDF Some forms ask for a single PDF instead of multiple image files. FormFit can combine up to 20 selected photos into one PDF directly on the phone. This is useful for receipts, scanned notes, application documents, and other small document sets. On-device processing The selected photos and PDFs are processed on the Android device. FormFit does not req

📚 This is part 2 of a series. Part 1: The Origin Story Part 2: [Current Article] Part 3: Coming soon... Let me tell you about the day my crash reporting UI crashed. The Grey Screen One afternoon, my Android app's crash screen rendered all-grey. No content. No report button. Just a blank slate where the app's last line of defense should have been. The root cause? A stale file from Gradle's build cache after a major refactor. The compiled resource IDs no longer matched the packaged resource table. ViewBinding inflated the wrong layout, and a silent NullPointerException killed the crash screen itself. It was invisible in CI. It only appeared in specific rebuild scenarios. And it took hours to trace. That bug taught me something important: The fix isn't done when the patch ships. It's done when the lesson becomes automated. So I wrote a build-time task that reads the compiled class files directly, compares them against the final packaged resources, and verifies every constant matches. It runs automatically after every packaging step. You never have to remember to invoke it. That was the first of many incident-driven tools I built. The FAB That Disappeared A few weeks later, a developer tools Floating Action Button vanished from consumer apps. Debug menus inaccessible. Secure screens incorrectly enabled. Turns out, my shared library's BuildConfigUtils was reading the library's own BuildConfig —which is baked as "release" at publish time. An AAR can never know the consumer's build type. 25 files across 34 call sites were silently broken. I built a Gradle plugin that generates a SskBuildConfig object per consumer module, per variant, using AGP's onVariants callback. It registers generated source via KotlinCompile.source() —not reflection, which broke across AGP versions. It detects Android plugins by extension type, not hardcoded IDs, so it works with com.android.application , com.android.library , com.android.dynamic-feature , and any future Google plugin. Same package as

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

Small language models can now run directly on phones. But most of them stop learning the moment they ship. For personal AI, that feels like a strange stopping point. Some of the most useful signals arrive only after the model acts: Did the user dismiss the notification? Did they open it later? Did they rewrite the suggestion? Did they ask for it again? These interactions contain useful information about the user, but they are delayed, private, and ambiguous. They are not clean labels, and they are not reliable scalar rewards. To explore this problem, we built Online-SDFT , an open-source prototype that continually fine-tunes a small language model from delayed interactions while keeping the learning loop on the device. The prototype uses: LiquidAI/LFM2.5-230M A rank-4 LoRA adapter ONNX Runtime Training A bounded on-device replay buffer An Android notification-routing testbed Once the model has been provisioned, inference, interaction storage, replay, and adapter updates all happen locally. Why standard fine-tuning is awkward here Suppose the model receives a notification and chooses one of three actions: Show it now Save it for later Archive it Supervised fine-tuning would require a correct action for every notification. But the phone never observes what the ideal action was. Reinforcement learning replaces the correct answer with a reward, but that reward is also difficult to define. Opening a notification does not necessarily mean it arrived at the right time. Ignoring it does not necessarily mean it was unimportant. The user may simply have been busy. There is another complication: the model only observes the result of the action it actually took. If it archives a notification, it cannot know what would have happened had it shown the notification immediately. What the phone receives is not a label or reward. It receives hindsight . Using the same model as student and teacher The core idea is simple: let the model reconsider its decision after seeing what happened

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

It is possible to achieve your desired work-life balance on your smartphone. Just set up separate accounts using this built-in Android feature.

The private Android-based OS will expand beyond Pixels next year.

Incremental improvements fail to generate much excitement, but Google’s Pixel 11 is still an accomplished Android phone.

Google's new Pixels make some compromises but still manage to be good phones.

GrapheneOS 2027 Lands on Flagship Phones: Real‑World Privacy for Premium Android Users Introduction When GrapheneOS announced official support for Motorola, OnePlus and Sony’s top‑tier phones in early 2027, the tech community stopped scrolling. Within days the phrase “GrapheneOS Motorola” spiked 250 % on Google Trends and sparked a firestorm on Hacker News. Why the hype? Because for the first time a hardened, auditable Android fork is available on devices that don’t compromise on performance, camera quality, or design. In this guide you’ll get a hands‑on look at what GrapheneOS 2027 actually does, how to install it, and which commands and configuration tweaks let you turn a flagship phone into a privacy‑first workstation. Quick‑Start Checklist ✅ Item 1 Verify device compatibility (locked bootloader, Snapdragon 8 Gen 3, TEE) 2 Backup current ROM (e.g., adb backup -apk -shared -all -f backup.ab ) 3 Unlock bootloader ( fastboot oem unlock ) – note this wipes data 4 Flash GrapheneOS boot and system images (see “Flashing the ROM”) 5 Enable verified boot ( fastboot flashing lock ) 6 Install the optional Play Store Compatibility Layer (PSCL) if needed Supported Premium Devices (2027) Manufacturer Model Key Security HW Motorola Edge 30 Ultra Snapdragon 8 Gen 3, TEE, Secure Enclave OnePlus 12 Pro Snapdragon 8 Gen 3, TEE, Secure Enclave Sony Xperia 1 V Snapdragon 8 Gen 3, TEE, Secure Enclave Google Pixel 9 (reference) Snapdragon 8 Gen 3, Titan M2 All listed phones meet GrapheneOS’s Hardware Security Module (HSM) requirements: locked bootloader, hardware‑backed keystore, and a modern Trusted Execution Environment. How GrapheneOS Differs from Stock Android Feature Stock Android GrapheneOS 2027 Google Play Services Core system component, heavy telemetry Replaced by a sandboxed Play Store Compatibility Layer (PSCL) Kernel Standard Linux kernel with optional vendor patches Memory‑safe, mitigates Spectre/Meltdown, SELinux Enforcing by default App Sandbox Permissions granted per‑app

Most speech-to-text is benchmarked on audio that looks nothing like a WhatsApp voice note. The standard evaluation sets are read speech, broadcast news, or recorded interviews: single speaker, decent microphone, one language, quiet room, speaker aware they are being recorded. A WhatsApp voice note is close to the opposite on every axis. I have spent a while building around this, and the gap turned out to be wider than I expected. Acoustics Phone held at arm's length while walking, in a car, in a kitchen, on a street. Distance-to-mic varies wildly within a single recording , which breaks a lot of assumptions about consistent gain. Then there is the codec. Voice notes are Opus at low bitrate — efficient, but it discards exactly the high-frequency detail that helps disambiguate fricatives. /s/ versus /f/ versus /th/ get genuinely harder, and those distinctions carry real meaning. Register Conversational, not read. False starts, self-corrections, filler, trailing off mid-sentence, and long pauses that are not sentence boundaries — someone thinking, or getting distracted. Punctuation inference is much harder here than on read speech. And punctuation is most of what makes a transcript skimmable rather than a wall of text. A perfectly accurate word sequence with no paragraph breaks is close to useless if the point was to let someone read it faster than listening. Language This is the one that surprised me most. Voice notes are heavily code-switched. People drop English technical terms into Urdu, Hindi, Arabic, Spanish sentences constantly — not as an edge case, as the default register for a huge number of speakers. If you force a single language selection up front, you mangle every mixed utterance. Auto-detection is not a convenience feature in this domain. It is a correctness requirement. Length distribution Most notes are 5–45 seconds. Very little context to work with, and per-request overhead dominates if you architected for long files. Batching strategies that make sen