Pragmatic Kotlin on Android

Pragmatic Kotlin on Android
Josh Skeen | [email protected] | @mutexkid

View Slide

Who am I?
Android Developer & Instructor at Big Nerd Ranch

View Slide

The Story So Far…
• Started with a Legacy Java/Android
Application (side-project)
Code and slides: https://goo.gl/gmFMqS

View Slide

The Story So Far…
• Run Automatic Conversion to Kotlin

View Slide

The Story So Far…
• Learn from What Changed

View Slide

The Story So Far…
• Learn from What Changed
• Improve upon Design w/ Kotlin Features

View Slide

Running the Automatic Conversion
RxFragment.java

View Slide

Running the Automatic Conversion
RxFragment.java RxFragment.kt
abstract class RxFragment : Fragment() {
var requestInProgress = false
val compositeDisposable: CompositeDisposable = CompositeDisposable()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
if (savedInstanceState != null) {
requestInProgress = savedInstanceState.getBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, false)
}
}
override fun onSaveInstanceState(outState: Bundle?) {
super.onSaveInstanceState(outState)
outState!!.putBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, requestInProgress)
}
override fun onResume() {
super.onResume()
if (requestInProgress) {
loadRxData()
}
}
override fun onPause() {
super.onPause()
compositeDisposable.clear()
}
abstract fun loadRxData()
companion object {
private val EXTRA_RX_REQUEST_IN_PROGRESS = "EXTRA_RX_REQUEST_IN_PROGRESS"
}
}
public abstract class RxFragment extends Fragment {
private static final String EXTRA_RX_REQUEST_IN_PROGRESS = "EXTRA_RX_REQUEST_IN_PROGRESS";
private boolean requestInProgress;
public boolean isRequestInProgress() {
return requestInProgress;
}
public void setRequestInProgress(boolean requestInProgress) {
this.requestInProgress = requestInProgress;
}
private CompositeDisposable compositeDisposable;
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
compositeDisposable = new CompositeDisposable();
requestInProgress = savedInstanceState.getBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, false);
}
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, requestInProgress);
}
@Override
public void onResume() {
super.onResume();
if (isRequestInProgress()) {
loadRxData();
}
}
@Override
public void onPause() {
super.onPause();
compositeDisposable.clear();
}
public abstract void loadRxData();
}

View Slide

RxFragment.java
1. Properties Aren’t Fields

View Slide

}
}
@Override
}
}
@Override
}
@Override
super.onResume();
loadRxData();
}
}
@Override
super.onPause();
}
}
Before and After..
}
}
}
super.onResume()
loadRxData()
}
}
super.onPause()
}
companion object {
}
}
}
}
@Override
}
}
@Override
}
@Override
super.onResume();
loadRxData();
}
}
@Override
}
}
}
super.onResume()
loadRxData()
}
}
super.onPause()
}
companion object {
}
}

View Slide

No Getters & Setters‽
private static final String EXTRA_RX_REQUEST_IN_PROGRESS = "EXTRA_RX_REQUEST_IN_PROG
}
}
@Override
requestInProgress = savedInstanceState.getBoolean(EXTRA_RX_REQUEST_IN_PROGRE
}
}
@Override
}
val compositeDisposable: CompositeDisposable = Comp
override fun onCreate(savedInstanceState: Bundle?)
requestInProgress = savedInstanceState.getB

View Slide

Direct Access‽ What About Encapsulation‽
private fun Observable.applyRequestStatus(rxFragment: RxFragment): Observable =
doOnSubscribe { rxFragment.requestInProgress = true }
.doOnTerminate { rxFragment.requestInProgress = false }
RxUtil.kt:

View Slide

Looking under the Hood…

View Slide


View Slide

generates this…

View Slide

public final boolean getRequestInProgress() {
return this.requestInProgress;
}
public final void setRequestInProgress(boolean var1) {
this.requestInProgress = var1;
}
generates this…

View Slide

2. Var and Val mean “writable” and “read-only”

View Slide

var/val syntax: var
}
}
}
}
var

View Slide

var/val syntax: val
val requestInProgress = false
private final boolean requestInProgress;
}
}
Read-only, not immutable!
val

View Slide

Proof: val != immutable!
private val notImmutable: Int
get() {
return (Math.random() * 10).toInt()
}

View Slide

Proof: val != immutable!
private val notImmutable: Int
get() {
return (Math.random() * 10).toInt()
}
public final int getNotImmutable() {
return (int)(Math.random() * (double)10);
}

View Slide

Related: No Primitives?

View Slide

3. No Static Keyword, Use File-Level or Object
Instead

View Slide

}
}
@Override
}
}
@Override
}
@Override
super.onResume();
loadRxData();
}
}
@Override
super.onPause();
}
}
Before and After..
}
}
}
super.onResume()
loadRxData()
}
}
super.onPause()
}
companion object {
}
}
}
}
@Override
}
}
@Override
}
@Override
super.onResume();
loadRxData();
}
}
@Override
super.onPause();
}
}
requestInProgress = savedInstanceState.getBoolean(EXTRA_RX_REQUEST_IN_PROGRESS,
}
}
}
super.onResume()
loadRxData()
}
}
super.onPause()
}
companion object {
}
}
3. No Static Keyword

View Slide

What Changed: Where’d static go?!
private static final String EXTRA_RX_REQUEST_IN_PROGRESS =
"EXTRA_RX_REQUEST_IN_PROGRESS";
companion object {
}

View Slide

Object’s not java.lang.Object!
companion object {
}

View Slide

What Changed: Where’s static‽
companion object {
}

View Slide

companion object {
}
compositeDisposable = CompositeDisposable()
requestInProgress =
savedInstanceState.getBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, false)
}
}
What Changed: Where’s static‽

View Slide

companion object {
}
compositeDisposable = CompositeDisposable()
requestInProgress =
}
}

View Slide

public static final class Companion {
private final String getEXTRA_RX_REQUEST_IN_PROGRESS() {
return RxFragment.EXTRA_RX_REQUEST_IN_PROGRESS;
}
private Companion() {
}
// $FF: synthetic method
public Companion(DefaultConstructorMarker $constructor_marker) {
this();
}
}

View Slide

Related: Java Interop
class Foo {
companion object {
val QAZ = "STATIC CLING"
}
}
public static void main(String[] args) {
Foo.Companion.getQAZ();
}

View Slide

Related: Java Interop
class Foo {
@JvmField
companion object {
val QAZ = "STATIC CLING"
}
}
public static void main(String[] args) {
println(Foo.Companion.getQAZ());
println(Foo.QAZ);
}
3. No Static Keyword (don’t cling to static)

View Slide

4. Automatic Migration Makes Mistakes!

View Slide

Automatic Migration Mistakes
private const val EXTRA_RX_REQUEST_IN_PROGRESS = "EXTRA_RX_REQUEST_IN_PROGRESS"
…
companion object {
}
- companion object often unneeded

View Slide

Automatic Migration Mistakes
private const val EXTRA_RX_REQUEST_IN_PROGRESS =
"EXTRA_RX_REQUEST_IN_PROGRESS"
…
File level deﬁnition - totally normal in Kotlin!
- companion object often unneeded

View Slide

Clean Up: Use File Level Constants
private const val EXTRA_RX_REQUEST_IN_PROGRESS =
"EXTRA_RX_REQUEST_IN_PROGRESS"
…
- Use File Level Constant if possible

View Slide

Cleaning up Automatic Migration: Nullability
outState!!.putBoolean(EXTRA_RX_REQUEST_IN_PROGRESS,
requestInProgress)
}
- nullability is often mistranslated

View Slide

Cleaning up Auto Migration: Nullability
}
“Nullability?”
Fragment.java

View Slide

}
Don’t see a @NonNullable annotation either…
Assume it’s nullable.
Fragment.java

View Slide

outState!!.putBoolean(EXTRA_RX_REQUEST_IN_PROGRESS,
requestInProgress)
}

View Slide

1. Manages ﬁeld, a getter and a setter as needed
2. No direct access to creating Fields in Kotlin.
3. Even more powerful when used with Extensions!
4. No primitives, but translated to primitives in byte code
5. Override getter/setter operators for the property, don’t adds functions
Takeaways

View Slide

Takeaways
2. Var and Val mean “readable/writable” and “read-only”
1. val != immutable!
2. For vals and vars, can’t specify primitives for type (but they are correctly “unboxed” in
bytecode)

View Slide

1. ‘object’ (singleton instance) or file level values & functions now
2. Favor file-level values/functions unless ne
3. Properties and functions at the file level are 100% normal in Kotlin
4. Java Interop annotations support generating static fields that match Java style
Takeaways

View Slide

1. Often gets nullability wrong when generating Kotlin from Java, since anything goes in
Java. Relies on @Null/@NonNull annotations to generate
2. Companion objects are often not needed
3. not quite idiomatic Kotlin…but, a good start!
Takeaways

View Slide

Improve Upon Design w/ Kotlin Features

View Slide

1. Let/Apply to Drop Null Checks & Conﬁg
Objects

View Slide

}
}
}
super.onResume()
loadRxData()
}
}
super.onPause()
}
companion object {
}
}
}
}
}
super.onResume()
loadRxData()
}
}
super.onPause()
}
companion object {
}
}
Code Smells: != null Checks
1. Let/Apply to Drop Null Checks & Conﬁg Objects
RxFragment.kt

View Slide

First thought: Make sure it actually needs to
be nullable!
}
}
}
super.onResume()
loadRxData()
}
}
super.onPause()
}
companion object {
RxFragment.kt

View Slide

Fix: Use Let with Safe Call Operator
savedInstanceState?.let {
requestInProgress = it.getBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, false)
}
}
}
}
RxFragment.kt

View Slide

Code Smells: == null
abstract class SingleFragmentActivity : AppCompatActivity() {
protected abstract fun createFragment(): Fragment
public override fun onCreate(savedInstanceState: Bundle?) {
if (savedInstanceState == null) {
supportFragmentManager.beginTransaction()
.add(R.id.fragment_container, createFragment())
.commit()
}
}
}
SingleFragmentActivity.kt

View Slide

Fix: Use Let with Null Coalesce Operator
if (savedInstanceState == null) {
.commit()
}
savedInstanceState ?: let {
.commit()
}
SingleFragmentActivity.kt

View Slide

Smell: Init a Class and Conﬁgure lots of
Methods on it
ProgressDialog.kt (legacy)
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
val progressDialog = ProgressDialog(context)
progressDialog.setMessage(arguments.getString(ARG_MESSAGE))
progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER)
return progressDialog
}

View Slide

Fix: Use an Apply Block
ProgressDialog.kt (legacy)
val progressDialog = ProgressDialog(context)
progressDialog.setMessage(arguments.getString(ARG_MESSAGE))
progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER)
return progressDialog
}
return ProgressDialog(context).apply {
setMessage(arguments.getString(ARG_MESSAGE))
setProgressStyle(ProgressDialog.STYLE_SPINNER)
}
}

View Slide

Cleaning up: Drop Unneeded Object
object DialogUtils {
private const val TAG_DIALOG_PROGRESS = "dialog_progress"
internal fun showProgressDialog(fragmentManager: FragmentManager, message: String) {
if (fragmentManager.findFragmentByTag(DialogUtils.TAG_DIALOG_PROGRESS) != null) {
hideProgressDialog(fragmentManager)
}
val dialog = ProgressDialogFragment.newInstance(message)
dialog.isCancelable = false
dialog.show(fragmentManager, TAG_DIALOG_PROGRESS)
}
internal fun hideProgressDialog(fragmentManager: FragmentManager) {
val fragment = fragmentManager.findFragmentByTag(TAG_DIALOG_PROGRESS)
(fragment as? ProgressDialogFragment)?.dismissAllowingStateLoss()
}
}

View Slide

2. Refactor to Extensions

View Slide

Extensions: Quick Example
fun String.addEnthusiasm() = this + "!!!!"
fun main(args: Array) {
"Android Summit is Awesome".addEnthusiasm()
}

View Slide

More Involved Example: Building Lambda Elvis
val mightBeNull: String? = null
val definitelyNotNull: String = mightBeNull ?: "default"
“If the thing on the left is null, do the thing on the right”

View Slide

infix fun T?.orDefault(default: T?.(T?) -> T) =  
this ?: default()
“For all Types? Add a function called orDefault that accepts a lambda.
The lambda must return a non-nullable version of the type.
If the instance is null, call the lambda”

View Slide

val displayName = cachedDisplayName orDefault {
val formatted = formatName(user.first, user.last)
cache.displayName = formatted
formatted
}

View Slide

Question: Where Will An Extension Help?
}
}
override fun onSaveInstanceState(outState: Bundle) {
outState.putBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, requestInProgress)
}
RxFragment.kt

View Slide

Refactoring RxFragment with Extensions
private var Bundle.requestInProgress: Boolean
get() = getBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, false)
set(inProgress) = putBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, inProgress)

View Slide

Carrying the Refactor Forward: Let no longer
Needed
savedInstanceState?.let {
requestInProgress =
}
requestInProgress = savedInstanceState?.requestInProgress ?: false
onCreate:
RxFragment.kt

View Slide

Carrying the Refactor Forward
override fun onSaveInstanceState(outState: Bundle) {
outState.putBoolean(EXTRA_RX_REQUEST_IN_PROGRESS, requestInProgress)
outState.requestInProgress = requestInProgress
}
onSaveInstanceState:
RxFragment.kt

View Slide

private val TAG_DIALOG_PROGRESS = "dialog_progress"
fragmentManager.findFragmentByTag(TAG_DIALOG_PROGRESS)?.let {
}
ProgressDialogFragment.newInstance(message).apply {
isCancelable = true
show(fragmentManager, TAG_DIALOG_PROGRESS)
}
}
if (fragment is ProgressDialogFragment) {
fragment.dismissAllowingStateLoss()
}
}
}
DialogUtils.Kt
Another Candidate for Refactoring To
Extensions

View Slide

Another Candidate for Refactoring To
Extensions
private const val TAG_DIALOG_PROGRESS = “dialog_progress"
private val FragmentManager.progressDialog: ProgressDialogFragment?
get() = findFragmentByTag(TAG_DIALOG_PROGRESS) as? ProgressDialogFragment
}
}
}
DialogUtils.kt

View Slide

Refactoring to an Extension Property
fun showProgressDialog(fragmentManager: FragmentManager, message: String) {
}
fragmentManager.progressDialog?.hideProgressDialog(fragmentManager)
}
DialogUtils.kt

View Slide

}
fragmentManager.progressDialog?.hideProgressDialog(fragmentManager)
isCancelable = false
}
}
Refactoring to an Extension Property
DialogUtils.kt

View Slide

fun hideProgressDialog(fragmentManager: FragmentManager) {
fragmentManager.progressDialog?.dismissAllowingStateLoss()
}
DialogUtils.kt

View Slide

fun hideProgressDialog(fragmentManager: FragmentManager) =
DialogUtils.kt

View Slide

Pushing the Extension Even Further…
fragmentManager.progressDialog?.let {
}
}
}
DialogUtils.kt

View Slide

Pushing the Extension Further…
fun FragmentManager.hideProgressDialog() = progressDialog?.dismissAllowingStateLoss()
DialogUtils.kt

View Slide

fun FragmentManager.showProgressDialog(message: String) {
hideProgressDialog()
}.show(this, TAG_DIALOG_PROGRESS)
}
Pushing the Extension Further…
DialogUtils.kt

View Slide

Before and After
DialogUtils.kt
fun FragmentManager.showProgressDialog(message: String) {
hideProgressDialog()
}.show(this, TAG_DIALOG_PROGRESS)
}
fragmentManager.findFragmentByTag(TAG_DIALOG_PROGRESS)?.let {
}
isCancelable = true
}
}
if (fragment is ProgressDialogFragment) {
fragment.dismissAllowingStateLoss()
}
}
}

View Slide

Before and After: Call Site
RxUtils.kt
private fun Observable.showLoadingDialog(rxFragment: RxFragment): Observable =
doOnSubscribe { DialogUtils.showProgressDialog(rxFragment.fragmentManager, LOADING_MESSAGE) }
.doOnTerminate { DialogUtils.hideProgressDialog(rxFragment.fragmentManager) }
private fun Observable.showLoadingDialog(fragmentManager: FragmentManager): Observable =
doOnSubscribe { fragmentManager.showProgressDialog(LOADING_MESSAGE) }
.doOnTerminate { fragmentManager.hideProgressDialog() }

View Slide

1. Let with safe call operator (.?) is good for dropping a != null comparison
2. Let with null coalesce operator (?:) is good for dropping a == null comparison
3. Apply is good for conﬁguring objects with many methods to call
Takeaways

View Slide

1. Extensions give you “this” for free, allows you to drop an argument to a function
commonly
2. Let with null coalesce operator is good for dropping a == null comparison
3. Apply is good for conﬁguring objects with many methods to call
Takeaways

View Slide

Resources
•Kotlin track on Exercism: http://exercism.io/languages/kotlin/about
•Kotlin Language Design https://discuss.kotlinlang.org/c/language-design
•Kotlin koans: https://kotlinlang.org/docs/tutorials/koans.html
•Big Nerd Ranch Kotlin course coming november

View Slide

Thanks!

View Slide

Pragmatic Kotlin on Android

Pragmatic Kotlin on Android

josh skeen

More Decks by josh skeen

Other Decks in Programming

Featured

Transcript