How to add flutter_boost to an existing Android project. This demo was done on macOS. On Windows, change the paths to Windows format.

The Flutter side

1. Create a new flutter module

   flutter create -t module flutter_module
   

2. Add the flutter_boost dependency in pubspec.yaml

   dependencies:
     flutter_boost:
   

3. Run flutter build apk With flutter_boost 0.400 this throws an error. The key part is:

   * What went wrong:
   A problem occurred evaluating project ':flutter_boost'.
   > Plugin with id 'kotlin-android-extensions' not found.
   

   It’s not hard to see it’s a missing kotlin dependency. Let’s fix that.

4. From the project root run flutter make-host-app-editable When it finishes you’ll see android and ios folders appear.

5. Add the kotlin dependency in android/build.gralde

    buildscript {
   +    ext.kotlin_version = '1.3.21'
   	repositories {
   		google()
   		jcenter()
   @@ -8,6 +9,7 @@ buildscript {
   
   	dependencies {
   		classpath 'com.android.tools.build:gradle:3.2.1'
   +        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   	}
   }
   

   Run flutter build apk again and it succeeds.

6. Copy the files under flutter_boost/example/lib into the lib directory

That’s the Flutter side prepared.

The Android side

1. Create a project with Android Studio

   If you already have a project you can skip this step

2. Add kotlin support to the App module, and add the following to settings.gradle

   setBinding(new Binding([gradle: this]))
   evaluate(new File('../flutter_module/.android/include_flutter.groovy'))   // keep the Android project and the flutter module in the same directory
   

   Run gralde sync. You should now see three new projects in your build: Flutter-flutter, flutter_boost and xservice_kit

   If you hit the error below, change the gradle version to 4.10.2

   ERROR: Unable to resolve dependency for ':flutter@dynamicProfile/compileClasspath': Could not resolve project :xservice_kit.
    Show Details
    Affected Modules: flutter
   
    ERROR: Unable to resolve dependency for ':flutter@dynamicProfile/compileClasspath': Could not resolve project :flutter_boost.
    Show Details
    Affected Modules: flutter
   

3. Add the dependencies below to the build.gradle file in the flutterservice directory

   implementation project(path: ':flutter')
   implementation project(":flutter_boost")
   

4. Copy everything from flutter_boost/example/android and create a new MyApplication class:

   class MyApplication : FlutterApplication(), IPlatform {
   	override fun onCreate() {
   		super.onCreate()
   		FlutterBoostPlugin.init(this)
   	}
   	override fun getApplication(): Application {
   		return this
   	}
   
   	override fun getMainActivity(): Activity? {
   		return MainActivity.sRef.get()
   	}
   
   	override fun isDebug(): Boolean {
   		return true
   	}
   
   	override fun startActivity(context: Context?, url: String?, requestCode: Int): Boolean {
   		return false
   	}
   
   	override fun getSettings(): MutableMap<Any?, Any?> {
   		return HashMap()
   	}
   
   }
   

   Then point the manifest at this Application

5. Add a weak reference in MainActivity to hold MainActivity

   class MainActivity : AppCompatActivity() {
   	override fun onCreate(savedInstanceState: Bundle?) {
   		super.onCreate(savedInstanceState)
   		setContentView(R.layout.activity_main)
   		sRef = WeakReference(this)
   	}
   
   	companion object {
   
   		var sRef: WeakReference<Activity?> = WeakReference(null)
   	}
   }
   

6. Create FlutterPageActivity, and remember to add it to the manifest

   class FlutterPageActivity:BoostFlutterActivity() {
   	override fun getContainerParams(): MutableMap<Any?, Any?> {
   		return HashMap()
   	}
   
   	override fun onRegisterPlugins(registry: PluginRegistry?) {
   		GeneratedPluginRegistrant.registerWith(registry)
   	}
   
   	override fun getContainerName(): String {
   		return "flutterPage"
   	}
   }
   

7. Give the textview an id in the layout

           android:text="Hello World!"
           android:id="@+id/tvHello"
           app:layout_constraintBottom_toBottomOf="parent"
   

8. Add a click listener in MainActivity

   tvHello.setOnClickListener {
   	startActivity(Intent(applicationContext, FlutterPageActivity::class.java))
   }
   

9. Run the Android project. If you hit errors, fix them following the prompts.

10. Click Hello world and a Flutter page opens. At this point you’ve gone from a native page to a Flutter page.

11. Change the startActivity function in MyApplication to the code below:

 override fun startActivity(context: Context?, url: String?, requestCode: Int): Boolean {
        if (url?.contains("sample://nativePage") == true) {
            context?.startActivity(Intent(context, MainActivity::class.java))
            return true
        }
        return false
    }

Click open native page in the Flutter page and the activity reopens.

That’s the round trip between both sides done. Welcome to the Flutter pit.

Creating a Plugin project

flutter create --org mingsin.scan --template=plugin  -i swift -a kotlin scan

Open the newly created project and you will see this code:

lib/scan.dart

import 'dart:async';

import 'package:flutter/services.dart';

class Scan {
  static const MethodChannel _channel =
      const MethodChannel('scan');

  static Future<String> get platformVersion async {
    final String version = await _channel.invokeMethod('getPlatformVersion');
    return version;
  }
}

android/src/..../ScanPlugin.kt

class ScanPlugin(): MethodCallHandler {
  companion object {
    @JvmStatic
    fun registerWith(registrar: Registrar): Unit {
      val channel = MethodChannel(registrar.messenger(), "scan")
      channel.setMethodCallHandler(ScanPlugin())
    }
  }

  override fun onMethodCall(call: MethodCall, result: Result): Unit {
    if (call.method.equals("getPlatformVersion")) {
      result.success("Android ${android.os.Build.VERSION.RELEASE}")
    } else {
      result.notImplemented()
    }
  }
}

From that code you can see clearly that Flutter does cross-language calls by providing a MethodChannel. In the Kotlin code there is a class called ScanPlugin that inherits from MethodCallHandler. It first registers a channel called scan with Flutter, then in onMethodCall checks whether the method name is getPlatformVersion and returns the Android OS version if so.

In Dart, get a MethodChannel registered under the name scan. Then use _channel.invokeMethod('getPlatformVersion'); to get the result of the corresponding function.

From that analysis you can already see that adding a function called codescan is all it takes.

Adding the codescan function

Run this command first

```shell
cd example; 
flutter build apk
```

Import the Android Plugin project

1. Open Android Studio
2. Choose Import project, then select the example/android/build.gradle file
3. In the Gradle Sync window, choose OK
4. In the Android Gradle Plugin Update window, choose Don’t remind me again for this project

Now you can run the example project.

Add the function in lib/scan.dart

  static Future codeScan() async {
    await _channel.invokeMethod('codeScan');
  }

Implement it in ScanPlugin.kt

class ScanPlugin(private val registrar: Registrar) : MethodCallHandler {
    companion object {
        @JvmStatic
        fun registerWith(registrar: Registrar) {
            val channel = MethodChannel(registrar.messenger(), "scan")
            channel.setMethodCallHandler(ScanPlugin(registrar))
        }
    }

    override fun onMethodCall(call: MethodCall, result: Result) {
        when (call.method) {
            "getPlatformVersion" -> {
                result.success("Android ${android.os.Build.VERSION.RELEASE}")
            }
            "codeScan" -> {
                IntentIntegrator(registrar.activity())
                        .setDesiredBarcodeFormats(IntentIntegrator.ONE_D_CODE_TYPES)
                        .initiateScan()
            }
            else ->
                result.notImplemented()
        }

    }
}

Call it from example/lib/main.dart

         body: new Center(
-          child: new Text('Running on: $_platformVersion\n'),
+          child: RaisedButton(
+            onPressed: () async {
+              await Scan.codeScan();
+            },
+            child: Text("Scan"),
+          ),
         ),
       ),

Reload the project and you should see this screen: Tap the Scan button and the QR code scanning screen appears.

At this point you can call a third-party library from Dart to do real work.

How do you get a return value back from the third-party library? MethodHandler provides a result class to pass values back, and you only need to pass what you need in the success function. If you also need the return value from onActivity, you can do it with PluginRegistry.ActivityResultListener.

    override fun onMethodCall(call: MethodCall, result: Result) {
        when (call.method) {
            "getPlatformVersion" -> {
                result.success("Android ${android.os.Build.VERSION.RELEASE}")
            }
            "codeScan" -> {
                if (listener.result == null) {
                    registrar.addActivityResultListener(listener)
                }
                listener.result = result
                IntentIntegrator(registrar.activity())
                        .setDesiredBarcodeFormats(IntentIntegrator.ONE_D_CODE_TYPES)
                        .initiateScan()
            }
            else ->
                result.notImplemented()
        }

    }

    private val listener = object : PluginRegistry.ActivityResultListener {
        var result: Result? = null
        override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?): Boolean {
            val intentResult = IntentIntegrator.parseActivityResult(requestCode, intent)
            result?.success(intentResult.contents)
            return true
        }

    }

Flutter widgets were inspired by React, and turned into the reactive framework everyone uses today. The core idea is that all UI is created with widgets. Every widget provides its current configuration and state. When a widget changes, the system computes the smallest change in the render tree behind that widget from the previous state to the current one, and rebuilds accordingly. So in Flutter, all UI is built by composing widgets. See all the widgets

A Hello World

Copy the code below into lib/main.dart in a new project and run it to see the result. (If you have not created a project yet, follow the steps here to create one)

import 'package:flutter/material.dart';

void main() {
  runApp(
    new Text(
      'Hello, world!',
      textDirection: TextDirection.ltr,
    ),
  );
}

In the main function we pass a text widget to runApp and get the result above. What if we want Hello, world! centered? As I said earlier, in Flutter we compose widgets. Here we need a widget called Center, and whatever component sits inside it shows up in the middle of that component. Let’s change the code:

import 'package:flutter/material.dart';

void main() {
  runApp(
   Center(
      child: Text(
        'Hello, world!',
        textDirection: TextDirection.ltr,
      ),
    ),
  );
}

The result: Sharp-eyed readers may have noticed that the new keyword on Center and Text disappeared in this snippet. That is Dart 2 syntactic sugar letting us drop new.

We put Text in the child property of the Center widget, and now the text is centered. Could not be simpler. At this point we have touched two kinds of widgets: Text, which displays content, and Center, which handles layout. In Flutter development we use this kind of composition heavily to get the effect we want. Next we want a white background and blue text. More layout widgets

import 'package:flutter/material.dart';

void main() {
  runApp(
    Container(
      color: Colors.white, // background color
      child: Center(
        child: Text(
          'Hello, world!',
          textDirection: TextDirection.ltr,
          style: TextStyle(color: Colors.red),  // text color
        ),
      ),
    ),
  );
}

To get a white background we add a Container widget and set its color to white. As you can see, Text has no color property but it does have style, so we build a TextStyle to turn the text red. TextStyle can change other font properties too — dig into it yourself.

How do we put a button under the text?

import 'package:flutter/material.dart';

void main() {
  runApp(
    Container(
      color: Colors.white,
      child: Center(
          child: Column( // vertical layout
        mainAxisAlignment: MainAxisAlignment.center,
        mainAxisSize: MainAxisSize.min,
        children: <Widget>[
          Text(
            'Hello, world!',
            textDirection: TextDirection.ltr,
            style: TextStyle(color: Colors.red),
          ),
          RaisedButton( // button
            child: Text(
              'Say Hello',
              textDirection: TextDirection.ltr,
            ),
            onPressed: null,
          )
        ],
      )),
    ),
  );
}

From the code you can see we added a Column to stack multiple widgets vertically, which is why its child property becomes a List called children. Then the button: we want a label on it, so we add a Text widget for that too. If you have read this far patiently, you basically have a foothold in Flutter development. Even more complex pages are built the same way, by composing widgets — maybe with more complicated widgets.

Notice anything? We did not use an xml or xib file, and we got this interface built with no effort. If we built the same screen in Java or Swift, how much code would that take?

Main directories and files

1. android Android platform code
2. ios iOS platform code
3. build produced by the build, ignore it
4. lib cross-platform code, the directory you actually care about in a Flutter project
5. test test code
6. pubspec.yaml the project manifest, equivalent to package.json in a Node.js project. It holds the project description and the libraries it depends on

The main files

pubspec.yaml

main.dart

Flutter is written in dart (later chapters will add more on dart). The image below shows the code after simplification. Three classes are enough for one app screen, and it runs on both iOS and Android at the same time. That simple. And main.dart is the entry file for every Flutter project: it cannot be deleted or renamed.

OS: macOS (64-bit). This walkthrough uses macOS as the example.
Tools: bash,git,curl,unzip

Get the Flutter SDK

1. Download the latest SDK from the Flutter SDK Archive page. Click flutter_macos_v0.4.4-beta.zip to download, or

curl -o ~/Downloads/flutter_macos_v0.4.4-beta.zip https://storage.googleapis.com/flutter_infra/releases/beta/macos/flutter_macos_v0.4.4-beta.zip

    
    **P.S. If the links above give you trouble, use the China mirror.**
    
    ```shell 
curl -o ~/Downloads/flutter_macos_v0.4.4-beta.zip  https://storage.flutter-io.cn/flutter_infra/releases/beta/macos/flutter_macos_v0.4.4-beta.zip

2. Unzip into whatever path you want

cd ~/development unzip ~/Downloads/flutter_macos_v0.4.4-beta.zip

3. Add `flutter` to PATH

    ```shell
export PATH=`pwd`/flutter/bin:$PATH

4. Run flutter doctor

flutter doctor

***If the steps above did not get you a working install, use these commands instead:***

```shell
export PUB_HOSTED_URL=https://pub.flutter-io.cn
export FLUTTER_STORAGE_BASE_URL=https://storage.flutter-io.cn
git clone -b dev https://github.com/flutter/flutter.git
export PATH="$PWD/flutter/bin:$PATH"
cd ./flutter
flutter doctor

####alternate mirror sites####
# export FLUTTER_STORAGE_BASE_URL=https://mirrors.sjtug.sjtu.edu.cn/
# export PUB_HOSTED_URL=https://dart-pub.mirrors.sjtug.sjtu.edu.cn/

Set up a development platform

iOS

Install Xcode

1. Install Xcode from the App Store.

2. Point the command line at the latest Xcode

   sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer
   

3. Make sure you have accepted the Xcode license agreement

   sudo xcodebuild -license
   

Set up the simulator

1. Launch the simulator from Launchpad, or with the command below

open -a Simulator

2. `flutter run` to run your app


### Android
#### Install Android Studio
Download and install [Android Studio](https://developer.android.com/studio/index.html)
#### Android device (Android 4.1 or newer)
1. Follow [this link](https://developer.android.com/studio/debug/dev-options.html) to enable developer mode and turn debugging on
2. Plug your phone into the computer
3. `flutter run` to run your app

Run the following command to install gitlab on your machine.

sudo docker run -d --hostname 10.211.55.5 \
-p 80:80 -p 443:443 -p 22:22 \
--restart always gitlab/gitlab-ce

Please follow official installation docs to install docker if it’s not been installed. Do NOT forget change 10.211.55.5 and /srv/gitlab/ to your own.(I have a virtual machine with that ip.) If your docker is behind a proxy, please see the search results from Google.

After several mins, access http://10.211.55.5 (the host you set above), you will the following picture.

Set your admin password, and login again.

Create new project hello-world as the following:

Once you create the project, follow the instruction to upload demo code to the repo. When you finish you will see a similar picture.

Click the Set up CI button, add the following code and commit.

test:
  script:
  - echo 'hello world'

A pending icon will appear on the result page.

Click the icon, you will see a stuk tag on your commit. That means you have to add gitlab-runner to this project.

Setup Gitlab Runner

1. Open CI/CD Pipeline tab in project settings

2. Install setup runner on your local machine

   brew install gitlab-ci-multi-runner
   

3. Register your local machine as a runner to the gitlab

   

4. Runner list

   

5. Go back to the Pipelines of your project and click the retry button

   

6. You runner has been set up successfully when you see the picture

7. Change the .gitlab-ci.yml to the following:

   test:
     script:
     - ./gradlew aR
     artifacts:
       paths:
       - app/build/outputs/apk/app-release*.apk
   

8. Now you will get the release apk file from the download button.

The project is based on the code complete in last article. You can download from here

Add Dependencies to your build.gradle

 kapt 'com.google.dagger:dagger-compiler:2.9'
 compile 'com.google.dagger:dagger:2.9'

Create your application instead of default

class App : Application() {
    override fun onCreate() {
    }
}

Update your manifest file to enable your App

Add the following to your application tag

     <application
+        android:name=".App"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"

Create Application module

Create a AppModule.kt file and add the following code

@Module
class AppModule(val app: App) {

    @Provides
    @Singleton
    fun app(): App {
        return app
    }

    @Provides
    @Singleton
    fun context(): Context {
        return app
    }

    @Provides
    @Singleton
    fun connectivity(): ConnectivityManager {
        val service = app.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        return service
    }
}

Create component

@Singleton
@Component(
        modules = arrayOf(AppModule::class)
)
interface AppComponent {
    fun inject(app: App)
}

Update your code in App.kt to enable the injection

  lateinit var component: AppComponent
    lateinit @Inject var cm: ConnectivityManager
    override fun onCreate() {
        super.onCreate()
        component = DaggerAppComponent.builder().appModule(AppModule(this)).build()
        component.inject(this)
        Logger.d("connectivity manager : ${cm}")
    }

Now you can run your code in IDE, you will see the following in your console. You have completed your first injection for Application.

02-17 10:03:20.492 10572-10572/? D/PRETTYLOGGER: ╔════════════════════════════════════════════════════════════════════════════════════════
02-17 10:03:20.493 10572-10572/? D/PRETTYLOGGER: ║ Thread: main
02-17 10:03:20.493 10572-10572/? D/PRETTYLOGGER: ╟────────────────────────────────────────────────────────────────────────────────────────
02-17 10:03:20.493 10572-10572/? D/PRETTYLOGGER: ║ BootstrapApplication.onCreate  (BootstrapApplication.java:370)
02-17 10:03:20.493 10572-10572/? D/PRETTYLOGGER: ║    App.onCreate  (App.kt:21)
02-17 10:03:20.493 10572-10572/? D/PRETTYLOGGER: ╟────────────────────────────────────────────────────────────────────────────────────────
02-17 10:03:20.493 10572-10572/? D/PRETTYLOGGER: ║ connectivity manager : android.net.ConnectivityManager@39309b5
02-17 10:03:20.494 10572-10572/? D/PRETTYLOGGER: ╚════════════════════════════════════════════════════════════════════════════════════════

Follow above guide to create ActivityModule and ActivityComponent

@Module
class ActivityModule(val activity: DaggerActivity) {

    @Provides
    fun activity(): DaggerActivity {
        return activity
    }

    @Provides
    fun progressDialog(): ProgressDialog {
        val progress = ProgressDialog(activity)
        progress.setMessage(activity.getString(R.string.loading))
        return progress
    }
}

@ForActivity
@Component(
        modules = arrayOf(ActivityModule::class),
        dependencies = arrayOf(AppComponent::class)
)
interface ActivityComponent {
    fun inject(activity: MainActivity)
}

You definately find there’s a @ForActivity above the ActivityComponent. Dagger need you to set a scope to define the lifecycle for any component. Activity cannot be the singleton. So we define a scrope annotation called ‘ForActivity’.

@Qualifier
@Retention(value = AnnotationRetention.RUNTIME)
@Scope
annotation class ForActivity

Use activity component in your code

Create a base class called DaggerActivity

abstract class DaggerActivity : AppCompatActivity() {
    var component: ActivityComponent? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val app = application as App
        component = DaggerActivityComponent.builder()
                .activityModule(ActivityModule(this))
                .appComponent(app.component)
                .build()
        onInject()
    }

    abstract fun onInject()

    override fun onDestroy() {
        component = null
        super.onDestroy()
    }
}

Update your MainActivity to extends DaggerActivity

class MainActivity : DaggerActivity() {
    @Inject lateinit var apiService: ApiService
    @Inject lateinit var cm: ConnectivityManager
    @Inject lateinit var progressDialog: ProgressDialog

    private val subscriptions = CompositeSubscription()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val binding = DataBindingUtil.setContentView<ActivityMainBinding>(this, R.layout.activity_main)
        binding.greating = "Hello Kotlin Data Binding!!!"

        val toolbar = findViewById(R.id.toolbar) as Toolbar
        setSupportActionBar(toolbar)

        Logger.d(cm)
    }

    override fun onInject() {
        component?.inject(this) // must call this
    }


    override fun onResume() {
        super.onResume()
        progressDialog.show()
    }

    override fun onStart() {
        super.onStart()
        subscriptions.add(apiService.ip().subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe({
                    ip ->
                    Logger.d("get result $ip")
                    progressDialog.hide()
                }) { error ->
                    Logger.e(error, "Aha.. got error message")
                    progressDialog.hide()
                })
    }

    override fun onStop() {
        super.onStop()
        subscriptions.clear()
    }

}

Run code from you IDE, you will see the fowlloing error

Error:mingsin.androidkotlinexample.data.ApiService cannot be provided without an @Provides-annotated method.
Error:mingsin.androidkotlinexample.data.ApiService cannot be provided without an @Provides- or @Produces-annotated method.
Error:android.net.ConnectivityManager cannot be provided without an @Inject constructor or from an @Provides- or @Produces-annotated method.

Because ConnectivityManager and ApiService are provided in you app component, So we must tell the dagger that we provide the two instance. Update your AppComponent code as following:

@Singleton
@Component(
        modules = arrayOf(AppModule::class)
)
interface AppComponent {
    fun inject(app: App)

    fun connectivity(): ConnectivityManager
    fun api(): ApiService
}

Now you have complete a project integrated with dagger2. You can chekcout the whole project from here

References

1. Dagger2
2. Dagger 2 Dependency Injection for Android Developers
3. Dependency Injection with Dagger 2

Add the following code into the dependencies block in your build.gradle

compile 'io.reactivex:rxkotlin:0.60.0'
compile 'io.reactivex:rxandroid:1.2.1'
compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
compile 'com.squareup.retrofit2:converter-gson:2.1.0'
compile 'com.orhanobut:logger:1.15'

Add internet permission for you application

Open you AndroidManifest.xml file and add the following line above your applicaiton tag.

 <uses-permission android:name="android.permission.INTERNET" />

Create the service interface

interface ApiService {
    @GET("/ip")
    fun ip(): Observable<Ip>
}

Create model

data class Ip(val origin: String)

Create Retrofit client

class RestClient {
    val BASE_URL = "http://httpbin.org"

    fun createApi(): ApiService {
        val retrofit = Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .build()
        return retrofit.create(ApiService::class.java)
    }
}

Integrate code into your activity

Init ApiService in your class

	 class MainActivity : AppCompatActivity() {
	+    lateinit var apiService: ApiService
	+
	+    private val subscriptions = CompositeSubscription()
	 
	     override fun onCreate(savedInstanceState: Bundle?) {
	         super.onCreate(savedInstanceState)
	@@ -27,25 +32,21 @@ class MainActivity : AppCompatActivity() {
	             Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
	                     .setAction("Action", null).show()
	         }
	+        apiService = RestClient().createApi()
	     } 

Update the code in your onStart and onStop method.

    override fun onStart() {
        super.onStart()
        subscriptions.add(apiService.ip().subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe {
                    Logger.d(it)
                })
    }

    override fun onStop() {
        super.onStop()
        subscriptions.clear()
    }

Run you application you will see the message on console

02-16 15:03:32.529 15858-15858/mingsin.androidkotlinexample D/PRETTYLOGGER: ╔════════════════════════════════════════════════════════════════════════════════════════
02-16 15:03:32.530 15858-15858/mingsin.androidkotlinexample D/PRETTYLOGGER: ║ Thread: main
02-16 15:03:32.530 15858-15858/mingsin.androidkotlinexample D/PRETTYLOGGER: ╟────────────────────────────────────────────────────────────────────────────────────────
02-16 15:03:32.530 15858-15858/mingsin.androidkotlinexample D/PRETTYLOGGER: ║ MainActivity$onStart$1.call  (MainActivity.kt:15)
02-16 15:03:32.530 15858-15858/mingsin.androidkotlinexample D/PRETTYLOGGER: ║    MainActivity$onStart$1.call  (MainActivity.kt:44)
02-16 15:03:32.530 15858-15858/mingsin.androidkotlinexample D/PRETTYLOGGER: ╟────────────────────────────────────────────────────────────────────────────────────────
02-16 15:03:32.530 15858-15858/mingsin.androidkotlinexample D/PRETTYLOGGER: ║ Ip(origin=20x.xx.xx.xx, 20x.xx.xx.xx)
02-16 15:03:32.530 15858-15858/mingsin.androidkotlinexample D/PRETTYLOGGER: ╚════════════════════════════════════════════════════════════════════════════════════════
02-16 15:03:33.025 15858-15858/mingsin.androidkotlinexample D/KeyEvent: obtain, mHwFlags=0

You can find the full version code from here

Create Android Kotlin Project

Please following[Dancing with kotlin] to create a new project. Or clone the project [https://github.com/trevorwang/android-kotlin-example], checkout kotlin-init

Update build.gradle

 buildscript {
	 ext.kotlin_version = '1.0.6'
+    ext.gradle_version = '2.2.3'
	 repositories {
		 jcenter()
	 }
	 dependencies {
- 	   classpath 'com.android.tools.build:gradle:2.2.3'
+ 	   classpath "com.android.tools.build:gradle:$gradle_version"
		 classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

update app/build.gradle to enable data binding

     sourceSets {
         main.java.srcDirs += 'src/main/kotlin'
     }
+
+    dataBinding {
+        enabled = true
+    }
+}
+kapt {
+    generateStubs = true
 }
 
  dependencies {
@@ -32,6 +39,7 @@ dependencies {
     compile 'com.android.support:design:25.1.1'
     testCompile 'junit:junit:4.12'
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    kapt "com.android.databinding:compiler:$gradle_version"
 }

update MainActivity.kt

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val binding = DataBindingUtil.setContentView<ActivityMainBinding>(this, R.layout.activity_main)
        binding.greeting = "Hello Kotlin Data Binding!!!"
    }
}

update activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<layout>

    <data>

        <variable
            name="greeting"
            type="String" />
    </data>

    <android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:fitsSystemWindows="true"
        tools:context="mingsin.androidkotlinexample.MainActivity">

        <android.support.design.widget.AppBarLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:theme="@style/AppTheme.AppBarOverlay">

            <android.support.v7.widget.Toolbar
                android:id="@+id/toolbar"
                android:layout_width="match_parent"
                android:layout_height="?attr/actionBarSize"
                android:background="?attr/colorPrimary"
                app:popupTheme="@style/AppTheme.PopupOverlay" />

        </android.support.design.widget.AppBarLayout>

        <RelativeLayout
            android:id="@+id/content_main"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:paddingBottom="@dimen/activity_vertical_margin"
            android:paddingLeft="@dimen/activity_horizontal_margin"
            android:paddingRight="@dimen/activity_horizontal_margin"
            android:paddingTop="@dimen/activity_vertical_margin"
            app:layout_behavior="@string/appbar_scrolling_view_behavior"
            tools:context="mingsin.androidkotlinexample.MainActivity"
            tools:showIn="@layout/activity_main">

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@{greeting}" />
        </RelativeLayout>


        <android.support.design.widget.FloatingActionButton
            android:id="@+id/fab"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="bottom|end"
            android:layout_margin="@dimen/fab_margin"
            app:srcCompat="@android:drawable/ic_dialog_email" />

    </android.support.design.widget.CoordinatorLayout>
</layout>

You can checkout whole source code from here

References

Issue with databinding using Kotlin for Android

Statically typed programming language for the JVM, Android and the browser. 100% interoperable with Java™

Why Kotlin?

• Concise
  Drastically reduce the amount of boilerplate code you need to write.
• Safe
  Avoid entire classes of errors such as null pointer exceptions.
• Versatile
  Build server-side applications, Android apps or frontend code running in the browser.
• Interoperable
  Leverage existing frameworks and libraries of the JVM with 100% Java Interoperability.
• Tooling
  Command Line Compiler or First Class IDE Support. Freedom to choose.

How to?

Install kotlin plugin

First, if using Android Studio, you’ll need to install the Kotlin plugin. Go to File | Settings | Plugins | Install JetBrains plugin… and then search for and install Kotlin. You’ll need to restart the IDE after this completes.

Creating a project

Just create an Android project from the IDE.

Converting Java code to Kotlin

• Setup kotlin runtime, select “Confure Kotlin in Project”
  
• Select All modules
  
• Convert Java file to Kotlin file
  
• The final code will be as following:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val toolbar = findViewById(R.id.toolbar) as Toolbar
        setSupportActionBar(toolbar)

        val fab = findViewById(R.id.fab) as FloatingActionButton
        fab.setOnClickListener { view ->
            Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                    .setAction("Action", null).show()
        }
    }

    override fun onCreateOptionsMenu(menu: Menu): Boolean {
        // Inflate the menu; this adds items to the action bar if it is present.
        menuInflater.inflate(R.menu.menu_main, menu)
        return true
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        val id = item.itemId


        if (id == R.id.action_settings) {
            return true
        }

        return super.onOptionsItemSelected(item)
    }
}

You can run the application with kotlin now

All the code you can find trevorwang/android-kotlin-example