Forem: Aldo Wachyudi

How to Use Kotlin Notebook for Free

Aldo Wachyudi — Wed, 04 Sep 2024 23:50:02 +0000

Kotlin Notebook is a fun way to experiment with Kotlin, whether you’re testing out Kotlin syntax or exploring libraries. But, to use the Kotlin Notebook Plugin in IntelliJ or Android Studio, you need an Ultimate Subscription, which makes it less accessible for those who want to use it for free. Here’s the good news: you can actually use the Kotlin Notebook kernel to run Kotlin Notebooks for free!

Yes, you can use Kotlin Notebook for free!

Since the kernel is free and Kotlin Notebook is one of the kernels available for Jupyter Notebooks, you can use it just like any other Python Notebook. This means you can run it in your browser using Jupyter Lab or in Visual Studio Code.

Which one do you prefer, JupyterLab or Visual Studio Code?

Installation

All you need to do is install the Kotlin kernel by running the command pip install kotlin-jupyter-kernel. Then, choose Kotlin as the kernel in your Jupyter Kernel.

Changing Kernel in VS Code

That’s it! But, in case you’re using Jupyter Notebook for the first time, head over to the appendix section.

Changing Kernel in Jupyter Notebook.

To make this article more complete, I’ve created three code examples to demonstrate various features of Kotlin Notebook in different scenarios.

Example 1 — Basic Features

The code: basic-kotlin-notebook.ipynb

I’ve created an example that uses MessageDigest, Base64, Sequence, and Stream. This example also showcases basic Notebook features like using variables or functions from other cells.

Notice that I don’t define numbers in the bottom cell.

Example 2 — Using Dependencies

The code: external-lib-retrofit.ipynb

This example demonstrates how you can use dependencies and transitive dependencies in Kotlin Notebook, using Retrofit as an example.

HTTP Get using Retrofit in Kotlin Notebook

Example 3 — Kotlin Notebook & Ollama

The code: external-lib-langchain4j.ipynb

Ollama is an easy-to-use LLM provider that allows us to communicate with large language models for free, without relying on commercial LLM services. LangChain4j, on the other hand, is a library that helps us write LLM-based applications in Java/Kotlin.

Ollama & LangChain4j in Action

Summary

Kotlin Notebook provides a convenient way to experiment with Kotlin code and libraries. While the IntelliJ Plugin requires an Ultimate Subscription, you can use Kotlin Notebook for free by using the Kotlin Jupyter kernel. This method allows you to run Kotlin notebooks in Jupyter Lab or Visual Studio Code, making it accessible to everyone.

Appendix — Installation

If this is your first time using Jupyter Notebook, I recommend installing the necessary tools in the following order:

Install PyEnv: This tool makes it easy to manage different Python versions, which is important since Jupyter Notebook and the Kotlin-Jupyter kernel rely on Python. You can install PyEnv using Homebrew with the following command: brew install pyenv
Install JupyterLab or Jupyter Notebook: Once PyEnv is set up, install JupyterLab or Jupyter Notebook. You can do this using pip, for example: pip install notebook
Install the Kotlin Kernel: Next, install the Kotlin-Jupyter kernel to enable Kotlin support in your notebooks: pip install kotlin-jupyter-kernel
Install Ollama: To use Ollama, you can simply drag and drop the app from the Ollama website. After installing, pull the necessary images used in the examples: ollama pull tinyllama and ollama pull gemma2:2b

Cover Photo by Mike Tinnion on Unsplash

How to access projects in multimodule Gradle project?

Aldo Wachyudi — Sat, 08 Oct 2022 04:26:57 +0000

In a multimodule Gradle project, you're likely to have.. many modules. Each module can have other modules as dependencies.

dependencies {
    implementation(project(":feature:feature-payment"))
    implementation(project(":lib:crypto"))
    implementation(project(":android-lib:navigation"))  
}

How would you remember the module name, if you have 100 modules?

Sure, you can type the module name manually, like in the above code snippet.
But is there a safer and faster way to access the project?
Yes, there is!

By using Gradle's TYPESAFE_PROJECT_ACCESSORS, we can access the projects in our project in a typesafe way.

If your project exists, the IDE will give autocomplete.

If your project doesn't exist, the IDE will give you an error.

Setup

Make sure you're using Gradle 7.0 or higher
In your root project build.gradle file, add the following line of code.

enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")

Result

Open your build.gradle or build.gradle.kts, the dependencies above will look like this.

dependencies {
    implementation(projects.feature.featurePayment)
    implementation(projects.lib.crypto)
    implementation(projects.androidLib.navigation)  
}

Notice that Gradle converts the module with kebab-case or snake_case to camelCase. From feature-payment to featurePayment.

Summary

By using typesafe project accessors you can access modules in your project in a typesafe manner. Currently, Gradle still marks this feature as experimental. But you can use it in your project by enabling the TYPESAFE_PROJECT_ACCESSORS in the build.gradle file.

References:

Type-safe project accessors

Should new Android developers learn Compose or XML?

Aldo Wachyudi — Sun, 18 Sep 2022 09:11:32 +0000

In the next three months, I'll be volunteering to teach undergrad students Android development. So, I'm also faced with this question, should I teach a new developer Compose or XML?

In my opinion, aspiring Android developers should just start learning Compose. Here are my four reasons why:

1. Production-ready

Compose is ready for production. Twitter, Play Store, and Airbnb are just a few companies that already using Compose. It has been more than one year since Compose reached version 1.0.

What do I mean by production ready?

No major bugs or unnecessary troubleshooting.
The APIs are stable, consistent, and intuitive.
There is no performance issue, your User Interface (UI) will render smoothly.

When I'm coming back to Android development after working as a backend engineer for a year, I'm curious whether I can build a complex UI with Compose. As a proof of concept, I've made a clone of Astro, a quick commerce app that I believe has typical requirements of the real app (layered UI, custom behavior, multiple UI sections, etc.).

So, you don't need to worry that you will encounter too many issues when learning Compose. You can publish a real app with Compose.

2. Simplicity

This is an example of how you write UI using XML.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView
        android:id="@+id/tvName"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hi, my name is Aldo" />

    <ImageView
        android:id="@+id/ivProfile"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        />

    <TextView
        android:id="@+id/tvRole"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="I'm an Android developer 🤖" 
        />

</LinearLayout>

And this is how you write UI using Compose.

Column {
    Text("Hi, my name is $name", style = TextStyle(
        fontWeight = FontWeight.Bold))
    AsyncImage(model = "https://example.com/img/user.png")
    Text("I'm an Android developer 🤖")
}

Even from this simple use case, you can see that Compose uses fewer lines of code.

The simpler the code, the easier it is to learn or to teach it.

You don't need to learn:

XML (just use Kotlin)
Binding XML to a Kotlin class
Improving performance by flattening your View hierarchies using ConstraintLayout

This means you've got more time to learn other Android topics, like ViewModel, testing, Coroutines, and Jetpack libraries.

3. Familiarity

If you've learned declarative UI from other platforms, you will feel right at home.

Take a look at these code snippets that build the same UI for iOS (SwiftUI) and cross-platform (Flutter).

VStack {
    Text("Hi, my name is \(name)!")
        .fontWeight(.bold)
    AsyncImage(url: URL(string: "https://example.com/img/user.png"))
    Text("I'm an iOS developer 🍏")
}

Column(
    children: const<Widget>[
        Text('Hi, my name is $name', style: TextStyle(
            fontSize: FontWeight.bold)),
        Image.network('https://example.com/img/user.png')
        Text('I\'m a Flutter developer ⬅️')
    ]
)

It looks somewhat similar, isn't it?

Chances are, a new Android developer is not going to pursue a career as a full-time Android developer. They might be exploring Flutter, iOS, backend, or not even pursuing a career as a developer.

By using Compose, you've learned a concept that can be applied to other platforms.

4. Support

Learning anything new can be difficult at first, no matter how good a library is. When you're stuck, Compose has many resources to help you, from official Android documentation to a plethora of community articles. To mention some:

You don't need to worry about integration with popular libraries as well. Popular libraries like Jetpack Components (ViewModel, Navigation, Hilt, etc.), Glide, or Koin is compatible with your Compose code.

Compose is still actively supported by Google, so even if you find a bug or a feature request, you can expect it's addressed in the next version.

Summary

In conclusion, Compose is a safe choice for a developer who's just getting started with Android development. While XML is still dominant in the legacy project, Compose is the modern toolkit for building native Android UI. Go ahead and use Compose in your first app!

Notes

I'll be teaching Pemograman Mobile course at Universitas Musamus Merauke (UNMUS) as part of praktisimengajar.id government program. Thank you for giving me this opportunity!
To be fair, XML is declarative UI too, a verbose one compared to Kotlin. But in XML, you still need to write imperative code for many tasks.
Cover photo is taken by weston m

How to manage dependencies between Gradle modules?

Aldo Wachyudi — Wed, 07 Sep 2022 15:31:45 +0000

In a multimodule project, managing dependencies manually can be challenging. For example, if you forget to update a library version after modifying a library version on another module, your project will have a duplicate library.

Starting from Gradle 7.4.1, version catalog is the recommended way of managing dependencies between Gradle projects (also known as a module).

To use the version catalog, simply add libs.versions.toml file inside gradle folder (yourproject/gradle/libs.versions.toml)

.
├── app
│   ├── build.gradle.kts
│   ├── proguard-rules.pro
│   └── src
├── gradle
│   ├── libs.versions.toml
│   └── wrapper
│      ├── gradle-wrapper.jar
│      └── gradle-wrapper.properties
├── build.gradle.kts
├── gradle.properties
├── gradlew
├── gradlew.bat
├── local.properties
└── settings.gradle.kts

Inside the libs.versions.toml file, you can add the dependencies of your projects.

[versions]
compose = "1.2.1"

[libraries]
compose-foundation = { module = "androidx.compose.foundation:foundation", version.ref = "compose" }
compose-material = { module = "androidx.compose.material:material", version.ref = "compose" }
compose-tooling = { module = "androidx.compose.ui:ui-tooling", version.ref = "compose" }
compose-ui = { module = "androidx.compose.ui:ui", version.ref = "compose" }

[bundles]
compose = ["compose-foundation", "compose-material", "compose-tooling", "compose-ui"]

That's it! The dependencies are available across your Gradle projects.

Here is how you use the dependencies in your project's build.gradle.kts.

dependencies {
    implementation(libs.compose.foundation)
    implementation(libs.compose.material)
    implementation(libs.compose.tooling)
    implementation(libs.compose.ui)
}

Note that Gradle converts the dash (-) separator to dot (.). From compose-foundation to compose.foundation.

Other benefits of using version catalogs are:

Centralized version for some libraries.

By using version.ref, we can assign the same compose version for each library. So, you just need to update a library version in one place.

Grouping dependencies.

Oftentimes, we have many dependencies that should be declared together. We can make the dependencies declaration shorter by using bundle, like this.

dependencies {
    implementation(libs.bundles.compose)
}

Summary

By using the version catalog, we can manage dependencies easier. This can be useful for a multimodule project, which is common in a mid-sized or large-sized software project.

Heads over to the official Gradle documentation for more detail.

Note:

Gradle introduces version catalog since version 7.0, but it's still marked as an experimental feature.
Photo taken by redcharlie

3 reasons why I'm not migrating LiveData to StateFlow

Aldo Wachyudi — Sun, 21 Aug 2022 14:40:29 +0000

I have a confession to make, after reading through StateFlow and SharedFlow documentation, watching Android Developers's video, and reviewing nowinandroid source codes, I'm not convinced to migrate LiveData to StateFlow or SharedFlow. At least for now. Here's why:

1. Most of the time, I only do one-shot operation

According to Kotlin documentation flow is "An asynchronous data stream that sequentially emits values and completes normally or with an exception."

There are valid use-cases for using flow, like fetching the latest data from server periodically or receiving live-update of query result when using Room.

But, most of the time, I only need to do a one-shot task. Not more, not less. Such as, making a GET request to a server and retrieving a value from a database. In those situations, the nature of my task is not stream. Even though I can convert it to flow:

flow {
    val weather = weatherApi.getWeather(coordinate)
    emit(weather)
}

This works, yet in my opinion, I added an extra line of codes for no specific reason.

We can also create a StateFlow or SharedFlow without flow.

private val _myState = MutableStateFlow(
    MyState(
        title = R.string.title,
        index = 0,
    )
)
val myState: StateFlow<MyState> = _myState.asStateFlow()

But again, if it's not emitting multiple values sequentially, why should I add more code?

This brings us to my second reason.

2. LiveData is lifecycle-aware

StateFlow and SharedFlow are part of Kotlin library. It's designed to be platform agnostic (go KMM! 🚀), so it doesn't know about Android framework and its lifecycle. If you want to integrate it Android, you need to ensure it follows Android lifecycle.

// Activity

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { uiState ->
            when (uiState) {
                is UiState.Success -> showSuccess(uiState.data)
                is UiState.Error -> showError(uiState.exception)
            }
        }
    }
}

If only there is a Jetpack library for that.. 🤔

That's what LiveData is made for! Taken from Android documentation, "LiveData is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services.".

The same functionality can be achieved with this code.

// Activity

viewModel.uiState.observe(this) { uiState ->
    is UiState.Success -> showSuccess(uiState.data)
    is UiState.Error -> showError(uiState.exception)
}

By using LiveData, we don't need to manually handle the lifecycle, worry about memory leaks, and be sure that the data is always up-to-date.

One caveat, I realize in Compose the difference isn't significant (Kudos to Jetpack team 👏).

@Composable
fun HomeRoute(
    modifier: Modifier = Modifier,
    viewModel: MyViewModel = getViewModel<MyViewModel>()
) {
    val uiStateLiveData by viewModel.uiState.observeAsState(initial = UiState.Loading)
    val uiStateStateFlow by viewModel.uiState.collectAsStateWithLifecycle()
}

The stable version of Jetpack Compose is just released last year. While I do like writing UI using Compose, I think most companies still need more time to adopt Compose.

3. I don't need StateFlow or SharedFlow features

StateFlow and SharedFlow have many features for configuring the emitted elements. SharedFlow has a reply functionality that can resend previously-emitted values for new subscribers. StateFlow has a time-out mechanism before stopping upstream flow using WhileSubscribed class.

val uiState: StateFlow<UiState> = flow {
    emit(repository.getItem())
}.stateIn(
    scope = viewModelScope, 
    initialValue = UiState.Loading,
    started = WhileSubscribed(5_000),
)

flow also allows you to combine multiple flows into a StateFlow.

val uiState: StateFlow<UiState> = combine(
    userRepository.getUser(),
    weatherRepository.getWeather(),
    statusRepository.getStatusStream(),
) { user, weather, status stream -> {
    // ...
}

Whereas, in my projects, the cool features that SharedFlow and StateFlow provides is a nice-to-have, not a must-have. The complex operation is handled on different classes, like on Repository (data layer) or UseCases (domain layer).

For merging multiple data-sources, like network and database, I can use Repository backed with NetworkDataSources and DbDataSources. For data manipulation, Kotlin's collection has many useful functions (map, reduce, groupBy, count, etc.). If I want to ensure a data can only be emitted once, a simple modification to LiveData is enough (SingleLiveData

Summary

So, when should you use StateFlow and SharedFlow? If you need them! Use the right tool for the right job.

If you need to store or buffer flow elements, if you need to support KMM in your project, or if you need first-class support for stream operation, then please use StateFlow and SharedFlow 🙏.

If you think LiveData is enough for you, don't migrate to StateFlow just yet 😁

References

Image taken by Samuel from Unsplash: https://unsplash.com/photos/scUBcasSvbE

How to run Java without Maven, Gradle, or IDE

Aldo Wachyudi — Wed, 10 Aug 2022 13:51:43 +0000

When you want to start programming using Java, you're most likely use Maven, Gradle, or an Integrated Development Environment (IDE) like IntelliJ or NetBeans. These tools has one thing in common, they're slow!

To start an empty Java project, Gradle takes more than 2 minutes.

BUILD SUCCESSFUL in 2m 38s
3 actionable tasks: 3 executed

Maven is better, although 57 seconds isn't exactly fast either.

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  57.824 s
[INFO] ------------------------------------------------------------------------

In a complex Java project, we could argue this overhead is worth it. But, what if you don't want to start a complex Java project? What if you just want to try a Java library, test your programming logic, or trying out a new Java syntax?

For a simple project, Java's build-in program like javac and java is enough. You can start write a Java program with a text editor and a terminal. That's it!

In this article, I'll show three examples of using JDK tools and a terminal to run a Java program.

1. Running a self-contained Java program

The first example is a class that takes a String as an input and produce hash as an output. This class doesn't need any third-party library. This class only use Java's build-in classes.

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Md5Util1 {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        String plainText = args[0];

        MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(plainText.getBytes());
        byte[] digest = md.digest();

        // Convert byte array to a hexadecimal String
        StringBuilder sb = new StringBuilder(2 * digest.length);
        for (byte b : digest) {
            sb.append(String.format("%02x", b));
        }

        System.out.println("MD5 Hash: " + sb);
    }
}

Open a terminal to compile and run this program.

$ javac Md5Util1.java
$ java Md5Util1 "Hello, world!"
MD5 Hash: 6cd3556deb0da54bca060b4c39479839

The compilation takes 0.7 second. No need to run an IDE that takes a lot of memory. Nor does waiting the build system finished configuring something. Just write the code!

As a refresher, javac is JDK's program that compile java code to bytecode.

$ javac Md5Util1.java
$ ls
Md5Util1.java Md5Util1.class

java is JDK's program that run a Java class.

$ man java
NAME
       java - Java application launcher

SYNOPSIS
       java [ options ] class [ argument...  ]

Note that we don't use .class extension, we just use the class name. Instead of java Md5Util1.class, we use java Md5Util1.

The argument(s) is passed to the Class's main method (public static void main(String[] args)). In this case, "Hello, world!" is passed on Md5Util1 main method.

We'll explore the java options in the next example.

Update:
Since Java 11, you can run java directly like this.

$ java Md5Util1 "Hello, world!"
MD5 Hash: 6cd3556deb0da54bca060b4c39479839

2. Running a JUnit test

Even in a simple project, you need to use a third-party library. Like JUnit. JUnit is the de-facto library for testing Java code. Let's modify the Md5Util1 to make it easier to test.

import java.security.MessageDigest;

public class Md5Util2 {
    public static void main(String[] args) throws Exception {
        String plainText = args[0];
        String output = stringToMd5(plainText);

        System.out.println("MD5 Hash: " + output);
    }

    public static String stringToMd5(String input) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(input.getBytes());
        byte[] digest = md.digest();

        // Convert byte array to a hexadecimal String
        StringBuilder sb = new StringBuilder(2 * digest.length);
        for (byte b : digest) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

We've extracted the code for hashing in stringToMd5 method. Now, let's add the test class.

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class Md5Util2Test {

    @Test
    public void helloWorld() throws Exception {
        // Given
        String input = "Hello, world!";
        String expectedOutput = "6cd3556deb0da54bca060b4c39479839";

        // When
        String actualOutput = Md5Util2.stringToMd5(input);

        // Then
        assertEquals(expectedOutput, actualOutput);
    }
}

Again, open a terminal to compile and run this program.

$ javac Md5Util2.java Md5Util2Test.java
Md5Util2Test.java:1: error: package org.junit does not exist
import org.junit.Test;

This time, javac shows an error! javac doesn't know where to find the org.junit package. We need to inform javac where to find the the JUnit package and classes.

Java classes is bundled in a jar file. So, we should download the junit.jar file and attach it during compilation. We use -cp option to include the path of the class (hence, class path).

Download the junit's jar file in the mvnrepository.com (or the junit website). In this example, I use JUnit 4.12.

$ javac -cp junit-4.12.jar Md5Util2.java Md5Util2Test.java
$ ls -al | grep ".class"
Md5Util2.class
Md5Util2Test.class

Now, let's run the test!

$ java -cp .:junit-4.12.jar org.junit.runner.JUnitCore Md5Util2Test
Exception in thread "main" java.lang.NoClassDefFoundError: org/hamcrest/SelfDescribing
    at java.base/java.lang.ClassLoader.defineClass1(Native Method)
    at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:1017)
    at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:174)

Oops, another error. This is why we should read the manual 😅.

JUnit require hamcrest.jar to run the test. So, heads over to mvnrepository.com to download the hamcrest.jar. In this example, I use version 1.3.

The class path can be used to in java command too. Let's try to run the test again.

$ java -cp .:junit-4.12.jar:hamcrest-core-1.3.jar org.junit.runner.JUnitCore Md5Util2Test
JUnit version 4.12
.
Time: 0.01

OK (1 test)

Use colon to separate classes in the class path. .:junit-4.12.jar:hamcrest-core-1.3.jar means we add the current path (dot is the current path) and two other jar files to run the program.

When we run a JUnit test, we're actually running org.junit.runner.JUnitCore class. We pass the target test class to the JUnitCore arguments. In this case, Md5Util2Test is the target test class.

At this point, you might be wondering.. Why we don't need to add MessageDigest in the class path? Java already add JDK's standard classes in the class path. The classes is bundled as rt.jar file. It's located in the /Library/Java/JavaVirtualMachines/adoptopenjdk-8.jdk/Contents/Home/jre/lib directory.

You can exract the rt.jar by using jar -xf rt.jar command.

$ tree -L 1
.
├── META-INF
├── apple
├── com
├── java
├── javax
├── jdk
├── org
├── rt.jar
└── sun

$ cd java

$ tree -L 1
.
├── applet
├── awt
├── beans
├── io
├── lang
├── math
├── net
├── nio
├── rmi
├── security
├── sql
├── text
├── time
└── util

Other than java.security.MessageDigest, you can see other useful Java classes, such as:

java.math.BigDecimal
java.time.Duration
java.util.ArrayList

3. Running a Java program with multiple JAR dependencies

As you see in example 2, some JAR may depends on other JARs. The more JAR we use in the project, the more complicated the compilation and running command is. This is why build tools like Maven or Gradle exist.

That being said, we can still use JDK's tool to run the program. Let's use Retrofit library as example. Retrofit is a popular REST API library that uses Interface as the API declaration. I use the sample code from Retrofit website verbatim to simplify the example.

import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Path;

import java.util.List;

public interface GitHubService {
    @GET("users/{user}/repos")
    Call<List<Repo>> listRepos(@Path("user") String user);
}

The Repo object from GitHub API is contains lots of information about a repository. In this case, we're only interested in Repo's id and name.

public class Repo {
    public String id;
    public String name;
}

Next, create GitHubRetrofit class that build the Retrofit instance.

import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
import java.util.List;

public class GitHubRetrofit {

    private Retrofit retrofit;
    private GitHubService service;

    public GitHubRetrofit() {
        retrofit = new Retrofit.Builder()
                .baseUrl("https://api.github.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        service = retrofit.create(GitHubService.class);
    }

    public Repo helloWorldRepo() throws Exception {
        Response<List<Repo>> response = service.listRepos("octocat").execute();
        return response.body()
                .stream()
                .filter(repo -> repo.name.equals("Hello-World"))
                .findFirst()
                .get();
    }
}

Finally, we create the test class that test the GitHubRetrofit class.

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class GitHubRetrofitTest {

    @Test
    public void repos() throws Exception {
        // Given
        CallGitHub callGitHub = new CallGitHub();
        String expectedName = "Hello-World";

        // When
        Repo repo = callGitHub.helloWorldRepo();

        // Then
        assertEquals(repo.name, expectedName);
    }
}

Even with this simple API call example, there are many classes and import statements. So, there should be several JAR files involved. Of course, we need the retrofit, junit, and hamcrest JAR. But, how do we know which JAR files to download in mavenrepository?

This is why we use Maven or Gradle. They manages dependencies for us. Maven uses Project Object Model (POM) to describe the dependencies. The POM file itself is available in the mvnrepository's Retrofit page. For example:

<dependencies>
    <dependency>
        <groupId>com.squareup.retrofit2</groupId>
        <artifactId>retrofit</artifactId>
        <version>2.9.0</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.5</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

You can use Gradle to list out dependencies too, by using ./gradlew dependencies command.

+--- com.squareup.retrofit2:converter-gson:2.9.0
|    +--- com.squareup.retrofit2:retrofit:2.9.0
|    |    \--- com.squareup.okhttp3:okhttp:3.14.9
|    |         \--- com.squareup.okio:okio:1.17.2
|    \--- com.google.code.gson:gson:2.8.5
\--- com.squareup.retrofit2:retrofit:2.9.0 (*)

Since this article is about building and running Java without Maven or Gradle, I won't explain more about this topic.

After doing some trial and error, we know that we need the following JAR files. I put it under the /libs folder.

$ ls
GitHubRetrofit.java
GitHubRetrofitTest.java
GitHubService.java
Repo.java
libs

$ tree
.
├── converter-gson-2.9.0.jar
├── gson-2.8.5.jar
├── hamcrest-core-1.3.jar
├── junit-4.12.jar
├── okhttp-3.14.9.jar
├── okio-1.17.2.jar
└── retrofit-2.9.0.jar

0 directories, 7 files

That's a lot of JARs!

To compile the class, run this command.

$ javac -d classes -cp libs/\* *.java

The -d option describes the destination directory. Since we're dealing with multiple files, it's tidier to group the class in a separate folder.

$ tree -L 2
.
├── GitHubRetrofit.java
├── GitHubRetrofitTest.java
├── GitHubService.java
├── Repo.java
├── classes
│   ├── GitHubRetrofit.class
│   ├── GitHubRetrofitTest.class
│   ├── GitHubService.class
│   └── Repo.class
└── libs
    ├── converter-gson-2.9.0.jar
    ├── gson-2.8.5.jar
    ├── hamcrest-core-1.3.jar
    ├── junit-4.12.jar
    ├── okhttp-3.14.9.jar
    ├── okio-1.17.2.jar
    └── retrofit-2.9.0.jar

2 directories, 15 files

Finally, run the test by using this command.

$ java -cp classes:libs/\* org.junit.runner.JUnitCore GitHubRetrofitTest
JUnit version 4.12

Time: 1.355

OK (1 test)

With several JAR files, we could simplify the command by grouping the Java files, Class files, and JAR files in a separate folder.

In this scenario, this trick works nicely. But for more complex project the build system can handle this in more elegant way. For example, Maven has build a standard directory layout for organizing a Java project. You can execute build and run with a simpler command.

Summary

Don't be scared by the last example. For simple use case, like solving an algorithmic problem or running a test, building and running Java manually is simple and powerful.

Not only you're more aware of the syntax (No autocomplete to help you), you'll also appreciate the blazing fast compilation speed. This enables you to focus more on the code rather than tweaking build system or IDE configuration.

As a bonus, if you're a laptop user like I am, you'll recognize your laptop temperature is colder 😁 (Yay typing!).

Use Maven/Gradle if you need few dependencies. Rather than typing and remembering Java commands, you just need to remember few build system commands like test or build.

Finally, use IDE if you need to manage many dependencies (and its transitive dependencies). IDE is also useful in some cases, like method completion (so, you don't have to find Java docs in the internet) or breakpoint for debugging (you can do it with jdb but it's more complicated).

In conclusion, use the right tool for the right job!

Credit

Cover photo by Emma Smith

How to use Dagger 2 - Binds Annotation

Aldo Wachyudi — Tue, 27 Nov 2018 16:22:12 +0000

Dagger 2 introduces new annotation @Binds. You can use it to simplify @Provides, it turns this:

@Module
class HomeModule {

    @Provides
    HomeView provideHomeView() {
        return new HomeViewImpl();
    }
}

Into this:

@Module
abstract class HomeModule {

    @Binds
    abstract HomeView provideHomeView(HomeViewImpl impl);
}

Can we use @Binds and @Provides together?

Yes, you can use static method.

@Module
public abstract class MainActivityModule {

    @Provides
    static MainPresenter provideMainPresenter(MainView mainView, ApiService apiService) {
        return new MainPresenterImpl(mainView, apiService);
    }

    @Binds
    abstract MainView provideMainView(MainActivity mainActivity);
}

On Kotlin, you can use companion object to achieve the same thing.

@Module
abstract class MainApplicationModule {

    @Binds
    abstract fun provideApplication(application: Application): Context

    @Module
    companion object {
        @JvmStatic
        @Provides
        internal fun provideAgeMap(): Map<String, Int> {
            return mapOf("Luffy" to 17, "Shanks" to 37)
        }
    }
}

Verdict

@Binds clearly makes component declaration more succint. There is a slight problem when combining it with @Provides. While both approach works. I would prefer to still use @Provides for the sake of consistency. But you may want to experiment it yourself too feel which one you like better.

How to scroll RecyclerView to a certain position?

Aldo Wachyudi — Tue, 27 Nov 2018 16:21:03 +0000

This questions seems so simple, in fact Android SDK has provided several API to scroll item at certain position.

fun iJustWantToScroll() {
    recyclerView.scrollToPosition()
    recyclerView.smoothScrollToPosition()
    recyclerView.layoutManager?.scrollToPosition()
    (recyclerView.layoutManager as LinearLayoutManager).scrollToPositionWithOffset()    
}

It should work as expected right? Afterall, scrolling an item to certain position is a fairly common usage. Yet, why does this question is still popular?

Me too, is a victim of this bug. I have spent years before I realised I was asking the wrong question, before I'll answer this question, let me show you what I previously had done before.

fun iJustWantToScroll() {
    recyclerView.postDelayed(Runnable {
        // or use other API
        recyclerView.smoothScrollToPosition(0)

        // give a delay of one second
    }, 1_000)
}

This is a bit hacky, but always works (in my scenario). Try to reduce the delay, usually 500 milliseconds is enough.

The right question to ask about scrollToPosition is not How, but When.

When to scroll RecyclerView to a certain position?

I find that the problem why scrollToPosition , and others API, does not work is because the dataset is not yet ready. We should call scrollToPosition when the recyclerView has received dataset. To do that, we can use AdapterDataObserver.

AdapterDataObserver on d.android

AdapterDataObserver has five public methods.

As the method name implies, onItemRangeInserted is called when an item is added to the RecyclerView, and onItemRemoved is called when an item is removed from the RecyclerView.

There is an exception for onChanged. onChangedis only called when you call notify on an Adapter, it is not going to called everytime there is a change on the RecyclerView.

I usually call scrollToPosition when the dataset is succesfully inserted to a RecyclerView, for example:

adapter.registerAdapterDataObserver( object : RecyclerView.AdapterDataObserver() {
    override fun onItemRangeInserted(
        positionStart: Int,
        itemCount: Int
    ) {
        recyclerView.scrollToPosition(0)
    }

    override fun onItemRangeRemoved(
        positionStart: Int,
        itemCount: Int
    ) {
        recyclerView.smoothScrollToPosition(itemCount)
    }
}

This way, we don't have to wait certain millisecond to scroll a ReyclerView. When there is a new dataset, we can trigger scrollToPosition or smoothScrollToPosition and be sure RecyclerView is scrolled.

How to use PowerMockito whenNew

Aldo Wachyudi — Tue, 27 Nov 2018 16:16:44 +0000

PowerMockito.whenNew is a powerful function to stub a constructor. This article will demonstrate some scenario when we use whenNew and some gotchas I encountered along the way.

Let's say we have two classes, BookDao and BookRepository.

public enum BookDao {

    INSTANCE;

    public String getRecentBookTitle() {
        BookRepository repository = new BookRepository();
        return repository.queryBookTitle();
    }
}

public class BookRepository {

    public String queryBookTitle() {
        return "xUnit Test Patterns";
    }
}

The BookRepository is instantiated on getRecentBookTitle block. How do you test bookDao.getRecentBookTitle()?

@RunWith(PowerMockRunner.class)
@PrepareForTest({BookRepository.class})
public class BookDaoTest {

    @Test
    public void shouldReturnEffectiveJava() throws Exception {
        String bookTitle = BookDao.INSTANCE.getRecentBookTitle();

        // How to verify queryBookTitle?
        // Mockito.verify(mock).queryBookTitle();
    }
}

The ideal solution is to let BookDao to change its BookRepository class via constructor or setter injection. However, let's assume that we don't want to modify existing source code. Yet we still want to verify queryBookTitle is called.

This is where we can use PowerMockito whenNew. Using whenNew we can stub BookRepository creation with a mock.

BookRepository mock = Mockito.mock(BookRepository.class);
PowerMockito.whenNew(BookRepository.class).withAnyArguments().thenReturn(mock);

// Verify BookRepository is created
PowerMockito.verifyNew(BookRepository.class).withNoArguments();

You can even specify the constructor's arguments using withArguments

// Assume BookDao constructor have two arguments
PowerMockito.whenNew(BookRepository.class).withArguments(true, ArgumentMatchers.anyString()).thenReturn(mock);

Once we have BookRepositry mock, we can do many things including stubbing BookRepository queryBookTitle return value.

// Given
BookRepository mock = Mockito.mock(BookRepository.class);
Mockito.when(mock.queryBookTitle()).thenReturn("Effective Java");
PowerMockito.whenNew(BookRepository.class).withAnyArguments().thenReturn(mock);

// When
String bookTitle = BookDao.INSTANCE.getRecentBookTitle();

// Then
Assert.assertEquals("Effective Java", bookTitle);

Another use case is to capture BookRepository argument. In this sample, BookRepository has a new getBookByIsbn method that takes String as an argument.

// Given
String isbn = "978-0134685991";
ArgumentCaptor<String> isbnCaptor = ArgumentCaptor.forClass(String.class);

BookRepository mock = Mockito.mock(BookRepository.class);
PowerMockito.whenNew(BookRepository.class).withNoArguments().thenReturn(mock);

// When
String ignoredBookTitle = BookDao.INSTANCE.getBookByIsbn(isbn);
Mockito.verify(mock).queryBookTitle(isbnCaptor.capture());

// Then
Assert.assertEquals(isbn, isbnCaptor.getValue());

Now we can verify the isbn value in queryBookTitle is similar to what we have passed to BookDao. Pretty cool isn't?

Gotchas!

If you try to run the code above, you will likely to encounter these errors:

Wanted but not invoked
org.junit.ComparisonFailure

This is because we failed to stub BookRepository mock. But why? Didn't we already add BookRepository on @PrepareForTest? It's true, however PowerMockito requires us to specify the class that create BookRepository, which is BookDao. Not the BookRepository itself.

@RunWith(PowerMockRunner.class)
// You should also add BookDao on PrepareForTest! Even though you didn't mock or stub BookDao class.
@PrepareForTest({BookDao.class})
public class BookDaoTest {

    @Test
    public void shouldReturnEffectiveJava() throws Exception {
       // ...
    }
}

Now our test is all green.

Summary

Using PowerMockito.whenNew we can stub constructor with Mock object very easily. That being said, thinking twice about your current design and refactoring your source code is much better alternatives. Afterall, that's one of the reason why we do Unit Testing, to reduce code smell in our code. Here is the full source code for this article. I hope you find it useful.

BookDao.java

public enum BookDao {

    INSTANCE;

    public String getBookFromCache() {
        BookRepository repository = new BookRepository(true, "http://example.com:4416");
        return repository.queryBookTitle();
    }

    public String getRecentBookTitle() {
        BookRepository repository = new BookRepository();
        return repository.queryBookTitle();
    }

    public String getBookByIsbn(String isbn) {
        BookRepository repository = new BookRepository();
        return repository.queryBookTitle(isbn);
    }

}

BookRepository.java

public class BookRepository {

    // unused variables, for demonstration purpose only
    private boolean useCache;

    private String connectionUrl;

    public BookRepository(boolean useCache, String connectionUrl) {
        this.useCache = useCache;
        this.connectionUrl = connectionUrl;
    }

    public BookRepository() {
        this(false, "");
    }

    public String queryBookTitle(String isbn) {
        return queryBookTitle();
    }

    public String queryBookTitle() {
        return "xUnit Test Patterns";
    }
}

BookDaoTest.java


import com.aldoapps.mybookshop.BookDao;
import com.aldoapps.mybookshop.BookRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@RunWith(PowerMockRunner.class)
@PrepareForTest({BookDao.class})
public class BookDaoTest {

    @Test
    public void shouldReturnEffectiveJava1() throws Exception {
        // Given
        BookRepository mock = Mockito.mock(BookRepository.class);
        Mockito.when(mock.queryBookTitle())
               .thenReturn("Effective Java");

        PowerMockito.whenNew(BookRepository.class)
                    .withAnyArguments()
                    .thenReturn(mock);

        // When
        String bookTitle = BookDao.INSTANCE.getRecentBookTitle();

        // Then
        PowerMockito.verifyNew(BookRepository.class)
                    .withNoArguments();

        Assert.assertEquals("Effective Java", bookTitle);
        Mockito.verify(mock)
               .queryBookTitle();
    }

    @Test
    public void shouldReturnEffectiveJava2() throws Exception {
        // Given
        BookRepository mock = Mockito.mock(BookRepository.class);
        Mockito.when(mock.queryBookTitle())
               .thenReturn("Effective Java");

        PowerMockito.whenNew(BookRepository.class)
                    .withArguments(ArgumentMatchers.anyBoolean(),
                            ArgumentMatchers.anyString())
                    .thenReturn(mock);

        // When
        String bookTitle = BookDao.INSTANCE.getBookFromCache();

        // Then
        PowerMockito.verifyNew(BookRepository.class)
                    .withArguments(ArgumentMatchers.anyBoolean(), 
                                   ArgumentMatchers.anyString());

        Assert.assertEquals("Effective Java", bookTitle);
        Mockito.verify(mock)
               .queryBookTitle();
    }

    @Test
    public void shouldHaveSimilarIsbnValue() throws Exception {
        // Given
        String isbn = "978-0134685991";
        ArgumentCaptor<String> isbnCaptor = ArgumentCaptor.forClass(String.class);

        BookRepository mock = Mockito.mock(BookRepository.class);

        PowerMockito.whenNew(BookRepository.class)
                    .withNoArguments()
                    .thenReturn(mock);

        // When
        String ignoredBookTitle = BookDao.INSTANCE.getBookByIsbn(isbn);

        // Then
        PowerMockito.verifyNew(BookRepository.class)
                    .withNoArguments();

        Mockito.verify(mock)
               .queryBookTitle(isbnCaptor.capture());
        Assert.assertEquals(isbn, isbnCaptor.getValue());
    }
}