import java.nio.file.Paths

fun main() {
    val cwd = Paths.get("").toAbsolutePath()
    println(cwd.toString())
}

The post How to get the current working directory in Kotlin appeared first on Creatronix.

BufferedReader br = new BufferedReader(new FileReader("data.txt")); 

try { 
    StringBuilder sb = new StringBuilder();
    String line = br.readLine(); 
    
    while (line != null) { 
        sb.append(line); 
        sb.append(System.lineSeparator());
        line = br.readLine(); 
    } 
   
    String content = sb.toString(); 
} finally { 
    br.close(); 
}

This is a code sample reading a files content in plain old Java. What a mess 🙂

With Kotlin

Look at this beauty!

val file = File("./data.txt") 
val contents = file.readText() 
val lines = contents.lines() 

lines.forEach { println(it) }

Yes there is Apache commons IO and yes since java 7 things have been easier as well, but with Kotlin I feel like I can concentrate on solving problems and not trying to don’t do things wrong 🙂

Further Reading

https://stackoverflow.com/questions/4716503/reading-a-plain-text-file-in-java

Kotlin Tutorial

The post Reading files with Kotlin appeared first on Creatronix.

First you need to add the following dependency to your build.gradle file

dependencies {

    testImplementation 'org.jetbrains.kotlin:kotlin-test'

As a second step you need to add the task

test {
    useJUnitPlatform()
}

Implementation

When you are familiar with JUnit you may recognized the @Test annotation.

Assertions work pretty much the same. You can choose from a variety of assert functions.

import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue

internal class TestCC06 {

    @Test
    fun testPasswordLength() {
        val myPassword: String = generatePassword()
        assertEquals(8, myPassword.length)
    }
    @Test
    fun testPasswordHasDigit() {
        val myPassword: String = generatePassword()
        var hasDigit = false
        println(myPassword)
        for (c in myPassword){
            if(c.isDigit()){
                hasDigit = true
            }
        }
        assertTrue(hasDigit)
    }

The post How to write unit tests in Kotlin appeared first on Creatronix.

Learning Kotlin Part 1 – print

Learning Kotlin Part 2 – arrays

Learning Kotlin Part 3 – ranges

Learning Kotlin Part 4 – conditionals

Learning Kotlin Part 5 – loops

Learning Kotlin Part 6 – functions

Learning Kotlin Part 7 – multiple return values

Reading files with Kotlin

How to get the current working directory in Kotlin

Classes in Kotlin Part 1

Classes in Kotlin Part 2

How to create a mutable list in Kotlin?

Log4j2 for Kotlin

Kotlinx Datetime

How to write unit tests in Kotlin

The post Kotlin Tutorial appeared first on Creatronix.

Motivation

There are a lot of reasons to use Dependency Injection, or even a Framework for it.

In this Article you’ll learn what Dependency Injection is, what benefits and downsides it has and how to use it with the usage of the Koin Framework.

Let’s look at a example of a House with a Doorbell to better understand what dependency injection is.

The House class has a function that returns a String representing the current Ringtone according to the installed doorbell.

Without Dependency Injection:

class House() {
    private val myDoorbell: Doorbell
   
   init {
       myDoorbell = SpeakingDoorbell()
   }
   
   fun ringDoorbell(): String {
       return "Current ringtone " + myDoorbell.getRingtone()
   }
}

fun main() {
    val myHouse = House()
   
    println(myHouse.ringDoorbell())
}

With Dependency Injection:

class House(private val myDoorbell: Doorbell) {
   fun ringDoorbell(): String {
       return "Current ringtone " + myDoorbell.getRingtone()
   }
}

fun main() {
    val myDoorbell: Doorbell = SpeakingDoorbell()
    val myHouse = House(myDoorbell)
   
    println(myHouse.ringDoorbell())
}

As you can see in the variant without Dependency Injection the House class has a direct dependency to the SpeakingDoorbell class.

With Dependency Injection this reference no longer exists. The only reference
remaining is to the generalized Doorbell Interface.

Benefits of Dependency Injection

Flexibility

Lets suppose another class FunnyDoorbell should be used in the future, which also implements the Doorbell interface.

Exchanging the SpeakingDoorbell class later on is less work with Dependency Injection.

In the first example the House class would have to change its implementation to switch to the FunnyDoorbell class.

But with Dependency Injection this change can be done without touching the House class.

In fact the House class does not even know whether it got an instance of SpeakingDoorbell or FunnyDoorbell.

This allows to write more flexible code which can be modified and extended easier.

A looser coupling between classes is achieved.

Testability

When writing tests one cannot test the House class in the first example in isolation to the SpeakingDoorbell class.

With Dependency Injection it’s very easy to insert mocks instead of the real instance.

Downsides of Dependency Injection

There is one part that got more complex though. The main function now knows not only the House class, but also the SpeakingDoorbell class.

This ultimately leads to a really big main function, that knows almost every component.

In this small example this is no issue, but when developing large applications we want the benefits of Dependency Injection, but as few downsides as possible.

This is exactly where Dependency Injection Frameworks comes into play!

They help to structure the whole block how and when to instantiate which classes and usually bring with them a bunch of useful features.

So let us look into the Dependency Injection Framework Koin.

Setting up Koin

Gradle

Add the following to your gradle configuration.
Get the latest Koin version [here](https://insert-koin.io/docs/setup/v3).

// Add Maven Central to your repositories if needed
repositories {
    mavenCentral()    
}
dependencies {
    // Koin for Android
    implementation "io.insert-koin:koin-android:$koin_version"
}

Application

Create an application class if you have none yet (don’t forget to add it to the manifest).

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
     
        startKoin {
            androidContext(this@MyApplication)
            modules(
                module {
                    single { House(get()) }
                    single<Doorbell> { SpeakingDoorbell() }
                }
            )
        }
    } 
}

Profit

That’s it! This is the basic Koin setup. As you can see the House class now even fetches its needed instance of Doorbell.
Simply call startKoin, configure the AndroidContext and define some Beans. These can also be injected like this into Android components like activities:

val myVariable: MyVariableType by inject()

ViewModel injection

The avid reader might already have noticed something. “What about our ViewModels. They have a lifecycle and should not get created just like that”.

To fix this issue there exists an extension for Koin.

Instead of declaring a Bean like that

single { MyClass() }

we use

viewModel<MyViewModelType> { MyViewModel() }

The injection is then done inside the fragment like that:

val myViewModel: MyViewModelType by viewModel()

Conclusion

Using Dependency Injection, especially with a framework, can be intimidating for a new programmer.

But in the most cases the positive aspects outweigh the negatives and the complexity of setting up a dependency
injection framework is quite low.

There are a lot of other things Koin can do like defining factories instead of singles, directly helping out with tests, instantiating fragments, or much more.

Have a glance at the official documentation

The post Dependency Injection with Koin and Kotlin in Android appeared first on Creatronix.

Camera: Camera new cameraInitNormal:-13

on Android 8. To fix this You have to integrate some code to check if permission is already granted by the user and in case it is not, request the rights for it at runtime.

This looks like this:

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)
    val scannerView = binding.scannerView
    val activity = requireActivity()

    if (ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA)
        != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.CAMERA), 50);
    }

Now the user is asked every time when the camera feature shall be accessed:

The post How to fix Camera: Camera new cameraInitNormal:-13 appeared first on Creatronix.

Dependency

implementation 'com.google.android.material:material:1.4.0'

Layout

A snackbar must be tied to a coordinator layout. If you use fragments the standard layout is FrameLayout which can be directly swapped with:

<androidx.coordinatorlayout.widget.CoordinatorLayout

Snackbar

val snackbar = Snackbar.make( 
    binding.root, 
    "No internet connection! Please enable WiFi or Mobile Data", 
    Snackbar.LENGTH_INDEFINITE ) 
snackbar.show()

Further Reading

Passing data between fragments using SafeArgs

Dependency Injection with Koin and Kotlin in Android

How to use ViewModel in Android

The post How to use Snackbars appeared first on Creatronix.

Import

import android.util.Log

Tag

class MainActivity : AppCompatActivity() {
    companion object {
        const val TAG = "MainActivity"
    }

Log statement

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    Log.d(TAG, "onCreate")
}

Logcat

Further Reading

Stetho: A debug bridge for Android applications

Dependency Injection with Koin and Kotlin in Android

versionCode vs versionName in Android Apps

The post Logging in Android appeared first on Creatronix.

class Planet(
    val diameter: Int,
    val distanceToSun: Double,
    val mass: Double
)

But wait: there is more:

Init block

The primary constructor cannot contain any code so init block for the rescue:

class Planet(
    val diameter: Int,
    val distanceToSun: Double,
    val mass: Double
) {
    val circumference = PI * diameter
    init {
        println(circumference)
    }
}

Notes:

• You can have more than one init block
• they run in order of their declaration

The post Classes in Kotlin – Part 2 appeared first on Creatronix.

Jokes aside, classes are still the building blocks of modern object oriented software design. And of course as the new kid on the block Kotlin has it’s own take on this subject.

Declaration

Let’s look at the most basic class declaration:

class Earth{
    
  val diameter = 12756
    
  val distanceToSun = 149.6e6
    
  val mass = 5.9724e24

}

Initialization

class Planet(
    
  val diameter: Int,
    
  val distanceToSun: Double,
    
  val mass: Double

)

Instantiation

fun main() {
    
  val earth = Planet(diameter = 12756, distanceToSun = 149.6e6, mass = 5.9724e24)
    
  println(earth.diameter)
    
  println(earth.distanceToSun)
    
  println(earth.mass)
}

The post Classes in Kotlin – Part 1 appeared first on Creatronix.