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.

Add the following to your dependencies

implementation(org.jetbrains.kotlinx:kotlinx-datetime:0.2.0)

Usage

import kotlinx.datetime.*
val today = Clock.System.todayAt(TimeZone.currentSystemDefault())

If you target Android devices running below API 26, you need to use Android Gradle plugin 4.0 or newer and enable core library desugaring.

https://github.com/Kotlin/kotlinx-datetime

The post Kotlinx Datetime appeared first on Creatronix.

This included all basic / built-in types like Strings and Integers.

In this part I will show you how you can pass custom objects.

Peprare your class

To use a custom class for passing between fragments it has to be of type Parcelable and you must use the annotation @Parcelize

import android.os.Parcelable
import kotlinx.parcelize.Parcelize

@Parcelize
class VideoPlayListItem(val videoID: String, val videoTitle: String): Parcelable {

}

Gradle Plugin

Add kotlin-parcelize to your module gradle.build

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'androidx.navigation.safeargs.kotlin'
    id "kotlin-parcelize"

Add argument in nav_graph.xml

<fragment
    android:id="@+id/VideoPlayerFragment"
    android:name="de.creatronix.levelup.fragments.VideoPlayerFragment"
    android:label="@string/video_player_fragment_label"
    tools:layout="@layout/fragment_video_player">

    <argument
        android:name="video"
        app:argType="de.creatronix.levelup.VideoPlayListItem" />
</fragment>

Pass data to fragment action

val action =
    VideoFragmentDirections.actionVideoFragmentToVideoPlayerFragment(
        clickedItem
    )
findNavController().navigate(action)

The post Pass custom objects via SafeArgs appeared first on Creatronix.

If you use a PatternLayout like this

appender.console.layout.type = PatternLayout
appender.console.layout.pattern = %m%n

you can customize the appearance of the output.

eg.

appender.console.layout.pattern = %d{yyyy-mm-dd-HH:mm:ss.SSS} %-4p %C{1}.%M [%t] - %m%n%ex

Parameter

Timestamps

%d{yyyy-mm-dd-HH:mm:ss.SSS}
2021-50-27-10:50:32.701

The post Log4j2 PatternLayout Cheatsheet appeared first on Creatronix.

Logging is a common good practice in software engineering. It enables you to monitor applications in production to gather information about crashes and other malfunctions for further analysis. It is the “little brother” of debugging and often a precursor for setting up test cases which can lead to reproducing the bugs on the developers machine.

Log4j2 is version 2 of the very famous Apache logging library log4j from the Java ecosystem.

This article describes a minimal working solution for log4j2 with Kotlin and Gradle.

Dependencies

To get started with log4j2 add the following lines to your build.gradle file in the dependency section:

implementation 'org.apache.logging.log4j:log4j-api:2.15.0'
implementation 'org.apache.logging.log4j:log4j-core:2.15.0'

Please make sure to use the latest 2.15.0 2.16.0 to avoid the Zero-Day Exploit! More Details

Configuration

Create a file with the name log4j2.properties under src/resources with the content:

status = error

appender.console.type = Console
appender.console.name = LogToConsole
appender.console.layout.type = PatternLayout
appender.console.layout.pattern = %m%n

rootLogger.level = error
rootLogger.appenderRef.stdout.ref = LogToConsole

Logger

In your code you can insert the log statements the following way:

import org.apache.logging.log4j.kotlin.logger

fun main() {
    val log = logger("Main")
    log.trace("Trace")
    log.debug("Debug")
    log.info("Info")
    log.warn("Warn")
    log.error("Error")
    log.fatal("Fatal")
}

Log Levels

In the configuration file you can set the log level.

e.g. rootLogger.level = error will log all log message which are more severe than error including error -> (fatal and error)

| Log msg |        |       |       |      |      |       |       |     |
|---------|--------|-------|-------|------|------|-------|-------|-----|
| trace   |        |       |       |      |      |       | x     | x   |
| debug   |        |       |       |      |      | x     | x     | x   |
| info    |        |       |       |      | x    | x     | x     | x   |
| warn    |        |       |       | x    | x    | x     | x     | x   |
| error   |        |       | x     | x    | x    | x     | x     | x   |
| fatal   |        | x     | x     | x    | x    | x     | x     | x   |
|         | off    | fatal | error | warn | info | debug | trace | all |
|         | config |       |       |      |      |       |       |     |

The post Log4j2 for Kotlin appeared first on Creatronix.

dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib"
     implementation 'org.jetbrains.kotlin:kotlin-script-runtime:1.4.32'
}

The post Kotlin Scripts with Gradle appeared first on Creatronix.

private void openVideoActivity(String video) {
    Intent newActivity = new Intent(this, PlayerActivity.class);
    newActivity.putExtra("videoId", video);
    startActivity(newActivity);
}

Retrieving data

final String videoID = getIntent().getExtras().getString("videoID");

In Kotlin it looks like this:

val intent = Intent(this, NewActivity::class.java).apply {
    putExtra("EXTRA_MESSAGE", "Test 123")
}
startActivity(intent)

Retrieving

val message = intent.getStringExtra("EXTRA_MESSAGE")

Further Reading

Passing data between fragments using SafeArgs

Pass custom objects via SafeArgs

The post Passing data between AndroidActivities appeared first on Creatronix.

Code

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.d("LifecycleTest", "onCreate")
    }

    override fun onStart() {
        super.onStart()
        Log.d("LifecycleTest", "onStart")
    }

    override fun onResume() {
        super.onResume()
        Log.d("LifecycleTest", "onResume")
    }

    override fun onPause() {
        super.onPause()
        Log.d("LifecycleTest", "onPause")
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        Log.d("LifecycleTest", "onSaveInstanceState")
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        Log.d("LifecycleTest", "onSaveInstanceState")
    }

    override fun onStop() {
        super.onStop()
        Log.d("LifecycleTest", "onStop")
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d("LifecycleTest", "onDestroy")
    }
}

The post Android App Lifecycle appeared first on Creatronix.

This is a pretty quick one:

Kotlin has the standard Java if / else if / else statements

val age = 12

if (age < 5) {
    println("Go to kindergarten")
} else if (age == 5) {
    println("Go to pre-school")
} else if (age > 5 && age <= 17) {
    println("Go to grade ${age - 5}")
} else {
    println("Go to college!")
}

But one nice feature is the when clause:

It feels like a mixture of switch/case and if/else with a flavor of ranges 🙂

when (age) { 
    0, 1, 2, 3, 4 -> println("Go to preschool") 
    5 -> println("Go to Kindergarten") 
    in 6..17 -> { 
        val grade = age - 5 println("Go to grade $grade") 
    } 
    else -> println("Go to college!") 
}

Ready for Part 5?

The post Learning Kotlin – Part 4 – conditionals appeared first on Creatronix.

I wanted to try writing an Android app. In spite of using plain old Java I wanted to give the new kid on the block Kotlin (from the Jetbrains folks) a try.

First observations

Coming from a Python background it’s good to see that Kotlin doesn’t use semi-colons! But the curly braces from Java make code blocks are still there, hmpf…

Variables

Kotlin has two ways of declaring “variables”:

• var: think variable: this is a mutable
• val: think values: this is read-only like const

Data Types and Type Inference

A nice thing about Kotlin is type inference. When it is clear which data type is meant you can leave out the data type from the declaration

Strings

val firstName = "Tony" 
val lastName = "Stark"

Concatenation

You can concatenate strings with the plus operator as you can do it in Python

val fullName: String = firstName + " " + lastName

Print and String interpolation

Kotlin has a built-in println function so you can stop typing System.out.println()

Less visual noise!

println(fullName)

A neat little feature is the string interpolation syntax. If You want to concatenate strings for logging output, you can write $stringName Locks similar to the Python f-Strings

println("Name: $fullName")

But there is more to it:
You can for example call functions inside strings as well:

println("String length: ${fullName.length}")

or access indices

println("2nd Index: ${fullName[2]}")

Ready for Part 2?

The post Learning Kotlin – Part 1 – strings and print appeared first on Creatronix.