Forem: Subbu Lakshmanan

Suspending functions should not be called on a different dispatcher

Subbu Lakshmanan — Mon, 14 Aug 2023 05:56:46 +0000

Why

There seems to be confusion around using Dispatchers in Coroutines. Dispatchers are used to mention the thread on which the coroutine should run.

Dispatchers.Main - Main thread
Dispatchers.IO - IO thread
Dispatchers.Default - CPU-intensive thread

While we should mention the dispatcher for the coroutine based on the work a function does, We don't need to do the same for the caller of the suspending function. i.e., The suspend function that does the actual work handles what dispatcher to use, and the caller of the function should not worry about it.

In fact, various libraries explicitly provide suspending APIs for long-running blocking operations. The complexity of moving the appropriate tasks to background threads is already taken care of within the library. When calling the library's suspending API, it does not have to be considered.

P.S: Dispatchers.Unconfined is not recommended to be used in production code and is not discussed here.

What to do

When you write a long-running or CPU intensive task, wrap the code with the appropriate dispatcher so that the caller of the function need not worry about it.
If the library provides suspending APIs, the library will take care of the dispatchers. (It's a good practice to check the documentation of the library to see if it provides suspending APIs)
If you are calling an existing suspending function, check if it uses the appropriate dispatcher. If not, wrap it with appropriate dispatcher to avoid mentioning one in the caller of the function.

How to do

Here's an example:

fun onDoneClicked() {
    viewModelScope.launch(Dispatcher.IO) {
        initiateSeeding()
    }
}

...

suspend fun initiateSeeding() {
    async {
        // Do some work that runs in IO thread
    }
}

Wrap the long-running IO task with Dispatcher.IO


suspend fun initiateSeeding() {
    async(Dispatcher.IO) {
        // Do some work that runs in IO thread
    }
}

Remove the dispatcher from the caller of the function

fun onDoneClicked() {
    viewModelScope.launch {
        initiateSeeding()
    }
}

Another good example is Retrofit. Retrofit provides suspending APIs for network calls. The library takes care of the dispatchers, and the caller of the function need not worry about it.

interface SeedApiService {
    @GET("seeds")
    suspend fun getSeeds(): List<Seed>
}

class SeedRepository(private val seedApiService: SeedApiService) {
    suspend fun getSeeds(): List<Seed> = seedApiService.getSeeds()
}

class SeedViewModel(private val seedRepository: SeedRepository) {
    fun fetchSeeds() {
        viewModelScope.launch {
          try {
            val seeds = seedRepository.getSeeds()
            // Do something with the seeds
          } catch (e: Exception) {
            // Handle error
          }
        }
    }
}

The library will handle the dispatchers, and We don't need to mention it in the viewModelScope.launch function.

References

This function has too many params

Subbu Lakshmanan — Sat, 05 Aug 2023 22:49:30 +0000

Why

As we add new functionality to an existing codebase, we tend to add more and more parameters to existing functions. Often, We want to minimize the changes to the current code and wrap the feature/bugfix quickly. While the intention is good, it can lead to many problems in the future.

Depending on the project, this number can vary. As per sonarlint, this number should be less than 7. Anything more than that indicates that either,

Function is doing too much
Parameters can be grouped to form a new class

While one can suppress this warning using @Suppress("LongParameterList"), it's better to refactor the code to avoid this warning.

What to do

Depending on the function, there are different ways to refactor the code to avoid this warning.

Check the usage of the parameters inside the function and see if you can
1. Remove parameters that may serve the same purpose
2. Split the function into multiple functions
Group related parameters into a new class and pass the class instance as a parameter

How to do

 fun showErrorDialog(
  title: String? = null,
  message: String? = null,
  positiveTitle: String? = null,
  negativeTitle: String? = null,
  val positiveButtonTextColor: Int? = null,
  isCancelable: Boolean = true,
  isSingleButtonDialog: Boolean = true,
  val inCompose: Boolean = false
) {
  ...
}

One way to fix this is to group the parameters into a new class and create a new overloaded function that takes the new class as a parameter.

data class DialogParams(
  val title: String? = null,
  val message: String? = null,
  val positiveTitle: String? = null,
  val negativeTitle: String? = null,
  val positiveButtonTextColor: Int? = null,
  val isCancelable: Boolean = true,
  val isSingleButtonDialog: Boolean = true,
)

fun showErrorDialog(
  dialogParams: DialogParams, 
  val inCompose: Boolean = false
) {
  ...
}

Replace the function call with the new function and pass the parameters as a new class instance.

fun showLoginFailed() {
  showErrorDialog(
    DialogParams(
      title = "Login Failed",
      message = "Please try again",
      positiveTitle = "Retry",
      negativeTitle = "Cancel",
      positiveButtonTextColor = R.color.green,
      isCancelable = false,
      isSingleButtonDialog = true
    )
  )
}

You can remove the old function once you replace all the usages with the new function.

Note: The code examples are simplified for brevity. Ideally, use string resources instead of hardcoded strings.

ViewModels should not expose suspending functions

Subbu Lakshmanan — Mon, 31 Jul 2023 03:45:36 +0000

Why

Sometimes the developer may add a suspend keyword to a function that calls another suspending function as that's the first auto-suggestion/warning provided by the IDE.

IDE makes it easy for the developer to auto-fix the warning by adding the suspend keyword to the function.

But, this breaks the rule Classes extending "ViewModel" should not expose suspending functions.

Views should not be responsible for directly triggering coroutines. Hence, ViewModel classes should prefer creating coroutines instead of exposing suspending functions to perform some piece of business logic. This approach allows for easier testing of your application, as ViewModel classes can be unit tested, whereas views require instrumentation tests.

What to do

When you find a function in a ViewModel which breaks this rule, follow these steps to refactor it:

Find the need for the suspend keyword in the function, i.e., check if the function is calling any other suspending function
- e.g., listOfPlants.collectLatest is a suspending function
See if you can wrap the suspending function call in a coroutine & use the appropriate scope & dispatcher
- e.g., viewModelScope.launch can be used to wrap the suspending function call
Remove the suspend keyword from the function
Remove creating coroutines from the caller of the function if it is not needed anymore

How to do

The example,

// In ViewModel
suspend fun listenForUpdates() {
    listOfPlants.collectLatest { plants ->
        plants.filter { it.isFavorite }.let { favorites ->
            // do something with favorites
        }
    }
}

// In Fragment
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    lifecycleScope.launchWhenStarted {
        viewModel.listenForUpdates()
    }
}

could be refactored to,

// In ViewModel
fun listenForUpdates() {
    viewModelScope.launch {
        listOfPlants.collectLatest { plants ->
            plants.filter { it.isFavorite }.let { favorites ->
                // do something with favorites
            }
        }
    }
}

// In Fragment
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    lifecycleScope.launchWhenStarted {
      viewModel.listenForUpdates()
    }
}

References

Coroutines: Best practices

Don't expose Mutable Flow Types

Subbu Lakshmanan — Sun, 23 Jul 2023 22:36:23 +0000

One of the recommendation in designing UI layer from the Android's guide to app architecture is to use 'Uni-Directional Data Flow'. This is achieved by viewModels exposing UI state via observer pattern and receive events from UI via callbacks.

One of the best practice in exposing the UI state is to use immutable data types like LiveData or StateFlow. But, sometimes, we may be tempted to use MutableStateFlow or MutableSharedFlow to expose the UI state. While they are very convenient for storing and adding updates of some data structures in event-driven paradigm & useful to manage such objects inside some class, it’s not recommended to expose them outside of the class.

Why

When properties of the types MutableStateFlow or MutableSharedFlow are accessible from outside of a class, data updates cannot be verified properly anymore.

val isBiometricEnabled = MutableStateFlow(false)

In the above example, the value of isBiometricEnabled can be changed from outside of the class. It is generally recommended to have only one class responsible for updating these flows, otherwise inconsistency issues and problems with maintainability, as well as bugs may be introduced.

What to do

To restrict write access, StateFlow or SharedFlow should be used together with private MutableStateFlow or MutableSharedFlow fields.

If the variable is used only for reading, change its type to StateFlow or SharedFlow
If the variable is used for writing, change its type to private MutableStateFlow or private MutableSharedFlow and add a public property with StateFlow or SharedFlow type that exposes the value of the private field

How to do

Here's one way of refactoring the code.

Find the usages of the variable in question (i.e., one that has MutableStateFlow or MutableSharedFlow type)
If the variable is used only for reading, change its type to StateFlow or SharedFlow
If the variable is used for reading & writing,
- Create a new variable with StateFlow or SharedFlow type that reads from the MutableStateFlow or MutableSharedFlow variable (use some naming convention to indicate that naming is temporary)
```
val isBiometricEnabled = MutableStateFlow(false)
val tempIsBiometricEnabled:StateFlow<Boolean> = isBiometricEnabled.asStateFlow()
```

Replace 'read' usages with the new variable

Change the type of the MutableStateFlow or MutableSharedFlow variable to private & rename it to indicate that it is private

private val _isBiometricEnabled = MutableStateFlow(false)
val tempIsBiometricEnabled:StateFlow<Boolean> = _isBiometricEnabled.asStateFlow()

Fix the naming of the new variable to match the naming convention

private val _isBiometricEnabled = MutableStateFlow(false)
val isBiometricEnabled:StateFlow<Boolean> = _isBiometricEnabled.asStateFlow()

Check the usages to verify that isBiometricEnabled is not used for writing anywhere outside of the class and _isBiometricEnabled is not exposed outside of the class

References

Here are some references to the articles that I found useful

coroutines-best-practices-mutable-types

Non-Transitive R Classes

Subbu Lakshmanan — Mon, 17 Jul 2023 06:47:26 +0000

While upgrading my android project to use AGP 8.0.0, I noticed that android build analyzer had a recommendation to use non-transitive R classes to improve build speed.

I was curious to know what it is and how it works. So, I did some research and here's what I found.

Why

Non-transitive R classes have been around for a while, but it was not enabled by default. With AGP 8.0.0, it is enabled by default. For the curious minds, I have included a blog that talks about the history of R classes and non-transitive R classes at the end of this article.

Non-transitive R classes enable namespacing of each library’s R class so that its R class includes only the resources declared in the library itself and none from the library’s dependencies, thereby reducing the size of the R class for that library.

For example, if the code uses a default animation R.anim.nav_default_enter_anim which comes from the androidx.navigation:navigation-ui-ktx dependency. Without using non-transitive R classes, The 'R' class of module has references to its own resources and transitive references to resources of navigation UI library.

  import com.learning.compose.R
  ...

    .setStartAnimations(activity, R.anim.nav_default_enter_anim, R.anim.nav_default_exit_anim)

With non-transitive R classes enabled, this will force us to use the fully qualified R class name to access the resources in the dependency module, thus reducing the references in the 'R' class of 'compose' module. And also by referencing using fully qualified R class name, the Compose module doesn't have to be recompiled and the build speed is improved.

  .setStartAnimations(activity, androidx.navigation.ui.R.anim.nav_default_enter_anim, androidx.navigation.ui.R.anim.nav_default_exit_anim)

Since the dependencies become more explicit with non-transitive R classes, the modularity of the code increases. It also decreases complexity, since resources cannot come from transitive dependencies. It also increases the build speed(both clean and incremental) as promised by Android Developers from Android Dev Summit '21.

What to do

If you use a resource from another dependency/module,

If your android project is 100% Kotlin Only, You are in luck. You can alias imports of R classes of dependency modules to access resources in that module.
If your project has some Java code references, You have to use fully qualified R class name to access resources in the dependency module

Also, If you use a resource from another module, but you do not declare a dependency on that module, and you do not want to declare a dependency, you could simply duplicate resources in the app module

How to do

Use Android Studio's Refactor -> Migrate to non-transitive R classes to migrate the project to use non-transitive R classes

This will,

Adds the below in gradle.properties

android.nonTransitiveRClass=true

Updates fully qualified R class name wherever it finds the non-transitive R class usage

  .setStartAnimations(activity, androidx.navigation.ui.R.anim.nav_default_enter_anim, androidx.navigation.ui.R.anim.nav_default_exit_anim)

Additionally, If the code base is in Kotlin, You could alias the fully qualified package name of the R class to access the resources

  import androidx.navigation.ui.R as NavUiR

  ...
    .setStartAnimations(activity, NavUiR.anim.nav_default_enter_anim, NavUiR.anim.nav_default_exit_anim)
    .setExitAnimations(activity, NavUiR.anim.nav_default_pop_enter_anim, NavUiR.anim.nav_default_pop_exit_anim)

Here are some references to the articles that I found useful

Slimming Down Repo-1

Subbu Lakshmanan — Sun, 01 Jan 2023 22:23:00 +0000

Most of the repository providers (Github, Bitbucket) have a size limitation on the repository size and mechanisms to store large files using LFS options. In most cases, a repository may not reach these typical max size limits enforced. However, it can happen over a long period unless certain measures are taken to reduce the file size.

Disclaimer:

There are a lot of articles on what to commit to a repository and what to ignore. The assumption is that you have followed the guidelines not to store any runtime/build/temporary files, yet reach the size limit.

There are a few commands that can permanently delete the data. The suggested approach to a clean-up is to create a new clone of the repo, execute the clean-up procedure and verify the results. If you are happy with what you have arrived at, then push the changes to your remote.

Since the process involves re-writing history, you will need to 'force' push the changes to remote. So make sure to perform these commands with the approval of the team and only when it's required (i.e., The Git repo storage limit is reached).

These are a few commands to identify the biggest files that could be potential files to remove. You can remove these files and commit, but this will not remove the pack files associated with the original commits.

One way to remove the large files and the pack files associated with them is by using the git filter-branch along with the git reflog & git gc command.

Before beginning, Here are a few commands that we use to identify and remove bigger files.

To identify the size of the repo

 du -scH

To identify the count of files & other info

 git count-objects -vH

Identify the top 10 big files

 ls -ld -- **/*(DOL[1,10])

Identify the commits with the largest 'n' blobs (Sort ascending and list the last 'n' items)

  git verify-pack -v .git/objects/pack/<pack-name>.idx | sort -k 3 -n | tail -n 2

List the files in a commit

  git rev-list --objects --all | grep <commit-id>

Remove the file and re-write the history

  git filter-branch --index-filter 'git rm --cached --ignore-unmatch <File-to-be-removed>' --tag-name-filter cat -- --all

To prune older reflog entries

  git reflog expire --expire=now --all

To perform clean up unnecessary files and optimize the local repository

  git gc --prune=now

Here's a sequence of actions I performed in one of my repositories to reduce the storage. (I didn't reach the storage limit, I performed these steps to demo the idea)

Identify

Identify the biggest file in the repo

▶ du -scH                                                                                                                                      
257M    .
257M    total

▶ git verify-pack -v .git/objects/pack/pack-3c30d356e18bda774eb13dc9e53929012ec06800.idx | sort -k 3 -n | tail -n 2
f5ed007fc5ee61733ee9bec25fdeac3f0119644f blob   12362185 12166055 61415659
de3e5b333ba453655951cabdae20588419ef7fe0 blob   18025235 18030628 35112687

▶ git rev-list --objects --all | grep f5ed007fc5ee61733ee9bec25fdeac3f0119644f
f5ed007fc5ee61733ee9bec25fdeac3f0119644f Side_Projects/MemoryTiles/google-play-screenshots-v1-todoriliev.com.sketch/Data

Removal

▶ git filter-branch --index-filter 'git rm --cached --ignore-unmatch Side_Projects/MemoryTiles/google-play-screenshots-v1-todoriliev.com.sketch' --tag-name-filter cat -- --all
WARNING: git-filter-branch has a glut of gotchas generating mangled history
         rewrites.  Hit Ctrl-C before proceeding to abort, then use an
         alternative filtering tool such as 'git filter-repo'
         (https://github.com/newren/git-filter-repo/) instead.  See the
         filter-branch manual page for more details; to squelch this warning,
         set FILTER_BRANCH_SQUELCH_WARNING=1.
Proceeding with filter-branch...
...
...
Ref 'refs/heads/main' was rewritten
Ref 'refs/remotes/origin/ESI_Archive' was rewritten
Ref 'refs/remotes/origin/main' was rewritten
WARNING: Ref 'refs/remotes/origin/main' is unchanged
Ref 'refs/stash' was rewritten

Clean-up

The git filter-branch command will create backup refs in .git/refs/original. These refs must be deleted in order to remove references to these objects. Also, it's good to perform a garbage collection to do some clean-up.

▶ git for-each-ref --format="%(refname)" refs/original/ | while read ref; do git update-ref -d $ref; done  

▶ git reflog expire --expire=now --all

▶ git gc --prune=now
Enumerating objects: 7802, done.
Counting objects: 100% (7802/7802), done.
Delta compression using up to 10 threads
Compressing objects: 100% (3950/3950), done.
Writing objects: 100% (7802/7802), done.
Total 7802 (delta 4367), reused 6593 (delta 3732), pack-reused 0

▶ git verify-pack -v .git/objects/pack/pack-358d01cc2715da3d0f49ccea3e5d3352e596e7c0.idx | sort -k 3 -n | tail -n 2 
20ca85599c3decf2a972b0ede24ac0a8231b4cd9 blob   7218535 239853 111309837
b9785b3f3b5cddb633e7b2204d08c4bfd32ca501 blob   7608065 7502636 55950582

▶ git push
To github.com:subbramanil/my-dev-notes.git
 ! [rejected]        main -> main (fetch first)
error: failed to push some refs to 'github.com:subbramanil/my-dev-notes.git'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. This is usually caused by another repository pushing
hint: to the same ref. You may want to first integrate the remote changes
hint: (e.g., 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Documents/personal/my-dev-notes  main ✔                                                                                                                                          2h3m  ⍉
▶ git push -f
Enumerating objects: 7796, done.
Counting objects: 100% (7796/7796), done.
Delta compression using up to 10 threads
Compressing objects: 100% (3312/3312), done.
Writing objects: 100% (7796/7796), 133.17 MiB | 2.66 MiB/s, done.
Total 7796 (delta 4364), reused 7795 (delta 4364), pack-reused 0
remote: Resolving deltas: 100% (4364/4364), done.
To github.com:subbramanil/my-dev-notes.git
 + 734e92e...71bd9bb main -> main (forced update)

▶ du -scH
212M    .
212M    total

Reducing a repo size from 257 MB to 212 MB (45 MB) may not look like a big saving, however, the approach can be applied repeatedly to remove the bigger files to reduce the size of the repo.

I found out there there are two alternatives to achieve similar results. I will write a follow-up blog on these two.

git filter-repo (As noticed in the command line logs of git filter-branch)
BFG

References:

Extending beyond contributing to Github repos

Subbu Lakshmanan — Mon, 16 Mar 2020 21:32:15 +0000

Hactoberfest is what triggered me to start contributing to the open-source rather than being a bystander on the open-source community. Whenever I get some time, I am contributing to open source repositories since I first participated in Hacktoberfest. The goal was to exercise what I know already and learn new things from the open-source repositories.

While working on the open-source repositories, I always try to stick to the contributor guidelines and be conscious of the changes I propose. In the absence of contributor guidelines, I tried to make judgments based on common sense and proposed changes. Most of the time, it worked, and there were few exceptions where the maintainer didn't see the same way as I did. We agreed to ignore the changes and closed the Pull request. Sometimes the repository isn't actively maintained, which results in the pull requests being ignored by the maintainer.

I would like to know the opinions of the community on the below situations. What's the recommended way?

Note: For the discussion, please assume the repositories are MIT/apache licensed, and the intention is not getting around licensing.

Scenario #1: There's an open-sourced android app 'A.'

It is released in the play store
Has less than 50k installs
Actively maintained by the developer.

You propose a feature/behavior change that adds value to the app but doesn't directly fall in the line of the maintainer's vision. The new feature/behavior change has potential & can still be extended.

Assuming you feel that you would like to continue in your direction, Would you create a clone of the app & release it under a different name?

Scenario #2: Same scenario as #1

It is released in the play store
Has less than 50k installs
Not actively maintained by the developer.

Assuming you feel that you would like to continue in your direction, Would you create a clone of the app & release it under a different name?

Scenario #3: There's an open-sourced android app 'B,'

It is released in the play store
Has less than 50k installs
Actively maintained by the developer.

You like the architecture/design/UI of the app and feel it could be a great base code for a different app idea you have in mind.

How would you go about creating your app? Create a new repo and import the code and modify it for your use?

Mystery Sticker Pack 2019

Subbu Lakshmanan — Fri, 17 Jan 2020 21:04:53 +0000

Quick shout out to the fantastic Dev.to team!!

Note: This post is a bit late, I received the package a couple of weeks ago.

I like to collect stickers from only those technologies I have gained experience from & services/websites that are meaningful to my career. So happy to get the Special gift stickers for DEV open-source contributors.

Thank you so much for the awesome Dev.to Team for the excellent platform for the developers & continue to keep engagement through the new features.

P.S: The commit history is hilarious!!

Show Love Through Tech

Subbu Lakshmanan — Wed, 18 Dec 2019 21:57:54 +0000

When you are a nerd, What do you do to show your love?

As I was cleaning up my storage space in my apartment, I found my old cache of IoT related materials. Breadboards, Resistors, Capacitors, LEDs, Different types of sensors, Raspberry PIs & Arduino, and of course, lots of jump-wires. I used to play around with sensors, making a lot of fun with my roommates at college. Seeing that I had a few hours available over the weekend, I thought of setting up at least one sensor and test it out.

I typically use Raspbian for the ease of installation & familiar Debian environment. I downloaded the image, flashed to SDCard. I had no extra monitor at home, so I planned to login via SSH to my Raspberry Pi. I came to It's been a while since I used Raspbian, I didn't realize Raspbian has updated their security & blocked ssh on boot. I found out the correct way to enable SSH on boot & logged in.

I had a bunch of motion sensors, and I was quickly able to put it together and test it out with one of my old programs for motion testing. I showed it to my wife; Having a Bachelor of Engineering in an Electronics, the demo didn't impress her a lot. In any case, I was happy that I didn't lose touch.

I wanted to do something a bit more fun, and I found an LED matrix in the cache, which I didn't remove from the package. (Guess, I planned to do something with it but closed the shop even before trying it out).

I typically prefer node.js for working on IoT projects. Looking for an npm package to work with LED matrix, I found several, but none seem promising (Most of them weren't up to date & I lost patience before getting them work). Then I came across the Python library luma-led-matrix, which was pretty quick to set up & had a bunch of examples that work.

Details of implementation

Hardware Required

Raspberry PI 2/3/4
MAX7219 8*8 LED matrix
Jumper wires

Software Required

Raspbian OS
Luma LED Matrix library

GPIO pin-outs

Board Pin	Name	Remarks	Rpi pin	Rpi function
1	VCC	+5V Power	2	5V0
2	GND	Ground	6	GND
3	DIN	Data In	19	GPIO 10 (MOSI)
4	CS	Chip Select	24	GPIO 8 (SPI CE0)
5	CLK	Clock	23	GPIO 11 (SPI CLK)

For more details:
luma-led-matrix documentation

I had to enable SPI, and there are enough tutorials on how to do it. Here's the one I followed: Sparkfun Tutorial on Enabling SPI on RaspberryPI

I showed my wife the demo of one of the examples, and she was a bit impressed.

The following day was 'her' day (meaning she can sleep as much as she wants and get up when she wants). So before I get to work, I changed the program to print, "I love you Mahi" & put it in a loop and left.

I received a text from her around lunchtime that she loved it. Finally Yeah!!

I'm sure that I'm not the only nerd who wanted to show off to loved ones. What's your experience in doing so?

Fastlane Setup in Ubuntu

Subbu Lakshmanan — Fri, 13 Dec 2019 16:42:54 +0000

The recipe we follow at my work for automating android app publishing is bitbucket + Teamcity + Fastlane + slack.

Choosing Fastlane for automatic publishing mobile apps to the store is no wonder. It's the most preferred way to publish apps automatically.

We use TeamCity for CICD at our work, We looked at a few of the cloud solutions for CICD, but finally, we opted to use TeamCity Professional Version as our CICD tool. It's free to use and 3 build agents with 100 build configurations which were more than enough for our purposes. And comparatively, We felt it was way easier to set it up and configure than Jenkins.

Of course, Jenkins has been there for a while and may have more community support and plugins than TeamCity, TeamCity felt easy to manage without a dedicated person for support. We did play around several other CICDs but finally settled with TeamCity.

Fastlane is officially supported to run on macOS, and it seems like Windows & Linux Support is coming up.

Since our TeamCity server (& the in-built build agent) was running on Ubuntu 14.04, We needed to install Fastlane in the same machine. The installation instructions for Fastlane on Ubuntu 18.04 is easy to find in comments of an issue.

Here are the installation steps for Ubuntu 18.04 from the comments.

Install ruby and ruby-dev headers
```
sudo apt install ruby ruby-dev
```
Set environment language variables. Add these lines to the top of ~/.profile
```
export LC_ALL=en_US.UTF-8
export LANG=en_US.UTF-8
```
Check that you didn't break the environment and restart. Run

source ~/.profile

in the terminal. If no output, you are safe. Otherwise, check for what you broke in the .profile file

Install Fastlane

sudo gem install fastlane
which fastlane  // Verify

From there do the normal Fastlane Setup

I ran into some issues while doing this setup. Some of the Gotchas while doing this.

Make sure to install Ruby 2.x version

sudo apt-add-repository ppa:brightbox/ruby-ng
sudo apt-get update
sudo apt-get install ruby2.4
ruby -v // Verify
sudo apt-get install ruby2.4-dev

Depends on your Ubuntu 14.04 environment, Sometimes the following needs to be installed
```
sudo apt-get install libc6-dev
sudo apt-get install g++
```
Fastlane uses the Google API client to communicate with the Google Play Console Services. I noticed this issue, 'Missing Google API Client' when installing Fastlane.
```
gem install google-api-client -v 0.29.1
```

That should be it, Hope that helps.

P.S: I wrote the draft of this blog a very long time ago and left it to pickle :D. I just decided to publish it after correcting the grammatical and misspelled words. Some of the errors may have been fixed.

HacktobeferFest:2019 Completed

Subbu Lakshmanan — Thu, 31 Oct 2019 16:19:38 +0000

Yeah, I did it, 2nd time completing Hacktoberfest. It's been extra fun working on Hacktoberfest this year (extra special coz., I had loads of fun working on a puzzle game in android).

First of all, Huge thanks to DigitalOcean and dev.to for organizing the Hacktoberfest 2019. Of course, the primary objective of my participation is to get the cool T-Shirts & Sticker and a self-gratifying of human behavior of achieving something. But along the way, I felt a bit happy about contributing to somebody's work and giving it back to the community.

It all started with one of our dev.to community buddy
Beautus S Gumede's question regarding how to write test cases a year back.

How to write tests for an android app?

Beautus S Gumede ・ Oct 5 '18 ・ 1 min read

#kotlin #java #android #discuss

I was much more active in 'dev.to' than nowadays. What started as answering to a question, led me to complete Hacktoberfest in 2018.

HactoberFest Challenge: Completed

Subbu Lakshmanan ・ Oct 30 '18 ・ 3 min read

#hacktoberfest #android #opensource

I started this year early. So the Hacktoberfest plan for this year is.

# Plan

- [x] Identify repos to contribute (Criteria: Android, Java/Kotlin, Easy/Medium difficulty)
- [x] Follow best coding practices & use conventional commits for git commits
- [x] Submit PRs
- [x] Get the HacktoberFest T-Shirt

Learnings

Lesson 1: You can learn a lot of new things when you review a repo & fix/add things

Issue

Build fails on Android Studio 3.4.x and 3.5, since libraries officially migrated to `androidx` #1

dpezely posted on Aug 23, 2019

Thank you so much for publishing this wonderful guide with source code!

Would you be so kind as to do a quick update, please? There were significant changes in the Android development world since your post in January 2019.

For instance, as of May 2019, Google recommends Kotlin for new development of Android apps-- you were one step ahead! Migration to androidx is out of preview and official, such that android.support.v7.app becomes androidx.appcompat.app, etc. As noted in comments to the blog post, there are deprecation warnings when running the python-based utilities.

Would you also note library versions used, please?

The Rust parts seem fine as of rustc v1.37.0, as expected.

As I'm new to both Kotlin and Android development, it would be a while before I'd be able to submit a PR with any confidence for this issue-- sorry.

Thanks!

View on GitHub

Add lint and fix issues #16

eduardb posted on Oct 09, 2019

What the title says.

View on GitHub

Several of my PRs focussed on improving the existing code by addressing lint warnings & suggestions based on my experience. Most of the lint warnings are pretty evident, and the android studio can help in resolving those. The below one was something I didn't come across and was glad to be bumped with the error. It allowed me to learn something new.

While working on the 'MEME' app, I came across the below deprecation as a result of running 'lint.'

Environment.getExternalStorageDirectory() is deprecated in SDK 29

From a quick research, found out baseContext.getExternalFilesDir("directory_name_to_create") can be used. And from the logs, able to understand the differences of their implementation as well.

10-15 15:31:05.328 27301-27301/com.example.lenovo.meme D/Test: Directory Path: baseContext.getExternalFilesDir("Meme"): /storage/emulated/0/Android/data/com.example.lenovo.meme/files/Meme
10-15 15:31:05.333 27301-27301/com.example.lenovo.meme D/Test: Environment.getExternalStorageDirectory(): /storage/emulated/0

Pull Requests

hotfix: Addresses Lint Warnings #20

subbramanil posted on Oct 23, 2019

Cleans up unused import statements
Applies appropriate scope qualifiers (i.e., private) for variables & functions
Moves hard-coded strings to String.xml & consts as required
Cleans up Regular expressions by removing unnecessary character escapes

Note:

Almost all of the fixes were applied automatically through Android Studio's Auto-Suggestions which made sense & appropriate. None of the changes should affect the functionality of the app. No files were removed, although there were unused files & references.
Reports character escapes that are replaceable with the unescaped character without a change in meaning. Note that inside the square brackets of a character class, many escapes are unnecessary that would be necessary outside of a character class. For example the regex [.] is identical to [.]
None of the changes should affect any functionality. But in case of any doubt, any change can be removed, analyzed & applied on another iteration.

Reference: #16

View on GitHub

Migration to AndroidX #2

subbramanil posted on Oct 03, 2019

Addresses https://github.com/vislyhq/rust-android-example/issues/1

View on GitHub

Migration to Latest Dev Tools #11

subbramanil posted on Oct 15, 2019

Migrates to 'kotlin' from 'java'
Upgrades gradle & gradle wrapper
Updates the compile & target SDK to fix warnings
Moves from 'appcompat' to 'androidx' library usage
Moves hard coded strings to 'Strings.xml'
Removes unused resources
Fixes Lint warnings
Fixes typos

This commit migrates the code base to the latest android development tools before adding new features. This will enable building new features quickly and attact more developers to work on.

The migration is done as follows,

Making use of Android Studio's tools: 'Convert Java to Kotlin' & 'Migrate to AndroidX'
Analyze the project using lint and apply auto-suggesions wherever possible
When auto-suggestion isn't available, apply sensible changes manually

Preview: Gets deleted after 30 days from Oct 15

View on GitHub

Lesson 2: Be conscious of the boundaries when proposing the changes & ask first

Issue

redesign/modify UI and UX #6

harshsri2208 posted on Oct 10, 2019

Interested people can redesign UI/UX for a better user experience. The current UI has a single page for all the activities and looks space deficient. Providing different pages for all the activities would provide a better control over the app.

View on GitHub

Also, one thing I learned this year was to be conscious of the boundaries & propose the changes. Although the primary goal of an owner/maintainer of a repository to get their bugs fixed, the implementation we provide may not align with what they need/requirements some times.

While working on this 'MEME' app, the question the maintainer was related to the UI/UX change. I had a pretty good idea for the UX flow, so I planned to work on it. However, I noticed that the app was written in Java, and as Google has been promoting Kotlin, I felt it would be better to migrate to 'Kotlin.' So I migrated the app from Java to Kotlin and worked on my idea and submitted PR.

But as I was working, I realized that I didn't check with the maintainer if he wished to migrate to 'Kotlin.' I opened up a discussion with the maintainer, and as I expected, he didn't want to migrate to Kotlin. No hard feelings; of course, the maintainer of a repo retains the right to decide what's best.

In any case, I submitted the PR as I wanted to increase the hacktoberfest count (to be honest). I added the idea & shared a video of the new UX in the comments, in case the maintainer wants to take a look.

I wish I asked the maintainer before starting working on the issue if he wanted to migrate the app from Java to Kotlin. In any case, it was fun to work.

Lesson 3: Contributing is more fun when you work on a game

Issue

Make UI more interactive #1

nikhilbansal97 posted on Sep 30, 2018

View on GitHub

The most fun I had was working on this repo: Memory-Game, which was a single screen memory based puzzle game. The repository was already in 'kotlin,' and I got a couple of ideas of extending the concept. I proposed a simple idea of providing 'difficulty' and let the user choose and play. Another idea was to allow the user to start at the beginner level and increase the difficulty as he finishes each level. I submitted PRs for both, and It was enjoyable working on this app.

Pull Requests

Migration to Latest Dev Tools #12

subbramanil posted on Oct 16, 2019

feat: Migration to Latest Dev Tools

- Upgrades gradle & gradle wrapper
- Updates the compile & target SDK to fix warnings
- Moves from 'appcompat' to 'androidx' library usage
- Moves hard coded strings to 'Strings.xml'
- Fixes Lint warnings

This commit migrates the code base to the latest android development tools before adding new features.

The migration is done as follows,

- Analyze the project using lint and apply auto-suggesions wherever possible
- When auto-suggestion isn't available, apply sensible changes manually

View on GitHub

Simple Game Idea with three challenge levels #13

subbramanil posted on Oct 16, 2019

feat: Simple Game Idea with three challenge levels

- Adds new launcher activity with challenge levels
- Replaces the hard-coded number of tiles & tries with flexible number based on challenge

The idea is to present the user with three challenge levels

1. Easy
2. Medium
3. Hard

Based on the user choice, set the number of tiles & max. number of tries. The user can play as many times as he wants in the current challenge level. To choose a much challenging level, he has to go back to the start of the app and change and continue playing. We can track how quickly user clears a challenge and award points/stars.

For now,

Easy -> 4 tiles, 4 tries
Medium -> 6 tiles, 6 tries
Hard -> 8 tiles, 8 tries

The number of tiles & tries are chosen as the same for simplicity but can be improved.

Screenshots:

Start

Easy

Medium

Hard

View on GitHub

Game with progressive levels #14

subbramanil posted on Oct 18, 2019

feat: Game with progressive levels

- Adds 'level' to the game to track the current level
- Shows 'current level' before starting a game
- Makes dialog dismiss listener as optional to avoid the need of additional listener
- Removes code imported from simple game branch

The idea of the game is to start with level 1 and increase difficulty as you win.

Level 1..3 -> 4 tiles & 4 tries
Level 4..7 -> 8 tiles & 8 tries
Level 8..20 -> 10 tiles & 10 tries

Games starts with level 1 and as the player wins the game, he's taken to next level. Once the max level is reached, the game will end. As of the max level is set to 10.

Level 1

Level 4

Level 8

Game Completion

View on GitHub

Learn by contributing to Open Source

Subbu Lakshmanan — Mon, 17 Jun 2019 21:43:02 +0000

In the recent Google I/O, Google announced Kotlin to be the first choice language for writing Android apps. Since few years before Google announced that, Kotlin is preferred language and added kotlin support to the android studio, this news doesn't come as a surprise for me.

When the announcement came a year ago, I registered for many courses, finished a couple of them. I felt good about completing the exercises & sample projects. However, It lasted only for a while. With my personal (got married to a wonderful girl) & work commitments doubled(they let go of a few folks at my work), I took a break from learning kotlin.

When I started again, I struggled a lot and confused as to where to start again, as I was in the middle of several kotlin courses. Although the courses I registered to learn kotlin were pretty good, I realized that I'm more of a reading person. I don't mind reading documentation or several blogs to understand a concept and try out on my own. Watching a video course and following along a tutorial felt too slow for me.

I worked on small projects as I was learning. Although the personal projects were helpful to understand the fundamentals, it had few challenges.

Focus on scope: It was up to me to decide the scope of the project. Sometimes I tend to expand on my idea on personal projects, and I spent more time on things that weren't relevant to kotlin.
Focus on Technology Stack: Again, it's up to me to decide the architecture and design of the app, the libraries to use. While identifying answers to these technical questions, I lost track of my goal(which is learning Kotlin). For ex., I lost loads of time when I started with the goal of looking for blogs related with data classes and somehow followed blogs on sample apps that are built using the MVVM + RxKotlin + Dagger2. Although it is good to learn about this setup, it wasn't contributing directly to my original goal.

That's when I decided to start learning Kotlin again from scratch, but this time with a better clear plan.

So the mistakes that I did earlier in learning Kotlin were,

Trying to learn Kotlin from too many sources
Didn't start with what's working out well for myself (Reading vs. Video courses)
Didn't have a plan with a defined schedule
Didn't have a defined scope on personal projects

I learned from my experience and created a plan.

Goal: To Learn & develop an App in Kotlin and publish to the store by Sep 2019

The plan to do that,

Buy a book for learning Kotlin: Kotlin Programming: The Big Nerd Ranch Guide
Work on Personal project with limited scope: An Android App
1. Outlined the basic idea of the app
2. Identified the functionality scope of the app
3. Identified the technology scope of the app
4. Designed simple UI/UX flow using sketch app

Learn by Contributing to open source

I have participated in Hactoberfest last year and contributed to Slim-Launcher app by Beautus S Gumede. I completed my Hactoberfest challenge and got my T-Shirt as well. It felt good to give back to the community.

When looking back,

I learned a lot while working on the project. The app uses Kotlin, and It was a good exercise for me to flex my skills.
The app was published to store and had a defined technical scope to it. It helped me to focus on one thing and work within the boundary.
I thoroughly enjoyed interacting with the project developer Beautus S Gumede and working on the project. While we both were strangers, connected through his blog on dev.to, I enjoyed working on his project and liked the candidness and the appreciative character of Beautus S Gumede.

This exercise made me realize that I could learn a lot more by working on projects with definitive design and functionality. I could look into the code, fix a bug, or add a feature and learn from the project.

This had led me to add one more step to my learning plan,

Buy a book for learning Kotlin
Work on Personal project: Android App
Contribute to open source projects

So far, I have contributed to,

Currently, I'm working on an enhancement request in the projects,

I typically make notes of my learnings as I work on a project, and I plan to write a series of blogs once the PRs are submitted and merged.

Note: I found out about the repositories through Github "Discover Repositories" feature. However, now that we have a listing in 'Dev.to,' I'm going to create a listing for volunteering to work on open source Android/kotlin based projects where I can contribute and learn as well. (Although, I'm going to delay that until I finish my current commitments)