Bin's Blog

Suspend Under The Hood

Mon, 13 Nov 2023 00:00:00 +0000

Kotlin Coroutine Async Launch

Fri, 10 Nov 2023 00:00:00 +0000

launch

Starts a new coroutine and doesn’t return the result to the caller.

async&await

Starts a new coroutine and allows you to return a result with a suspend function called await.

Return Type

Launch return a Job, while async return a Deffered implementation.

Error Handling

try catch will work for both. For unhandled exceptions, launch will throw it directly while async will store the exception in deffered object and throw it when await() is called.

Testing Coroutine

Wed, 08 Nov 2023 00:00:00 +0000

Testing Coroutines in Android

Invoking suspending functions in tests

runTest{} is a coroutine builder designed for testing.

suspend fun fetchData(): String {
    delay(1000L)
    return "Hello world"
}

@Test
fun dataShouldBeHelloWorld() = runTest {
    val data = fetchData()    
    assertEquals("Hello world", data)
}

However, there are additional considerations to make, depending on what happens in your code under test:

When your code creates new coroutines other than the top-level test coroutine that runTest creates, you will need to control how those new coroutines are scheduled by choosing the appropriate TestDispatcher.
If your code moves the coroutine execution to other dispatchers (for example, by using withContext), runTest will still generally work, but delays will no longer be skipped, and tests will be less predictable as code runs on multiple threads. For these reasons, in tests you should inject test dispatchers to replace real dispatchers.

TestDispatchers

TestDispatchers shalll be used if new coroutines are created during the test to make the execution of the new coroutines predictable.

runTest runs the test coroutine in a TestScope, using a TestDispatcher. TestDispatchers use a TestCoroutineScheduler to control virtual time and schedule new coroutines in a test. All TestDispatchers in a test must use the same scheduler instance.

StandardTestDispatcher

When you start new coroutines on a StandardTestDispatcher, they are queued up on the underlying scheduler, to be run whenever the test thread is free to use.

UnconfinedTestDispatcher

When new coroutines are started on an UnconfinedTestDispatcher, they are started eagerly on the current thread.

Injecting TestDispatchers

Code under test might use dispatchers to switch threads (using withContext) or to start new coroutines. When code is executed on multiple threads in parallel, tests can become flaky.

In tests, replace real dispatchers with instances of TestDispatchers to ensure that all code runs on the single test thread.

Setting the Main dispatcher

Local unit tests run on JVM instead of real android device, if your code under test references the main thread, it’ll throw an exception during unit tests.

To replace the Main dispatcher with a TestDispatcher in all cases, use the Dispatchers.setMain and Dispatchers.resetMain functions.

class HomeViewModelTest { 
    @Test
    fun settingMainDispatcher() = runTest {
        val testDispatcher = UnconfinedTestDispatcher(testScheduler)      
        Dispatchers.setMain(testDispatcher)        
        
        try {           
            val viewModel = HomeViewModel()            
            viewModel.loadMessage() // Uses testDispatcher, runs its coroutine eagerly            
            assertEquals("Greetings!", viewModel.message.value)        
        } finally {
            Dispatchers.resetMain()        
       }   
    }
}

Coroutine Android Best Practices

Wed, 08 Nov 2023 00:00:00 +0000

Best practices for coroutines in Android

Inject Dispatchers

Easier to test.

Suspend functions should be safe to call from the main thread

Using withContext and specify dispatchers in coroutine.

The ViewModel should create coroutines

Hide suspend functions and flows from UI Layer.

The data and business layer should expose suspend functions and Flows

Make your coroutine cancellable

Cancellation in coroutines is cooperative, which means that when a coroutine’s Job is cancelled, the coroutine isn’t cancelled until it suspends or checks for cancellation.

Check your coroutine is active using ensureActive . If your coroutine is inactive, CancellationException will be thrown.

Coroutine Intro

Tue, 07 Nov 2023 00:00:00 +0000

Introduction

Feature

Lightweight

Suspension

Multi coroutinues can be run on one thread due to support for suspension, which doesn’t block the thread where coroutine is running.

Fewer Memory Leaks

Structured Concurrency

New coroutines can only be launched in a specific CoroutineScope which delimits the lifetime of the coroutine.

Built-in cancellation support

Cancellation is propagated automatically through the running coroutine hierarchy.

Jetpack integration

Advanced Coroutine Concepts

Suspend - Resume (Stack Frame)

Kotlin uses a stack frame to manage which function is running along with any local variables. When suspending a coroutine, the current stack frame is copied and saved for later. When resuming, the stack frame is copied back from where it was saved, and the function starts running again.

Dispatchers

Assign Dispatchers

Dispatchers.Main
Dispatchers.IO
Dispatchers.Default

withContext(Dispatchers.IO)

withContext() Performance

withContext() does not add extra overhead compared to an equivalent callback-based implementation. Furthermore, it’s possible to optimize withContext() calls beyond an equivalent callback-based implementation in some situations.

Start a Coroutine

async

Starts a new coroutine and allows you to return a result with a suspend function called await
Exception: Async expects an eventual call to await, it holds exceptions and rethrows them as part of the await call. The exception will not show in crash metrics.
launch
Starts a new coroutine and doesn’t return the result to the caller.

Parallel Decomposition

All coroutines that are started inside a suspend function must be stopped when that function returns, so you likely need to guarantee that those coroutines finish before returning.

With structured concurrency in Kotlin, you can** define a coroutineScope** that starts one or more coroutines.

Then, using await() (for a single coroutine) or awaitAll() (for multiple coroutines), you can guarantee that these coroutines finish before returning from the function.

Summary

Build a coroutineScope with async and await them to finish

suspend fun fetchTwoDocs() = coroutineScope {
    val deferredOne = async { fetchDoc(1) }        
    val deferredTwo = async { fetchDoc(2) }       
    deferredOne.await()        
    deferredTwo.await()    
}

Coroutines concepts

CoroutineScope

A CoroutineScope keeps track of any coroutine it creates using launch or async. scope.cancel()

class ExampleClass { 
    ...
    fun exampleMethod() {
        // Handle to the coroutine, you can control its lifecycle
        val job = scope.launch { 
            // New coroutine       
        }
        if (...) {
            // Cancel the coroutine started above, this doesn't affect the scope           
            // this coroutine was launched in            
            job.cancel()        
        }
    }
}

CoroutineContext

A CoroutineContext defines the behavior of a coroutine using the following set of elements:

Job: Controls the lifecycle of the coroutine.
CoroutineDispatcher: Dispatches work to the appropriate thread.
CoroutineName: The name of the coroutine, useful for debugging.
CoroutineExceptionHandler: Handles uncaught exceptions.

Parent CoroutineContext explained

The resulting parent CoroutineContext of a coroutine can be different from the CoroutineContext of the parent since it’s calculated based on this formula:

Parent context = Defaults + inherited CoroutineContext + arguments

Some elements have default values: Dispatchers.Default is the default of CoroutineDispatcher and “coroutine” the default of CoroutineName.
The inherited CoroutineContext is the CoroutineContext of the CoroutineScope or coroutine that created it.
Arguments passed in the coroutine builder will take precedence over those elements in the inherited context.

New CoroutineContext

New coroutine context = parent CoroutineContext + Job()

val job = scope.launch(Dispatchers.IO) {// new coroutine}

Job

A job is a handle to coroutine. If a job is not passed into CoroutineContext, Job() will be used and it will cancel all coroutines in the scope for uncaught exceptions.

val job = scope.launch {
    // New coroutine        
}

Job Lifecycle

A Job can go through a set of states: New, Active, Completing, Completed, Cancelling and Cancelled.

CoroutineDispatcher

Kotlin coroutines use dispatchers to determine which threads are used for coroutine execution. Coroutines can suspend themselves, and the dispatcher is responsible for resuming them.

withContext is usually called to switch dispatcher.

Customize Dispatcher

Private thread pools can be created with newSingleThreadContext and newFixedThreadPoolContext.
An arbitrary java.util.concurrent.Executor can be converted to a dispatcher with the asCoroutineDispatcher extension function.

CoroutineName

The name of the coroutine, useful for debugging.

CoroutineExceptionHandler

An optional element in the coroutine context to handle uncaught exceptions.

Normally, uncaught exceptions can only result from root coroutines as all children coroutines delegate handling of their exceptions to their parent.
Coroutines running with SupervisorJob do not propagate exceptions to their parent and treated like root coroutines.
A coroutine that was created using async always catches all its exceptions and represents them in the resulting Deferred object, so it cannot result in uncaught exceptions.

Uncaught exceptions with no handler

If exception is CancellationException, it is ignored, as these exceptions are used to cancel coroutines.
Otherwise, if there is a Job in the context, then Job.cancel is invoked.
Otherwise, as a last resort, the exception is processed in a platform-specific manner:
- On JVM, all instances of CoroutineExceptionHandler found via ServiceLoader, as well as the current thread’s Thread.uncaughtExceptionHandler, are invoked.

References

Coroutines: first things first Developer Android Kotlin Coroutine

Apksigner Unsupportedclassversionerror

Mon, 17 Aug 2020 00:00:00 +0000

Error description

Error: A JNI error has occurred, please check your installation and try again Exception in thread “main” java.lang.UnsupportedClassVersionError: com/android/apksigner/ApkSignerTool has been compiled by a more recent version of the Java Runtime (class file version 53.0), this version of the Java Runtime only recognizes class file versions up to 52.0 at java.lang.ClassLoader.defineClass1(Native Method) at java.lang.ClassLoader.defineClass(ClassLoader.java:756) at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142) at java.net.URLClassLoader.defineClass(URLClassLoader.java:468) at java.net.URLClassLoader.access$100(URLClassLoader.java:74) at java.net.URLClassLoader$1.run(URLClassLoader.java:369) at java.net.URLClassLoader$1.run(URLClassLoader.java:363) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:362) at java.lang.ClassLoader.loadClass(ClassLoader.java:418) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:355) at java.lang.ClassLoader.loadClass(ClassLoader.java:351) at sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:495)

Solution

Remove Android SDK Build-tools v30.0.1 in SDK manager, use 29.x.x version instead. For me, Build-Tools v29.0.2 works.

Adnroid Wifi Adb

Mon, 17 Aug 2020 00:00:00 +0000

Enable Wifi ADB

Connect device to computer with cable.
Ensure your device and computer are in save network, like connect to same wifi.
Find out your device ip address, such as 172.10.10.5
In terminal, command: adb tcpip 5555
In terminal, command: adb connect ip:5555, such as 172.10.10.5: 5555

Kotlin Vocabulary Readnote Suspend

Wed, 08 Apr 2020 00:00:00 +0000

References

The suspend modifier — Under the hood

Kotlin Vocabulary Readnote Inline Function

Tue, 07 Apr 2020 00:00:00 +0000

When to use inline function

For function with higher order function (lambda), make the function inline will save some memory by avoiding Function object creation.
If the reference for higher order function is used, inline can’t be applied to it.
Inline a function will grow the size of app, and then better do it when the function is simple and contains only few lines of codes.
noinline to annotate which higher order function should not converted to inline

References

Inline functions - Kotlin Vocabulary

Kotlin Vocabulary Readnote D8 R8 Enum

Tue, 07 Apr 2020 00:00:00 +0000

How Java Enum works in switch statement

Look Into Bytecode

I write a demo code which will be compiled to bytecode later, which will show how switch with Enum works internally.

public class EnumDemo {

    enum BlendMode {FADE, ADD, MIX}

    public static void main(String[] args) {
        testSwitch(BlendMode.ADD);
    }

    private static void testSwitch(BlendMode mode) {
        switch (mode) {
            case FADE:
                doSomething("fade");
                break;
            case ADD:
                doSomething("add");
                break;
            case MIX:
                doSomething("mix");
                break;
        }
    }

    private static void doSomething(String s) {

    }
}

The switch case part of bytecode:

public class tech/jubin/demo/EnumDemo {
  ... truncated ...

  // access flags 0xA
  private static testSwitch(Ltech/jubin/demo/EnumDemo$BlendMode;)V
   L0
    LINENUMBER 12 L0
    GETSTATIC tech/jubin/demo/EnumDemo$1.$SwitchMap$tech$jubin$demo$EnumDemo$BlendMode : [I
    ALOAD 0
    INVOKEVIRTUAL tech/jubin/demo/EnumDemo$BlendMode.ordinal ()I
    IALOAD
    TABLESWITCH
      1: L1
      2: L2
      3: L3
      default: L4

      ... truncated ...

From the bytecode we can find that for switch statement, a mapping is created first and switch will use enum’s ordinal for TABLESWITCH.

Why The Mapping is necessary

Unlike Android application, Java application might not compiled together. In this case, if the orinal of enum from a library is changed, the application which depend on the library might break. To avoid this, javac will add a mapping to the place switch enum is used.

How Kotlin Enum works in when statement

Kotlin Enum class will be translated to Java Enum and it also add a mapping to where the when statement with enum is called.

when statement decompiled to Java code

These code snippet is from blog When using enums and R8…

public final class BlendingKt$WhenMappings {
    public static final int[] $EnumSwitchMapping$0 =
            new int[BlendMode.values().length];

    static {
        $EnumSwitchMapping$0[BlendMode.OPAQUE.ordinal()] = 1;
        $EnumSwitchMapping$0[BlendMode.TRANSPARENT.ordinal()] = 2;
        $EnumSwitchMapping$0[BlendMode.FADE.ordinal()] = 3;
        $EnumSwitchMapping$0[BlendMode.ADD.ordinal()] = 4;
    }
}

R8 Optimization

Android application is different from general Java application in that all codes are compiled together, thus the ordinal can be fixed during compilation.

Proguard is a separate program which will run after dex, and as a result, it has no access to compile time resources and can’t do the optimisation.

R8 is run after d8 and can be seen as a part of d8 compilation. Thus it has access to all compile time resources. As a result, the mappings are not necessary anymore and can be removed with R8, saving us runtime memory and speed up our application.

R8 optimized code:

public static void blend(@NotNull BlendMode b) {
    switch (b.ordinal()) {
        case 0: {
            src();
            break;
        }
        // ...
    }
}