DEV Community: Prakhar Shakya

Why do webdev posts get so much engagement? Where are Java people?

Prakhar Shakya — Fri, 03 Jan 2025 05:59:20 +0000

A Comprehensive Guide to Mastering Kotlin Coroutines

Prakhar Shakya ・ Jan 3

A Comprehensive Guide to Mastering Kotlin Coroutines

Prakhar Shakya — Fri, 03 Jan 2025 05:54:04 +0000

Introduction

Coroutines simplify asynchronous programming by making it more readable and efficient. Think of threads as individual cars on a highway, each taking up space and resources. In contrast, coroutines are like carpooling - multiple tasks sharing resources efficiently.
Three main benefits make coroutines stand out:

Simplicity and readability in handling async operations
Efficient resource management compared to traditional threads
Enhanced code maintainability through structured concurrency

Setting Up Coroutines

To get started with coroutines in your Android project, add these dependencies to your build.gradle file:

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.1"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1"
}

Understanding Coroutine Builders

Coroutine builders are the foundation for creating and launching coroutines. Let's explore each type with practical examples:

Launch

class WeatherService {
    fun updateWeather() {
        lifecycleScope.launch {
            // Simulating weather API call
            val weather = fetchWeatherData()
            updateUI(weather)
        }
    }

    private suspend fun fetchWeatherData(): Weather {
        delay(1000) // Simulate network delay
        return Weather(temperature = 25, condition = "Sunny")
    }
}

Asynch

class StockPortfolio {
    suspend fun fetchPortfolioValue() {
        val stocksDeferred = async { fetchStockPrices() }
        val cryptoDeferred = async { fetchCryptoPrices() }

        // Wait for both results
        val totalValue = stocksDeferred.await() + cryptoDeferred.await()
        println("Portfolio value: $totalValue")
    }
}

Coroutine Scopes and Contexts

Understanding scopes and contexts is crucial for proper coroutine management. Let's look at different scope types:

LifecycleScope

class NewsActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleScope.launch {
            val news = newsRepository.fetchLatestNews()
            newsAdapter.submitList(news)
        }
    }
}

ViewModelScope

class UserViewModel : ViewModel() {
    private val _userData = MutableLiveData<User>()

    fun loadUserData() {
        viewModelScope.launch {
            try {
                val user = userRepository.fetchUserDetails()
                _userData.value = user
            } catch (e: Exception) {
                // Handle error
            }
        }
    }
}

Working with Dispatchers

Dispatchers determine which thread coroutines run on. Here's how to use different dispatchers effectively:

class ImageProcessor {
    fun processImage(bitmap: Bitmap) {
        lifecycleScope.launch(Dispatchers.Default) {
            // CPU-intensive image processing
            val processed = applyFilters(bitmap)

            withContext(Dispatchers.Main) {
                // Update UI with processed image
                imageView.setImageBitmap(processed)
            }
        }
    }

    suspend fun downloadImage(url: String) {
        withContext(Dispatchers.IO) {
            // Network operation to download image
            val response = imageApi.fetchImage(url)
            saveToDatabase(response)
        }
    }

Error Handling and Exception Management

Proper error handling is essential in coroutines. Here's how to implement it effectively:

class DataManager {
    private val exceptionHandler = CoroutineExceptionHandler { _, exception ->
        println("Caught $exception")
    }

    fun fetchData() {
        lifecycleScope.launch(exceptionHandler) {
            try {
                val result = riskyOperation()
                processResult(result)
            } catch (e: NetworkException) {
                showError("Network error occurred")
            } catch (e: DatabaseException) {
                showError("Database error occurred")
            }
        }
    }
}

Flow and StateFlow

Flow is perfect for handling streams of data, while StateFlow is ideal for managing UI state:

class SearchViewModel : ViewModel() {
    private val _searchResults = MutableStateFlow<List<SearchResult>>(emptyList())
    val searchResults: StateFlow<List<SearchResult>> = _searchResults.asStateFlow()

    fun search(query: String) {
        viewModelScope.launch {
            searchRepository.getSearchResults(query)
                .flowOn(Dispatchers.IO)
                .catch { e -> 
                    // Handle errors
                }
                .collect { results ->
                    _searchResults.value = results
                }
        }
    }
}

Structured Concurrency

Structured concurrency helps manage related coroutines effectively:

class OrderProcessor {
    suspend fun processOrder(orderId: String) = coroutineScope {
        val orderDeferred = async { fetchOrderDetails(orderId) }
        val inventoryDeferred = async { checkInventory(orderId) }
        val paymentDeferred = async { processPayment(orderId) }

        try {
            val order = orderDeferred.await()
            val inventory = inventoryDeferred.await()
            val payment = paymentDeferred.await()

            finalizeOrder(order, inventory, payment)
        } catch (e: Exception) {
            // If any operation fails, all others are automatically cancelled
            throw OrderProcessingException("Failed to process order", e)
        }
    }
}

Conclusion

Kotlin coroutines provide a powerful yet intuitive way to handle asynchronous operations in Android development. By understanding these core concepts and patterns, you can write more efficient, maintainable, and robust applications. Remember to always consider the appropriate scope, dispatcher, and error handling strategies for your specific use case.

The key to mastering coroutines is practice - start implementing them in your projects, experiment with different patterns, and gradually build more complex implementations as your understanding grows.

Originally written here

How to Inspect Element on an Android App (Actual App, not Web)

Prakhar Shakya — Fri, 18 Oct 2024 10:19:18 +0000

If you've ever thought, "How do I inspect an Android app the same way I do with websites?" – you're in the right place.

Let's break it down, step by step, for everyone.

Although these steps will show you how to inspect elements on an app, keep in mind that this only works for apps that you own or have access to their source code. If you're thinking of inspecting a popular app (like AirBnB, Uber, etc.), well... sorry, friend, Android doesn't play that game. Unlike browsers where you can inspect anything and everything, Android apps are a bit more possessive. You can only inspect what you control.

Oh, and while we're at it – inside Developer Options, there's a setting called Show Layout Bounds. It's a bit like putting on x-ray glasses for your app UI – it shows the boundaries, margins, and paddings of everything on the screen. Cool, right? Well, sort of. It's not exactly deep inspection, but it's handy for checking if everything lines up nicely or if your UI elements are misbehaving.

Step 1: Ensure Your App is Debuggable

First things first, your app needs to be debuggable. Without this, Android Studio won't let you peek under the hood.

In your build.gradle file, make sure you set debuggable:true

Heads up: Set debuggable:true only for testing or staging builds—not for your production builds. You don't want to ship a debuggable app to your users; it's a security risk.

Step 2: Setup Your Gear

You need a few things to get started:

An Android phone (obviously)
A USB cable to connect it to your computer
Android Studio installed on your computer

Got it all? Great. Let’s get started.

Step 3: Enable USB Debugging

Make sure USB Debugging is enabled on your device. Most mobile app developers will already have this on, but just in case:

Go to Developer Options in your phone settings.
Toggle on USB Debugging. This allows your computer to communicate with your Android device for all the inspecting fun.

Plug in your Android device via USB, and you’re all set.

Step 4: Use Android Studio's Layout Inspector

Install Android Studio (it’s free).
Connect your Android device and open Layout Inspector.
Click on different UI elements to see their properties.
Use the 3D view to see how your UI components stack up.

Layout Inspector gives you a super detailed view of each element in your app, including its properties and hierarchy. This is where the true dev magic happens, especially if you’re trying to debug a tricky UI.

Step 5: Debug with Logcat

Logcat is like a live feed of what's happening inside your app.

Use the search bar to filter logs by keyword, tag, or process.
Type your app's package name to focus on your app's logs.
Look out for logs in red—they indicate errors or crashes.
Use Log.d, Log.i, Log.e, etc., in your code to print custom messages.

Step 6: Inspect Network Requests

Seeing network/API logs is crucial for debugging.

Option 1: Android Studio's Network Profiler

Select Your Device and App: Choose your device and the running app.
Use the Network Tab: Run network operations in your app; they'll show up here.
Inspect Requests: Click on requests to see headers, responses, and payloads.

Option 2: Use an OkHttp Interceptor
If your app uses OkHttp for networking, you can log network activity.

Add the dependency:
implementation 'com.squareup.okhttp3:logging-interceptor:4.9.3'

Configure your OkHttpClient:

HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(HttpLoggingInterceptor.Level.BODY);

OkHttpClient client = new OkHttpClient.Builder()
    .addInterceptor(logging)
    .build();

Now, all your network requests and responses will be logged in Logcat.(Blue one in the above screenshot)

Bonus: Inspect Web Content with Chrome DevTools

This is the part where it feels like web dev magic. If your app uses WebView or you want to inspect a website on your Android device:

Open Chrome on your computer.
In the address bar, type: chrome://inspect
You’ll see your connected Android device listed.
Click Inspect on the app you want to view.

Boom! You should see something similar to the Elements panel you’re used to with web apps.

Note: Chrome DevTools is for inspecting web pages and WebView content, not native Android UI elements.

TL;DR

Set debuggable:true in your app's debug build (not for production).
Enable USB Debugging on your Android device.
Use Android Studio's Layout Inspector to inspect UI elements.
Leverage Logcat for logging and error tracking.
Monitor Network Requests with Network Profiler or OkHttp Interceptor.
Use Chrome DevTools to inspect WebView content.

Inspecting elements on an Android app isn’t as instant as right-clicking on a webpage, but with this setup, it’s almost just as easy.

Disclaimer: Originally written for Quashbugs

I have a side gig for Mobile Devs who can write well.

Prakhar Shakya — Mon, 09 Sep 2024 13:15:09 +0000

I've been searching for developers who also enjoy writing for a while now.
It's not that me and my organisation is in need people who can code, we are looking for writers who understand code and are well versed with corporate dev culture.

And now, I found dev.to - seems like a lot of people here are exactly that.

So, If you're a developer (Mobile ideally) and love writing - I have a sidegig for you. (Considering you have a main job as well)

Comment here if you're interested, we'll take it from there.

OpenSourced our Mobile Testing Tool

Prakhar Shakya — Tue, 03 Sep 2024 13:11:07 +0000

Github - https://github.com/Oscorp-HQ/quash-max

Some context, quash-MAX is an in-app bug reporting tool for Mobile Apps. It captures data like Screenshots, session replays, Crash logs, API calls, device details, etc.
We're still working on making it compatible for Flutter, iOS, etc. Android is already done, & Contributions are welcome.

With this we've also started a discord community for mobile app developers. Feel free to comment for an invite.

Any advice, suggestions on how to make it better is welcome.