如何将 flutter_boost 添加到已有的Android工程，此 demo 在 MacOS 下完成，如果使用 Windows， 请修改对应的路径为 Windows 的格式。

flutter 端

1. 新建 flutter module

   flutter create -t module flutter_module
   

2. 在 pubspec.yaml 中添加 flutter_boost 依赖

   dependencies:
     flutter_boost:
   

3. 运行 flutter build apk 在 flutter_boost 0.400版本会有错误抛出，找出其中关键信息如下：

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

   不难发现是因为没有 kotlin 依赖导致, 下面我们就来修复这个问题

4. 在项目根目录下执行，flutter make-host-app-editable 执行完成后，发现目录下面出现了 android 以及 ios 文件夹

5. 在 android/build.gralde 中添加 kotlin 依赖

    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"
   	}
   }
   

   再一次运行 flutter build apk 发现成功了

6. 把 flutter_boost/example/lib 下的文件复制到 lib 目录

这样 flutter 这一端的工作就准备完成了

Android 端

1. 使用Android Studio新建一个工程

   如果你有现成的项目，可以跳过这一步

2. 在 App module 中添加kotlin支持，并在 settings.gradle 中添加如下代码

   setBinding(new Binding([gradle: this]))
   evaluate(new File('../flutter_module/.android/include_flutter.groovy'))   //保证Android项目和flutter module在同一目录下
   

   运行一下 gralde sync，这时候你的工程里应该会出现三个新的项目 Flutter-flutter, flutter_boost 和 xservice_kit

   如果碰到一下错误，请把gradle的版本改为 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. 在 flutterservice 目录下的 build.gradle 文件中添加一下依赖

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

4. 从flutter_boost/example/android 中复制所有chu新建 MyApplication 类，代码如下：

   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()
   	}
   
   }
   

   完成后再manifest文件中指定使用此Application

5. 在 MainActivity 中添加弱引用来保存 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. 新建FlutterPageActivity, 记得添加到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. 在layout中给textview 添加id

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

8. MainActivity 中添加点击事件

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

9. 运行android工程，如果碰到错误请按照提示修改

10. 点击 Hello world,就会打开一个Flutter的页面了，到此已经完成了从Native页面打开flutter页面

11. 把MyApplication 中 startActivity 函数修改为下面代码：

 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
    }

点击flutter页面中的open native page，就会重新打开activity。

这样就完成了两端的相互调用，欢迎入坑 Flutter

新建 Plugin 工程

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

打开新创建的工程，可以看到一下代码：

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()
    }
  }
}

通过以上代码，可以清晰看出来，Flutter 通过提供 MethodChannel 来实现跨语言的调用。 Kotlin 的代码中，有个叫做 ScanPlugin 的类，这个类继承自 MethodCallHandler。它会先向 Flutter 注册一个叫做 scan 的 channel， 然后在 onMethodCall 判断当函数名为 getPlatformVersion 时，返回 android 系统的 OS 版本。

在 Dart 中，获取一个注册明为 scan 的 MethodChannel。然后通过 _channel.invokeMethod('getPlatformVersion'); 来获取对应的函数的结果。

通过以上分析，我看就可以看得出来，如果要添加一个叫做 codescan 的函数就可以了。

添加 codescan 函数

先执行以下命令

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

导入 Android Plugin 工程

1. 打开 Android Studio
2. 选择 Import project,然后选中 example/android/build.gradle 文件
3. 在 Gradle Sync 窗口中，选择 OK
4. Android Gradle Plugin Update 窗口中选择 Don’t remind me again for this project

这样你就可以运行 example 工程了

lib/scan.dart 中添加函数

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

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()
        }

    }
}

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 该工程，应该可以看到如下界面： 点击 Scan 按钮，就可以看到二维码扫描的界面了。

到这里你就可以实现 dart 来调用三方库来实现具体的功能了。

如何获取第三方库的返回值呢？MethodHandler提供了一个 result 类传递返回值，只需要在 success 函数中传递你需要的返回值就可以了。同时如果需要获取 onActivity 的返回值，可以通过 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 是从 React 得到启发，从而产生的一套现在流行的响应式框架。其主要思想就是所有的 UI 使用 widgets 来创建。所有的 widgets 会给出当前的配置和状态。当一个 widget 有变化时，系统会计算出来所有的这个 widget背后的渲染树从前一个状态到当前状态的最小变化，从而重新构建自己。所以在 Flutter 中所有的 UI 都是通过各种 widgets 的组合来实现的。查看所有的 widgets

来一个 Hello World

将如下代码 copy 到你新建项目中的 lib/main.dart，运行一下将会看到一下效果。(如果你还没有新建过项目，请按照这里的步骤新建一个项目)

import 'package:flutter/material.dart';

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

我们在 main 函数中，把一个 text 的 widget 传给了 runApp 这个函数，从而得到上面的效果。 如果我们需要 Hello, world! 居中显示怎么办，前面我讲了在 flutter 中我们需要各种 widgets 的组合。这里我们就需要一个叫做 Center 的widget 所以放在里面的组件，都会显示在这个组建的中间。我们改一下代码：

import 'package:flutter/material.dart';

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

效果如下： 细心的朋友，可能注意到了，本段中 Center 跟 Text 的 new 关键字不见了， 这里是因为 Dart 2 提供的语法糖，让我们省略关键字 new。

我们把 Text 放到了 Center widget 的 child 属性中，然后这个文字就可以居中了，不要太简单。到这我们就碰到了两种类型的 widgets，一个是用来展示内容的 Text，一个是用来布局的 Center。 在 Flutter 的开发中，我们会大量使用这种 widgets 的组合来实现我们需要的效果。接下来我们需要一个白色的背景以及蓝色的字体。更多布局类型的 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
        ),
      ),
    ),
  );
}

为了实现白色背景，我们添加了一个 Container widget，然后颜色设置为 白色。我们看到 Text 没有 color 的属性，但是有个 style，所以我们通过构建一个白色的 TextStyle 来实现字体变成红色。TextStyle 中还可以改变字体的其他属性，自己可以在研究一下。

如何在文字下面添加一个按钮呢？

import 'package:flutter/material.dart';

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

从代码中我们可以看到我们增加了一个 Column 来实现一个多个 widgets 的竖状排列，所以它的子控件 属性变成了需要一个 List 的 children。我们再来看 Button，这里我们要给 button 添加一个说明，同样通过添加一个 Text widget 来实现。如果你耐心看到这里，你基本上已经入门了 Flutter 开发。再复杂的页面也是类似于这样组合 widget 的方式来进行开发，可能使用到更复杂的 widget 罢了。

你有没有发现，我们没有用 xml 或者 xib 文件，轻轻松松就实现了这样一个界面。 如果我们同样使用 Java 或者 Swift 来实现同样的界面，需要多少代码呢？

主要目录以及文件

1. android Android 平台相关代码
2. ios iOS 平台相关代码
3. build 项目编译产生的目录，不需要关心
4. lib 跨平台代码，也是 Flutter 项目主要关心的目录
5. test 测试相关代码
6. pubspec.yaml 项目描述文件，相当于 NodeJs 项目的 package.json，里面包含了项目的描述信息以及所需要的依赖的库

主要文件说明

pubspec.yaml

main.dart

Flutter 使用 dart 语言（以后的章节中会逐步增加一些介绍 dart 的内容）来进行开发，下图是将代码简化之后的效果。只需要3个类就可以实现一个 app 页面，并且可以同时运行在 iOS 和 Android 两个平台，非常简单。而且 main.dart 是所有 Flutter 项目的入口文件，不能被删除或者改名。

操作系统：macOS (64-bit) 本文以 macOS 系统为例介绍安装过程
工具： bash,git,curl,unzip

获取 Flutter SDK

1. 从Flutter SDK Archive页面下载最新版本的 SDK。 点击flutter_macos_v0.4.4-beta.zip下载或者

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. 如果上面链接有问题,请使用中国专用链接**
    
    ```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. 解压文件到你想要的路径

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

3. 添加`flutter`到PATH

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

4. 运行 flutter doctor

flutter doctor

***如果按照上面的步骤，没有成功安装。请采用下面命令安装：***

```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

####备用的镜像网站####
# export FLUTTER_STORAGE_BASE_URL=https://mirrors.sjtug.sjtu.edu.cn/
# export PUB_HOSTED_URL=https://dart-pub.mirrors.sjtug.sjtu.edu.cn/

配置开发平台

iOS开发

安装 Xcode

1. 从 App Store 安装 xcode.

2. 配置命令行使用最新的 xcode

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

3. 确保您已经接受 xcode 许可协议

   sudo xcodebuild -license
   

配置模拟器

1. 通过LaunchPad 或者下面的命令来启动模拟器

open -a Simulator

2. `flutter run` 来运行你的程序


### Android 开发
#### 安装 Android Studio
下载安装 [Android Studio](https://developer.android.com/studio/index.html)
#### Android 设备（Android Version >= 4.1）
1. 参照[此链接](https://developer.android.com/studio/debug/dev-options.html)开启开发者模式并打开 debug
2. 链接你的手机到电脑
3. `flutter run` 运行你的程序

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.

Kotlin’s type system is aimed to eliminate NullPointerException’s from our code. The only possible causes of NPE’s may be

1. An explicit call to throw NullPointerException()
2. Usage of the !! operator that is described below
3. External Java code has caused it
4. There’s some data inconsistency with regard to initialization (an uninitialized this available in a constructor is used somewhere)

Variables

As mentioned above, there’re the only 4 ways to cause a NPE. And there’re nullable and non-nullable types in Kotlin’s System. So when you define a variable, you must tell Kotlin whether the variable is nullable or not.

1. Non-nullable variable You can define non-nullable variables as following:

       var b:String = "abc"
       var a:Int = 10
   

   Once you want to assign a null to a non-nullable variable,

       b = null
       a = null
   

   the compiler will throw you an error. The Kotlin system prevent nullable value in the compile stage.

2. Nullable variable If you want to define a variable which can be set as null, please code as following.

       var b:String? = "abc"
       var a:Int? = 10
   

   Now both of them can be set as null

       b = null    // ok
       a = null    // ok
   

Nullable check

The Kotlin system will tell you an error if you want to call a method from a nullable variable.

    b.length.  // compile error

You must check b whether it is null or not.

    if (b != null) {
        b.length
    }

It’s a Java style way, is there a new method to handle this in Kotlin. Absolutely, yes. There’s a new and safe operator, ?., to be used in this state.

    val a = b?.length

It’s safe and never throws the NullPointerException. It will return a null for this invocation and never really call the length method. Isn’t a easy way to handle nullable variable?

If you want the Java’s style to handle exception, just use !!.

  val a = b!!.length

The above code may throws a NullPointerException during the runtime.

There’s also another example from kotlin’s official site:

Safe calls are useful in chains. For example, if Bob, an Employee, may be assigned to a Department (or not), that in turn may have another Employee as a department head, then to obtain the name of Bob’s department head (if any), we write the following:

bob?.department?.head?.name

Such a chain returns a null if any of the properties in it is null.

To perform a certain operation only for non-null values, you can use the safe call operator together with let:

val listWithNulls: List<String?> = listOf("A", null)
for (item in listWithNulls) {
     item?.let { println(it) } // prints A and ignores null
}

Elvis Operator (?:)

You definitely meet the following issue: return the string’s length if non-null and just return -1 when it’s null

    val l: Int = if (b != null) b.length else -1

Now there’s new operator.

    val l = b?.length ?: -1

or

    bob?.department?.head?.name ?: "No Name"

If the expression to the left of ?: is not null, the elvis operator returns it, otherwise it returns the expression to the right. Note that the right-hand side expression is evaluated only if the left-hand side is null.

Note that, since throw and return are expressions in Kotlin, they can also be used on the right hand side of the elvis operator. This can be very handy, for example, for checking function arguments:

fun foo(node: Node): String? {
    val parent = node.getParent() ?: return null
    val name = node.getName() ?: throw IllegalArgumentException("name expected")
    // ...
}

safe cast

Regular casts may result into a ClassCastException if the object is not of the target type. Another option is to use safe casts that return null if the attempt was not successful:

val a = Animal()
val dog: Dog? = a as? Dog

Collections of Nullable Type

If you have a collection of elements of a nullable type and want to filter non-null elements, you can do so by using filterNotNull.

val nullableList: List<Int?> = listOf(1, 2, null, 4)
val intList: List<Int> = nullableList.filterNotNull()

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