Let’s talk about something that trips up a lot of Android developers — especially when building apps with complex navigation: the Android Back Stack. You know that moment when you hit the back button and your app behaves like it has a mind of its own? Yeah, we’ve all been there. The Android Back Stack can be...
You build a clean UI, test it on your emulator, and everything looks solid. But once QA or users get their hands on it, layout bugs pop up — text overflowing, views misaligned, odd paddings. It happens more often than we like to admit. That’s where the Paparazzi Testing Library proves its worth. It’s a powerful snapshot...
When building Android apps, it’s easy to focus only on the code, UI, and features. But behind every successful app lies a set of powerful, low-level tools that keep the whole process moving. These are the Android SDK Tools — the unsung heroes of the Android development ecosystem.
In this post, we’ll break down what they are, how they work, and why every Android developer should understand them — even in the age of Android Studio.
Android SDK Tools are a collection of command-line utilities that help you build, test, and debug Android apps. They used to be packaged together as “SDK Tools,” but over time, they’ve been split into modular components like:
platform-tools — includes ADB, fastboot, and other core tools.build-tools — includes utilities like aapt, zipalign, etc.Even though Android Studio handles much of this behind the scenes, these tools are still critical — especially when things go wrong, or when you want to automate development tasks.
Let’s take a closer look at the key tools that power Android development under the hood:
ADB is a command-line tool that lets your computer communicate with an Android device or emulator.
Think of it as a remote control for your Android environment. You can install apps, copy files, debug logs, and even run shell commands directly on the device.
Common ADB Commands:
adb devices # Lists connected devices
adb install myapp.apk # Installs an APK
adb logcat # Displays real-time device logsThis is one of the most valuable tools in your toolbox, especially for real-time debugging.
When your device is in bootloader mode, fastboot lets you flash images to the device, unlock the bootloader, and perform other low-level operations.
It’s typically used for:
While not every developer uses fastboot regularly, it’s indispensable for anyone working near the hardware layer or with custom builds.
Originally, ProGuard was used to shrink and obfuscate Java code in Android apps. Today, R8 has replaced it as the default tool for most modern Android projects.
R8 performs:
R8 is built into the Android Gradle plugin, so you don’t typically run it manually — but understanding what it does can help you configure it properly in
proguard-rules.pro.
Even though Android Studio and Gradle handle most of the heavy lifting today, knowing how SDK tools work gives you:
When something breaks outside the Studio UI, these tools are often your first (and best) line of defense.
The Android SDK Tools may not be glamorous, but they are the engine under the hood of Android development. Whether you’re pushing your first APK or debugging a complex issue, understanding ADB, fastboot, and R8 will make you a more capable — and confident — developer.
Let me guess. You’ve nailed your application code, CI/CD pipelines are humming, deployments are smooth… until it comes to the database. Suddenly, things get messy. Manual SQL scripts, environment inconsistencies, and mystery errors that only appear in prod. Sound familiar..? That’s where Liquibase comes in. What Is Liquibase? Liquibase is an open-source database change management...
Have you ever looked at a finished gadget, app, or piece of code and thought, “How the heck did they build this?” That’s exactly where Reverse Engineering comes in — it’s like digital archaeology for modern tech. Whether you’re a curious developer, cybersecurity enthusiast, or just someone who loves figuring things out, reverse engineering is a fascinating skill to explore.
In this post, we’ll break it all down — from the concept of reverse engineering to real code examples — so you walk away not only knowing what it is, but how to start doing it.
At its core, Reverse Engineering is the process of taking something apart to understand how it works — then documenting, modifying, or improving it. While it originally came from mechanical engineering (think tearing down an engine), today it’s widely used in software, cybersecurity, game modding, and even competitive hacking (CTFs).
Imagine you have a compiled program, but no access to the source code. Reverse engineering lets you peel back the layers to uncover the logic, data structures, and behavior hidden inside.
Here are a few real-world reasons people dive into reverse engineering:
Let’s look at a simplified breakdown of the process:
Let’s split this into two main categories: hardware and software.
This often involves examining physical components — like circuit boards or mechanical parts. Engineers may take high-resolution images, use 3D scanning, or map out circuitry by hand.
Example: If a critical component in a legacy machine fails, and the manufacturer no longer exists, reverse engineering helps recreate or replace that part.
This can be broken into two techniques:
1. Static Analysis
You inspect the software without running it. This involves:
2. Dynamic Analysis
Here, you run the software and monitor what it does. Tools like OllyDbg, x64dbg, or Wireshark let you:
Before we jump into code, here are a few tools you’ll often see in reverse engineering:
Let’s say you find a mysterious binary function. After decompiling, you see this assembly code:
push ebp
mov ebp, esp
mov eax, [ebp+8]
add eax, 5
pop ebp
retEven if you’re not a pro, this pattern is pretty straightforward. Here’s how it works:
push ebp / mov ebp, esp: standard setup for a functionmov eax, [ebp+8]: grabs the first argument passed to the functionadd eax, 5: adds 5 to itret: returns the resultThis is likely the compiled version of:
int addFive(int x) {
return x + 5;
}That’s reverse engineering — working backwards from machine instructions to human-readable logic.
Good question..! The answer isn’t black and white — it largely depends on what you’re doing and where you’re doing it.
If you’re reverse engineering for educational purposes or security research — and not distributing pirated software or stolen code — you’re likely in the clear.
Always read license agreements and check local laws carefully before diving in.
Reverse Engineering isn’t just for hackers in hoodies — it’s a powerful way to understand, learn, and even protect software systems. Whether you’re analyzing malware, figuring out a legacy application, or just learning how binaries work, this skill puts you in control of what’s normally a black box.
By starting small, using the right tools, and staying curious, you can turn the mysterious world of compiled code into something you can read, modify, and even improve.
So next time you encounter an executable and wonder what’s inside, fire up your debugger and take a peek — you might just discover something amazing.
strings, objdump, and Ghidra.
Let’s talk about something that’s become way too common: ransomware. If you’ve never heard of it before, or if you’ve heard the word but aren’t exactly sure what it means, don’t worry — you’re not alone. I wrote this guide to give you the real-world, no-BS breakdown of what ransomware is, how it spreads, and what you can do to protect yourself. Whether you’re running a business or just trying to keep your personal laptop safe, this is for you.
Ransomware is a type of malicious software (malware) that locks you out of your files or entire system until you pay a ransom. It’s like a digital hostage situation. The attacker usually demands payment in cryptocurrency (like Bitcoin) because it’s harder to trace.
Once it gets into your system, it starts encrypting your files — basically scrambling them so you can’t open anything. Then it flashes a message on your screen saying something like,
“Your files are locked. Pay us $500 in Bitcoin or lose everything.”
And here’s the kicker: even if you pay, there’s no guarantee you’ll get your files back.
Ransomware doesn’t just fall from the sky. It usually sneaks in through one of these methods:
This isn’t just a problem for big companies. Ransomware hits schools, hospitals, local governments, and regular people every day. Some folks lose precious family photos, years of work, or personal records. For businesses, downtime can cost thousands — or millions.
What’s worse, some newer strains of ransomware not only encrypt your files but also threaten to leak them online if you don’t pay. That’s a double whammy.
Alright, now that we’ve covered the scary part, here’s the good news: you can protect yourself. Here are the essentials:
Make backing up your files a habit. Use an external hard drive or cloud storage (ideally both). If ransomware hits and you have clean backups, you can just wipe your system and restore your stuff.
Updates aren’t just annoying popups — they fix vulnerabilities that attackers exploit. Turn on automatic updates for your operating system, antivirus, browsers, and any other key software.
Make sure you have a solid antivirus program running. Windows Defender is decent, but for extra peace of mind, consider additional tools like Malwarebytes.
If an email seems off, don’t click anything. Look for misspellings, weird addresses, and urgent language. Hover over links before clicking to see where they actually lead.
Did you know Windows has built-in ransomware protection?
Here’s how to enable it:
1. Open "Windows Security"
2. Click on "Virus & threat protection"
3. Scroll down to "Ransomware protection"
4. Click "Manage ransomware protection"
5. Turn on "Controlled folder access"This feature blocks unauthorized apps from accessing important folders.
If someone steals your password, MFA can still block them. It’s a simple way to add a serious layer of protection.
First: Don’t pay the ransom. Paying doesn’t guarantee your files will be restored, and it just funds more attacks.
Here’s what to do:
If you’re stuck and need help, look into organizations like No More Ransom (nomoreransom.org). They offer free decryption tools for certain types of ransomware.
Ransomware isn’t going away anytime soon, but that doesn’t mean you have to live in fear. By understanding how it works and taking some basic steps, you can avoid becoming a victim.
If there’s one takeaway from this post, it’s this: Backup your data today. Seriously. Do it now.
Selenium is a free, open-source framework used to automate web browsers. Developers and QA engineers rely on it to:
Originally created in 2004, Selenium has evolved into the industry-standard tool for browser-based testing. It’s flexible, powerful, and backed by a strong community.
Selenium consists of several key parts:
The primary focus here is WebDriver, which interacts with the browser by simulating mouse movements, clicks, form entries, and more. Let’s explore a basic example.
pip install seleniumYou also need a WebDriver executable for your browser (e.g., chromedriver for Chrome).
Create a file named test_google_search.py:
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
# 1. Launch browser
driver = webdriver.Chrome()
try:
# 2. Go to Google
driver.get('https://www.google.com')
# 3. Locate search box
search_box = driver.find_element('name', 'q')
# 4. Type and press Enter
search_box.send_keys('Selenium testing')
search_box.send_keys(Keys.RETURN)
# 5. Print title
print("Page title is:", driver.title)
finally:
# 6. Close browser
driver.quit()What’s happening?
webdriver and Keys for browser control and keyboard interaction.Let’s assert that the title contains “Selenium”:
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Chrome()
driver.get('https://www.google.com')
search_box = driver.find_element('name', 'q')
search_box.send_keys('Selenium testing')
search_box.send_keys(Keys.RETURN)
assert 'Selenium' in driver.title, "Selenium not found in title"
print("Test passed. Title contains 'Selenium'")
driver.quit()try/finally, but you’ll want try/finally in real-world tests for safety.1. Use explicit waits, not time.sleep, to wait for page elements:
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
wait = WebDriverWait(driver, 10)
element = wait.until(EC.presence_of_element_located((By.NAME, 'q')))2. Use Page Object Model (POM) to organize locators and actions into classes.
3. Parameterize tests (e.g., search terms) to reuse code.
4. Log actions and screenshots for easier debugging.
pytest-selenium and selenium-page-factory help structure and scale tests.Use selenium if you need to:
Avoid or complement selenium if:
pytest, requests, etc.Selenium is a powerful, established tool that helps you automate web browsers exactly how a user would interact with them. With support for multiple languages, browsers, and platforms, it’s an essential component in web test automation. By following clean code practices, using waits, and organizing your tests, you’ll master selenium quickly — and write reliable, maintainable tests.
If you’re tired of repeating the same dependencies across different modules in your Android project, you’re not alone. Managing dependencies manually is error-prone, messy, and not scalable. Fortunately, Bundles in libs.versions.toml offer a clean and modern solution that saves time and reduces duplication. Let’s break it down, step by step, in a simple way. What...
Managing data on Android has evolved significantly over the years. From SharedPreferences to Room, we’ve seen the full spectrum. But when it comes to storing structured, complex data in a lightweight and efficient way, Proto DataStore steps in as a game-changer.
In this blog, we’ll walk through Proto DataStore, how it works under the hood, and how to use it with Protocol Buffers to store complex objects. We’ll also look at how it stacks up against the older SharedPreferences and why it’s the better modern choice.
Let’s break it down step by step.
Proto DataStore is a Jetpack library from Google that helps you store typed objects persistently using Protocol Buffers (protobuf), a fast and efficient serialization format.
It’s:
Unlike Preferences DataStore, which stores data in key-value pairs (similar to SharedPreferences), Proto DataStore is ideal for storing structured data models.
Here’s why developers love Proto DataStore:
Let’s go hands-on. Suppose you want to save a user profile with fields like name, email, age, and preferences.
Add these to your build.gradle (app-level):
dependencies {
implementation "androidx.datastore:datastore:1.1.0"
implementation "androidx.datastore:datastore-core:1.1.0"
implementation "com.google.protobuf:protobuf-javalite:3.25.1"
}In your build.gradle (project-level), enable Protobuf:
protobuf {
protoc {
artifact = "com.google.protobuf:protoc:3.25.1"
}
generateProtoTasks {
all().each { task ->
task.builtins {
java { }
}
}
}
}Also apply plugins at the top:
plugins {
id 'com.google.protobuf' version '0.9.4'
id 'kotlin-kapt'
}.proto FileCreate a file named user.proto inside src/main/proto/:
syntax = "proto3";
option java_package = "com.softaai.datastore";
option java_multiple_files = true;
message UserProfile {
string name = 1;
string email = 2;
int32 age = 3;
bool isDarkMode = 4;
}This defines a structured data model for the user profile.
Create a Kotlin class that implements Serializer<UserProfile>:
object UserProfileSerializer : Serializer<UserProfile> {
override val defaultValue: UserProfile = UserProfile.getDefaultInstance()
override suspend fun readFrom(input: InputStream): UserProfile {
return UserProfile.parseFrom(input)
}
override suspend fun writeTo(t: UserProfile, output: OutputStream) {
t.writeTo(output)
}
}This handles how the data is read and written to disk using protobuf.
Create a DataStore instance in your repository or a singleton:
val Context.userProfileDataStore: DataStore<UserProfile> by dataStore(
fileName = "user_profile.pb",
serializer = UserProfileSerializer
)Now you can access this instance using context.userProfileDataStore.
Here’s how you read the stored profile using Kotlin Flow:
val userProfileFlow: Flow<UserProfile> = context.userProfileDataStore.dataTo update the profile:
suspend fun updateUserProfile(context: Context) {
context.userProfileDataStore.updateData { currentProfile ->
currentProfile.toBuilder()
.setName("Amol Pawar")
.setEmail("[email protected]")
.setAge(28)
.setIsDarkMode(true)
.build()
}
}Easy, clean, and fully type-safe.
You can customize the corruption handler if needed:
val Context.safeUserProfileStore: DataStore<UserProfile> by dataStore(
fileName = "user_profile.pb",
serializer = UserProfileSerializer,
corruptionHandler = ReplaceFileCorruptionHandler {
UserProfile.getDefaultInstance()
}
)If you’re switching from SharedPreferences:
val Context.migratedUserProfileStore: DataStore<UserProfile> by dataStore(
fileName = "user_profile.pb",
serializer = UserProfileSerializer,
produceMigrations = { context ->
listOf(SharedPreferencesMigration(context, "old_prefs_name"))
}
)Use Proto DataStore when:
Avoid it for relational data (instead use Room) or for simple flags (Preferences DataStore may suffice).
Proto DataStore is the future-forward way to store structured data in Android apps. With Protocol Buffers at its core, it combines speed, safety, and type-safety into one clean package.
Whether you’re building a user profile system, app settings, or configuration storage, Proto DataStore helps you stay efficient and future-ready.
Q: What is Proto DataStore in Android?
A: Proto DataStore is a modern Jetpack library that uses Protocol Buffers to store structured, type-safe data asynchronously and persistently.
Q: How do I store complex objects using Proto DataStore?
A: Define a .proto schema, set up a serializer, initialize the DataStore, and read/write using Flow and coroutines.
Q: Why is Proto DataStore better than SharedPreferences?
A: It’s type-safe, faster, handles corruption, and integrates with Kotlin coroutines.
If you’re still using SharedPreferences in your Android app, it’s time to move forward. Google introduced Jetpack DataStore as a modern, efficient, and fully asynchronous solution for storing key-value pairs and typed objects. In this blog, we’ll break down what Jetpack DataStore is, why it’s better than SharedPreferences, and how you can use it effectively...