jacoco는 UnitTest 및 Coverage 레포트를 만들어주는 플러그인(plug-in)입니다.

build.gradle에 다음과 같이 작성하면 gradle 옵션에서 jacoco 레포트 생성을 선택할 수 있습니다.

build.gradle (Module)

excludes는 레포트에서 제외할 파일이나 디렉토리, 패키지입니다. Kotlin이나 Java의 환경에 따라 classDirectories의 디렉토리 위치는 변경될 수 있습니다.

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'jacoco'

jacoco {
    toolVersion = '0.8.4'
}

tasks.withType(Test) {
    jacoco.includeNoLocationClasses = true
}

task jacocoTestReport(type: JacocoReport, dependsOn: ['testDebugUnitTest', 'createDebugCoverageReport']) {

    reports {
        xml.enabled = true
        html.enabled = true
    }

    def excludes = [
            '**/R.class',
            '**/R$*.class',
            '**/BuildConfig.*',
            '**/Manifest*.*',
            'android/**/*.*',
            '**/treemanager/component/**',
            '**/treemanager/tree/*.*',
            '**/activity/**'
    ]

    classDirectories = fileTree(
            dir: "$buildDir/intermediates/javac/debug/compileDebugJavaWithJavac/classes",
            excludes: excludes
    ) + fileTree(
            dir: "$buildDir/tmp/kotlin-classes/debug",
            excludes: excludes
    )

    sourceDirectories = files([
            android.sourceSets.main.java.srcDirs,
            "src/main/kotlin"
    ])

    executionData = fileTree(dir: project.buildDir, includes: [
            'jacoco/testDebugUnitTest.exec', 'outputs/code_coverage/debugAndroidTest/connected/**/*.ec'
    ])
}

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "com.snowdeer.jacoco.example"
        minSdkVersion 26
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        buildConfigField "long", "TIMESTAMP", System.currentTimeMillis() + "L"
    }
    buildTypes {
        debug {
            testCoverageEnabled true
        }

        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    packagingOptions {
        pickFirst 'lib/arm64-v8a/*'
        pickFirst 'lib/armeabi-v7a/*'
    }
    buildToolsVersion '28.0.3'
}

그런 다음 gradle 옵션에서 jacocoTestReport 항목을 선택하면 레포트가 만들어집니다.

팝업 형태의 다이얼로그(Dialog)로 실행하는 Directory Picker 입니다.

dialog_directory_picker.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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="wrap_content"
  android:layout_height="wrap_content"
  android:orientation="vertical">

  <FrameLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@color/colorPrimaryDark">

    <TextView
      android:textStyle="bold"
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:layout_marginTop="8dp"
      android:layout_marginBottom="8dp"
      android:layout_marginLeft="12dp"
      android:text="@string/directory_picker_title"
      android:textColor="@color/colorDialogTitle"
      android:textSize="24sp"/>

  </FrameLayout>

  <FrameLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@color/colorCurrentPathBackground">

    <TextView
      android:id="@+id/current_path"
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:layout_marginTop="4dp"
      android:layout_marginBottom="4dp"
      android:layout_marginLeft="12dp"
      android:text="current directory path"
      android:textColor="@color/colorCurrentPathText"
      android:textSize="16dp"/>

  </FrameLayout>

  <android.support.v7.widget.RecyclerView
    android:id="@+id/recycler_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_marginTop="16dp"
    android:minHeight="320dp"/>

</LinearLayout>

DirectoryListAdapter.kt

import android.content.Context
import android.os.Environment
import android.support.v7.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.snowdeer.ftpserver.R
import kotlinx.android.synthetic.main.item_directory.view.*
import java.io.File

interface OnDirectoryListEventListener {
    fun onDirectoryChanged(path: String)
}

data class DirectoryItem(val name: String, val path: String)

class DirectoryListAdapter(private val ctx: Context) : RecyclerView.Adapter<ViewHolder>() {

    private val list = ArrayList<DirectoryItem>()
    private val root = Environment.getExternalStorageDirectory().absolutePath
    var currentPath: String = ""

    var onDirectoryListEventListener: OnDirectoryListEventListener? = null

    fun refresh(path: String) {
        list.clear()

        val file = File(path)
        currentPath = file.path
        onDirectoryListEventListener?.onDirectoryChanged(path)

        addParentDirectory(file)

        if (!file.exists()) {
            notifyDataSetChanged()
            return
        }

        val files = file.listFiles()
        files?.let {
            for (f in it) {
                if (f.isHidden) {
                    continue
                }

                if (f.isDirectory) {
                    list.add(DirectoryItem(f.name, f.absolutePath))
                }
            }
        }

        notifyDataSetChanged()
    }

    private fun addParentDirectory(file: File) {
        val path = file.path
        if ((path == "/") || (path == root)) {
            return
        }

        list.add(DirectoryItem("..", file.parentFile.path))
    }

    override fun onCreateViewHolder(parent: ViewGroup, position: Int): ViewHolder {
        val view: View = LayoutInflater.from(ctx).inflate(R.layout.item_directory, parent, false)
        return ViewHolder(view)
    }

    fun getItem(position: Int): DirectoryItem {
        return list[position]
    }

    override fun getItemCount(): Int {
        return list.size
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val item = getItem(holder.adapterPosition)

        holder.name.text = item.name

        holder.layout_item.setOnClickListener {
            refresh(item.path)
        }
    }
}

class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    val layout_item = view.layout_item!!
    val name = view.name!!
}

DirectoryPickerDialog.kt

import android.app.Dialog
import android.os.Bundle
import android.support.v4.app.DialogFragment
import android.support.v4.app.FragmentActivity
import android.support.v7.app.AlertDialog
import android.support.v7.widget.LinearLayoutManager
import android.view.LayoutInflater
import android.widget.Toast
import com.snowdeer.ftpserver.R
import com.snowdeer.ftpserver.SnowPreference
import kotlinx.android.synthetic.main.dialog_directory_picker.view.*
import kotlinx.android.synthetic.main.item_directory.view.*
import java.io.File
import java.util.*

interface OnDirectoryPickerEventListener {
    fun onDirectorySelected(path: String)
}

class DirectoryPickerDialog : DialogFragment() {

    private lateinit var adapter: DirectoryListAdapter

    var onDirectoryPickerEventListener: OnDirectoryPickerEventListener? = null

    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        val builder = AlertDialog.Builder(Objects.requireNonNull<FragmentActivity>(activity))
        val inflater = activity!!.layoutInflater
        val view = inflater.inflate(R.layout.dialog_directory_picker, null)

        adapter = DirectoryListAdapter(activity!!)
        adapter.onDirectoryListEventListener = object : OnDirectoryListEventListener {
            override fun onDirectoryChanged(path: String) {
                view.current_path.text = path
            }
        }

        view.recycler_view.layoutManager = LinearLayoutManager(activity)
        view.recycler_view.adapter = adapter
        adapter.refresh(SnowPreference.getDirectory(activity!!))

        builder.setView(view)
                .setPositiveButton(getString(R.string.directory_picker_ok), null)
                .setNeutralButton(getString(R.string.directory_picker_new_directory), null)

        val dialog = builder.create()

        dialog.setOnShowListener {
            dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener {
                onDirectoryPickerEventListener?.onDirectorySelected(adapter.currentPath)
                dialog.dismiss()
            }

            dialog.getButton(AlertDialog.BUTTON_NEUTRAL).setOnClickListener {
                showNewDirectoryDialog(adapter.currentPath)
            }
        }

        return dialog
    }

    private fun showNewDirectoryDialog(path: String) {
        val view = LayoutInflater.from(activity).inflate(R.layout.dialog_new_directory, null)

        AlertDialog.Builder(activity!!)
                .setTitle(getString(R.string.directory_picker_new_directory))
                .setView(view)
                .setPositiveButton("Ok") { _, _ ->
                    val newPath = path + "/" + view.name.text.toString()
                    if (createDirectory(newPath)) {
                        adapter.refresh(path)
                    } else {
                        Toast.makeText(activity!!, getString(R.string.new_directory_failed), Toast.LENGTH_SHORT).show()
                    }

                }
                .show()
    }

    private fun createDirectory(path: String): Boolean {
        val file = File(path)

        if (file.exists()) {
            return false
        }

        return file.mkdir()
    }
}

안드로이드 버전에 따라 모니터링 방법이 조금씩 다르기 때문에 코드 내에서 분기를 태워줍니다.

AndroidManifest.xml

먼저 AndroidManifest.xml 파일에 permission을 추가해줍니다.

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

WifiConnectivityMonitor.kt

import android.annotation.TargetApi
import android.arch.lifecycle.LiveData
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Context.CONNECTIVITY_SERVICE
import android.content.Intent
import android.content.IntentFilter
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkInfo
import android.net.NetworkRequest
import android.os.Build

class WifiConnectivityMonitor(private val ctx: Context) : LiveData<Boolean>() {

    private var connectivityManager: ConnectivityManager = ctx.getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager

    private lateinit var connectivityManagerCallback: ConnectivityManager.NetworkCallback

    override fun onActive() {
        super.onActive()
        updateConnection()
        when {
            Build.VERSION.SDK_INT >= Build.VERSION_CODES.N ->
                connectivityManager.registerDefaultNetworkCallback(getConnectivityManagerCallback())
            Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP -> lollipopNetworkAvailableRequest()
            else -> {
                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
                    ctx.registerReceiver(networkReceiver, IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"))
                }
            }
        }
    }

    override fun onInactive() {
        super.onInactive()
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            connectivityManager.unregisterNetworkCallback(connectivityManagerCallback)
        } else {
            ctx.unregisterReceiver(networkReceiver)
        }
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private fun lollipopNetworkAvailableRequest() {
        val builder = NetworkRequest.Builder()
                .addTransportType(android.net.NetworkCapabilities.TRANSPORT_CELLULAR)
                .addTransportType(android.net.NetworkCapabilities.TRANSPORT_WIFI)
        connectivityManager.registerNetworkCallback(builder.build(), getConnectivityManagerCallback())
    }

    private fun getConnectivityManagerCallback(): ConnectivityManager.NetworkCallback {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {

            connectivityManagerCallback = object : ConnectivityManager.NetworkCallback() {
                override fun onAvailable(network: Network?) {
                    postValue(true)
                }

                override fun onLost(network: Network?) {
                    postValue(false)
                }
            }
            return connectivityManagerCallback
        } else {
            throw IllegalAccessError("Should not happened")
        }
    }

    private val networkReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            updateConnection()
        }
    }

    private fun updateConnection() {
        val activeNetwork: NetworkInfo? = connectivityManager.activeNetworkInfo
        postValue(activeNetwork?.isConnected == true)
    }
}

WifiConnectivityMonitor 클래스 사용 예시

private fun initWifiMonitor() {
    val connectivityMonitor = WifiConnectivityMonitor(this)
        connectivityMonitor.observe(this, Observer { isConnected ->
            isConnected?.let {
                if (it) {
                    ip_address.text = getWifiIPAddress()
                    port.visibility = View.VISIBLE
                } else {
                    ip_address.text = getString(R.string.wifi_not_available)
                    port.visibility = View.GONE
                }
            }
        })
}

private fun getWifiIPAddress(): String {
    val wm = getSystemService(Service.WIFI_SERVICE) as WifiManager
    return Formatter.formatIpAddress(wm.connectionInfo.ipAddress)
}

NotificationHandler.kt

import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.graphics.Color
import android.support.v4.app.NotificationCompat
import com.snowdeer.neverfi.R

class NotificationHandler {
    private lateinit var ctx: Context
    private lateinit var notificationManager: NotificationManager

    companion object {
        private const val CHANNEL_ID = "com.snowdeer.neverfi"
        private const val SUMMARY_NOTI_ID = 10003
        private const val NOTIFICATION_GROUP_KEY = "snowdeer_noti"
        val instance = NotificationHandler()
    }

    fun init(ctx: Context) {
        this.ctx = ctx
        notificationManager = ctx.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
    }

    fun createNotificationChannel(name: String, description: String) {
        val importance = NotificationManager.IMPORTANCE_LOW
        val channel = NotificationChannel(CHANNEL_ID, name, importance)

        channel.description = description
        channel.enableLights(true)
        channel.lightColor = Color.RED
        channel.enableVibration(true)
        channel.vibrationPattern = longArrayOf(100, 200, 300, 400, 500, 400, 300, 200, 400)
        notificationManager.createNotificationChannel(channel)
    }

    fun showNotification(id: Int, text: String, resultIntent: Intent) {
        val pendingIntent = PendingIntent.getActivity(ctx, 0, resultIntent, 0)
        val notification = Notification.Builder(ctx, CHANNEL_ID)
                .setContentText(text)
                .setSmallIcon(R.drawable.ic_launcher)
                .setChannelId(CHANNEL_ID)
                .setContentIntent(pendingIntent)
                .setGroup(NOTIFICATION_GROUP_KEY)
                .setGroupSummary(true)
                .build()

        notification.flags = Notification.FLAG_NO_CLEAR

        notificationManager.notify(id, notification)
        showSummaryNoti()
    }

    fun isPinnedItem(id: Int): Boolean {
        val notiList = notificationManager.activeNotifications

        for (n in notiList) {
            if (id == n.id) {
                return true
            }
        }

        return false
    }

    fun dismissNotification(id: Int) {

        notificationManager.cancel(id)
    }

    private fun showSummaryNoti() {
        val summaryNoti = NotificationCompat.Builder(ctx, CHANNEL_ID)
                .setSmallIcon(R.drawable.ic_launcher)
                .setStyle(NotificationCompat.InboxStyle()
                        .setSummaryText(ctx.getString(R.string.app_name)))
                .setGroup(NOTIFICATION_GROUP_KEY)
                .setGroupSummary(true)
                .build()

        notificationManager.notify(SUMMARY_NOTI_ID, summaryNoti)
    }
}

DayListBuilder.kt

import java.util.*
import kotlin.collections.ArrayList

data class DayInfo(
        val year: Int, val month: Int, val day: Int,
        val timestamp: Long, val inMonth: Boolean) {

    fun isToday(): Boolean {
        val c = Calendar.getInstance()
        val todayYear = c.get(Calendar.YEAR)
        val todayMonth = c.get(Calendar.MONTH)
        val todayDay = c.get(Calendar.DAY_OF_MONTH)

        return (todayYear == year) && (todayMonth == month) && (todayDay == day)
    }
}

class DayListBuilder {

    companion object {
        val instance = DayListBuilder()
    }

    private constructor()

    fun getDayList(year: Int, month: Int): ArrayList<DayInfo> {
        val list = ArrayList<DayInfo>()

        val c = Calendar.getInstance()

        c.set(Calendar.YEAR, year)
        c.set(Calendar.MONTH, month - 1)
        c.set(Calendar.DAY_OF_MONTH, 1)
        c.set(Calendar.HOUR_OF_DAY, 3)
        c.set(Calendar.MINUTE, 0)
        c.set(Calendar.SECOND, 0)

        // Add days of previous Month
        val prevMonthDays = c.get(Calendar.DAY_OF_WEEK) - Calendar.SUNDAY
        c.add(Calendar.DAY_OF_YEAR, -prevMonthDays)
        for (day in 0 until prevMonthDays) {
            list.add(DayInfo(c.get(Calendar.YEAR), c.get(Calendar.MONTH),
                    c.get(Calendar.DAY_OF_MONTH), c.timeInMillis, false))
            c.add(Calendar.DAY_OF_YEAR, 1)
        }

        // Add days of target Month
        for (day in 1..c.getActualMaximum(Calendar.DAY_OF_MONTH)) {
            c.set(Calendar.DAY_OF_MONTH, day)
            list.add(DayInfo(c.get(Calendar.YEAR), c.get(Calendar.MONTH),
                    c.get(Calendar.DAY_OF_MONTH), c.timeInMillis, false))
        }

        // Add days of next Month
        val nextMonthDays = Calendar.SATURDAY - c.get(Calendar.DAY_OF_WEEK)
        for (day in 1..nextMonthDays) {
            c.add(Calendar.DAY_OF_YEAR, 1)
            list.add(DayInfo(c.get(Calendar.YEAR), c.get(Calendar.MONTH),
                    c.get(Calendar.DAY_OF_MONTH), c.timeInMillis, false))
        }

        return list
    }
}

CalendarAdapter.kt

import android.content.Context
import android.graphics.Color
import android.support.v7.app.AlertDialog
import android.support.v7.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.snowdeer.htracker.R
import com.snowdeer.htracker.model.OnDatabaseEventListener
import com.snowdeer.htracker.model.RewardModelManager
import com.snowdeer.htracker.model.data.HabitDto
import kotlinx.android.synthetic.main.item_calendar.view.*
import java.util.*
import kotlin.collections.ArrayList

class CalendarAdapter(
        private val ctx: Context, private val habit: HabitDto?
        , private var year: Int, private var month: Int
) : RecyclerView.Adapter<ViewHolder>(), OnDatabaseEventListener {

    private var list = ArrayList<DayInfo>()

    init {
        refresh()
        RewardModelManager.instance.setOnDatabaseEventListener(this)
    }

    private fun refresh() {
        list = DayListBuilder.instance.getDayList(year, month)
        notifyDataSetChanged()
    }

    fun refresh(year: Int, month: Int) {
        this.year = year
        this.month = month
        refresh()
    }

    override fun onDatabaseUpdated() {

    }

    fun getItem(position: Int): DayInfo {
        return list[position]
    }

    override fun getItemCount(): Int {
        return list.size
    }

    override fun onCreateViewHolder(parent: ViewGroup, position: Int): ViewHolder {
        val view: View = LayoutInflater.from(ctx).inflate(R.layout.item_calendar, parent, false)
        return ViewHolder(view)
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val item = getItem(holder.adapterPosition)

        holder.day.text = item.day.toString()
        holder.day.setTextColor(getDayColor(item))

        if (existStamp(item.year, item.month, item.day)) {
            holder.stamp.visibility = View.VISIBLE
        } else {
            holder.stamp.visibility = View.INVISIBLE
        }

        if (item.isToday()) {
            holder.background.setBackgroundColor(ctx.getColor(R.color.today_background))
        } else {
            holder.background.setBackgroundColor(ctx.getColor(R.color.transparent))
        }

        holder.background.setOnClickListener {
            if (habit != null) {
                if (item.isToday()) {
                    if (existStamp(item.year, item.month, item.day)) {
                        RewardModelManager.instance.delete(habit.id, item.year, item.month, item.day)
                    } else {
                        RewardModelManager.instance.create(habit.id, item.year, item.month, item.day)
                    }
                    notifyItemChanged(holder.adapterPosition)
                } else {
                    showForceHabitResultDialog(holder.adapterPosition, habit.id, item.year, item.month, item.day)
                }
            }
        }
    }

    private fun existStamp(year: Int, month: Int, day: Int): Boolean {
        if (habit == null) {
            return false
        }

        return RewardModelManager.instance.exist(habit.id, year, month, day)
    }

    private fun getDayColor(info: DayInfo): Int {
        val c = Calendar.getInstance()
        c.set(Calendar.YEAR, info.year)
        c.set(Calendar.MONTH, info.month)
        c.set(Calendar.DAY_OF_MONTH, info.day)

        if (info.inMonth) {
            when (c.get(Calendar.DAY_OF_WEEK)) {
                Calendar.SUNDAY -> return ctx.getColor(R.color.in_month_sunday)
                Calendar.SATURDAY -> return ctx.getColor(R.color.in_month_saturday)
            }
            return Color.BLACK
        } else {
            when (c.get(Calendar.DAY_OF_WEEK)) {
                Calendar.SUNDAY -> return ctx.getColor(R.color.out_month_sunday)
                Calendar.SATURDAY -> return ctx.getColor(R.color.out_month_saturday)
            }

            return Color.GRAY
        }
        return Color.BLACK
    }

    private fun showForceHabitResultDialog(pos: Int, habitId: Long, year: Int, month: Int, day: Int) {
        AlertDialog.Builder(ctx)
                .setTitle("It is not Today. Do you want to edit the result?")
                .setPositiveButton("Yes") { _, _ ->
                    if (existStamp(year, month, day)) {
                        RewardModelManager.instance.delete(habitId, year, month, day)
                    } else {
                        RewardModelManager.instance.create(habitId, year, month, day)
                    }
                    notifyItemChanged(pos)
                }
                .setNegativeButton("No") { _, _ ->
                }
                .show()
    }
}

class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    val background = view.item_layout!!
    val day = view.day!!
    val stamp = view.stamp!!
}

fragment_calendar.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:orientation="vertical">

  <LinearLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:orientation="vertical">

    <TextView
      android:id="@+id/month"
      android:textStyle="bold"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_marginTop="8dp"
      android:layout_marginStart="8dp"
      android:layout_gravity="center_vertical"
      android:text="5"
      android:textColor="@color/black"
      android:textSize="34sp"/>

    <TextView
      android:id="@+id/year"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_marginStart="8dp"
      android:layout_gravity="center_vertical"
      android:text="2019"
      android:textColor="@color/darkergray"
      android:textSize="16sp"/>
  </LinearLayout>

  <android.support.v7.widget.RecyclerView
    android:id="@+id/recycler_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_margin="8dp"/>

</LinearLayout>

CalendarFragment.kt

import android.os.Bundle
import android.support.v4.app.Fragment
import android.support.v7.widget.GridLayoutManager
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.snowdeer.htracker.R
import com.snowdeer.htracker.model.data.HabitDto
import com.snowdeer.utils.Log
import kotlinx.android.synthetic.main.fragment_calendar.view.*
import java.util.*

private const val ARG_YEAR = "ARG_YEAR"
private const val ARG_MONTH = "ARG_MONTH"
private const val ARG_HABIT = "ARG_HABIT"

class CalendarFragment : Fragment() {

    private var year: Int = 2019
    private var month: Int = 1
    private var habit: HabitDto? = null

    private lateinit var adapter: CalendarAdapter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        arguments?.let {
            year = it.getInt(ARG_YEAR)
            month = it.getInt(ARG_MONTH)
            habit = it.getParcelable(ARG_HABIT)
        }

        Log.i("onCreate: $habit")
    }

    companion object {
        fun newInstanceWithMonthOffset(habit: HabitDto?, offset: Int): CalendarFragment {
            val c = Calendar.getInstance()
            c.add(Calendar.MONTH, offset)

            Log.i("newInstanceWithMonthOffset: $habit")
            return newInstance(habit, c.get(Calendar.YEAR), c.get(Calendar.MONTH) + 1)
        }

        private fun newInstance(habit: HabitDto?, year: Int, month: Int): CalendarFragment {
            return CalendarFragment().apply {
                arguments = Bundle().apply {
                    putInt(ARG_YEAR, year)
                    putInt(ARG_MONTH, month)
                    putParcelable(ARG_HABIT, habit)
                }
            }
        }
    }

    override fun onCreateView(
            inflater: LayoutInflater, container: ViewGroup?,
            savedInstanceState: Bundle?): View? {
        val view = inflater.inflate(R.layout.fragment_calendar, container, false)

        view.year.text = year.toString()
        view.month.text = month.toString()

        Log.i("onCreateView: $habit")
        adapter = CalendarAdapter(activity!!, habit, year, month)
        view.recycler_view.layoutManager = GridLayoutManager(activity, 7)
        view.recycler_view.adapter = adapter

        return view
    }
}