"Delegates, Delegates everywhere" Владимир Миронов

Delegates, Delegates
everywhere
Миронов Владимир

Делегирование
● Очень часто используемый дизайн паттерн

● Kotlin поддерживает делегирование на уровне языка

● Два вида делегирования в Kotlin

● Interface delegation

● Interface delegation
● Property delegation

Properties
● Понятие field отсутсвует на уровне языка

Properties
● Есть только property

Properties
● Пара setter + getter для var и getter для val

Properties
● Все обращения происходят через getter и setter

Properties
● Все обращения происходят через getter и setter
● При необходимости у property есть backing field

Property Delegation
class HelloDelegates {
var property by Delegate()
}

Property Delegation
}
private val delegate = Delegate()
}

Property Delegation
}
private val delegate = Delegate()
var property: String
set(value) = delegate.setValue(this, metadata, value)
get() = delegate.getValue(this, metadata)
}

Property Delegation
class Delegate {
operator fun getValue(thisRef: Any, property: KProperty<*>): String
operator fun setValue(thisRef: Any, property: KProperty<*>, value: String)
}

Property Delegation
class Delegate {
operator fun getValue(thisRef: Any, property: KProperty<*>): String
operator fun setValue(thisRef: Any, property: KProperty<*>, value: String)
}
class Delegate : ReadOnlyProperty<Any, String>
class Delegate : ReadWriteProperty<Any, String>

Built-in delegates
● Delegates.notNull()
● lazy
● Delegates.observable()
● Delegates.vetoable

Delegates.notNull()
class ChatFragment : Fragment() {
override fun onAttach(activity: Activity) {
super.onAttach(activity)
adapter = createMessagesAdapter(context)
}
}

Delegates.notNull()
private var adapter: MessagesAdapter? = null
}
}

Delegates.notNull()
private var adapter: MessagesAdapter? = null
}
private fun onMessagesChanged(messages: List<Message>) {
adapter!!.notifyMessagedChanged(messages)
}
}

Delegates.notNull()
private var adapter: MessagesAdapter by Delegates.notNull()
}
adapter!!.notifyMessagedChanged(messages)
}
}

Delegates.notNull()
private var adapter: MessagesAdapter by Delegates.notNull()
}
adapter.notifyMessagedChanged(messages)
}
}

lazy
private val adapter by lazy(LazyThreadSafetyMode.NONE) {
createMessagesAdapter(context)
}
adapter.notifyMessagedChanged(messages)
}
}

Delegates.observable
private var title by Delegates.observable("Chat") { desc, old, new ->
notifyTitleChanged(new)
}
private fun notifyTitleChanged(title: String) {
titleView.text = title
}
}

Наш первый делегат
public class OvalView extends View {
private float radiusX = 100.0f;
private float radiusY = 100.0f;
}

public void setRadiusX(float radiusX) {
this.radiusX = radiusX;
invalidate();
}
}

public void setRadiusX(float radiusX) {
this.radiusX = radiusX;
invalidate();
}
public void setRadiusY(float radiusY) {
this.radiusY = radiusY;
invalidate();
}
}

class OvalView : View() {
val radiusX by Delegates.observable(100.0f) { desc, old, new ->
invalidate()
}
val radiusY by Delegates.observable(100.0f) { desc, old, new ->
invalidate()
}
}

fun <T> View.bindViewProperty(initial: T): ReadWriteProperty<Any, T> {
return Delegates.observable(initial) { desc, old, new ->
invalidate()
}
}

invalidate()
}
}
val radiusX by bindViewProperty(100.0f)
val radiusY by bindViewProperty(100.0f)
}

invalidate()
}
}
val radiusX by bindViewProperty(100.0f)
val radiusY by bindViewProperty(100.0f)
val centerX by bindViewProperty(50.0f)
val centerY by bindViewProperty(50.0f)
}

Еще один простой делегат
fun <V : View> Activity.bindView(id: Int): Lazy<V> {
throw UnsupportedOperationException("Implement me!")
}

return lazy(LazyThreadSafetyMode.NONE) {
findViewById(id) as V
}
}

return lazy(LazyThreadSafetyMode.NONE) {
findViewById(id) as V
}
}
class UserActivity : Activity() {
private val image by bindView<ImageView>(R.id.user_image)
private val firstName by bindView<TextView>(R.id.user_first_name)
private val lastName by bindView<TextView>(R.id.user_last_name)
}

Typesafe Bundle Builders
val fragment = UserFragment()
val extras = Bundle()
extras.putString("firstName", "Ivan")
extras.putString("lastName", "Ivanov")
extras.putInt("age", 20)
fragment.arguments = extras

val extras = Bundle()
extras.putString("firstName", "Ivan")
extras.putString("lastName", "Ivanov")
extras.putInt("age", 20)
fragment.arguments = extras
inline fun <reified T : Any> bindArgument(bundle: Bundle, default: T? = null): BundleDelegate {
throw UnsupportedOperationException()
}

class UserArguments(val extras: Bundle) {
var firstName by bindArgument<String>(extras)
var lastName by bindArgument<String>(extras)
var age by bindArgument(extras, 33)
}

class UserArguments(val extras: Bundle) {
var firstName by bindArgument<String>(extras)
var lastName by bindArgument<String>(extras)
var age by bindArgument(extras, 33)
}
val arguments = UserArguments(Bundle())
arguments.firstName = "Ivan"
arguments.lastName = "Ivanov"
fragment.arguments = arguments.extras

class UserFragment : Fragment() {
private val args by lazy(LazyThreadSafetyMode.NONE) {
UserArguments(arguments)
}
}

LifecycleAware delegates
class ChatFragment : BaseFragment() {
private var chat by Delegates.notNull<ChatModel>()
private var messages by Delegates.notNull<CollectionRange<Message>>()
}

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
chat = acquireChatModel()
messages = chat.acquireMessagesRange()
}
}

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
chat = acquireChatModel()
messages = chat.acquireMessagesRange()
}
override fun onDestroy() {
messages.close()
chat.close()
super.onDestroy()
}
}

private val chat by bindToLifecycleEagerly(LifecycleInterval.CREATED) {
acquireChatModel()
}
private val participants by bindToLifecycleEagerly(LifecycleInterval.CREATED) {
chat.acquireParticipantsRange()
}
}

Preferences delegates
class DebugSettings(private val preferences: SharedPreferences) {
var logEnabled: Boolean
set(value) = preferences.edit().putBoolean("logEnabled", value).apply()
get() = preferences.getBoolean("logEnabled", true)
var logTag: String
set(value) = preferences.edit().putString("logTag", value).apply()
get() = preferences.getString("logTag", "Debug")
}

class DebugSettings(private val preferences: SharedPreferences) {
var logEnabled by bindPreference(preferences, true)
var logTag by bindPreference(preferences, "Debug")
}

ReadWriteProperty и ReadOnlyProperty

ReadWriteProperty и ReadOnlyProperty
public interface ReadWriteProperty<in R, T> {
public operator fun getValue(thisRef: R, property: KProperty<*>): T
public operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}
public interface ReadOnlyProperty<in R, out T> {
public operator fun getValue(thisRef: R, property: KProperty<*>): T
}

KProperty<T>
● Хранит в себе метаинформацию о property

KProperty<T>
● KProperty<T>.name: String

KProperty<T>
● KProperty<T>.returnType.javaType: Class

KProperty<T>
● KProperty<T>.returnType.isMarkedNullable: Boolean

KProperty<T>
● KProperty<T>.returnType.isMarkedNullable: Boolean
● KProperty<T>.annotations: List<Annotation>

KProperty<T> и Android
● По дефолту работает только KProperty.name

● Оставшимся методам необходима зависимость kotlin-reflect

● Количество методов - 12112

● JAR Size - 2268KB

● JAR Size - 2268KB
● DEX size - 1726KB

Как жить без reflection

● KProperty.name работает и так

● KProperty.returnType.javaType - inline reified generic функция

● KProperty.returnType.isMarkedNullable - два разных делегата

inline fun <reified T : Any> bindValue(): ReadWriteProperty<Any, T> {
return createRequiredDelegate(T::class.java)
}

inline fun <reified T : Any> bindValue(): ReadWriteProperty<Any, T> {
return createRequiredDelegate(T::class.java)
}
inline fun <reified T : Any> bindOptionalValue(): ReadWriteProperty<Any, T?> {
return createOptionalDelegate(T::class.java)
}

class PreferenceReadWriteProperty<T : Any>(
// some arguments here
) : ReadWriteProperty<Any, T> {
// implement me
}

private val preferences: SharedPreferences
// implement me
}

private val preferences: SharedPreferences,
private val clazz: Class<T>
// implement me
}

private val clazz: Class<T>,
private val default: T
// implement me
}

private val clazz: Class<T>,
private val default: T,
private val name: String?
// implement me
}

override fun getValue(thisRef: Any, property: KProperty<*>): T {
throw UnsupportedOperationException()
}

val key = name ?: property.name
}

if (!preferences.contains(key)) {
return default
}
}

return default
}
return when (clazz) {
String::class.java -> preferences.getString(key, null)
else -> throw UnsupportedOperationException()
} as T
}

return default
}
Int::class.java -> preferences.getInt(key, 0)
} as T
}

return default
}
Long::class.java -> preferences.getLong(key, 0L)
} as T
}

return default
}
Boolean::class.java -> preferences.getBoolean(key, false)
} as T
}

return default
}
Boolean::class.java -> preferences.getBoolean(key, false)
Float::class.java -> preferences.getFloat(key, 0.0f)
} as T
}

inline fun <reified T : Any> bindPreference(
preferences: SharedPreferences,
default: T,
name: String? = null
return PreferenceReadWriteProperty(preferences, T::class.java, default, name)
}

Links
https://kotlinlang.org/docs/reference/delegated-properties.html
https://github.com/JakeWharton/kotterknife
https://github.com/nsk-mironov/kotlin-jetpack

​"Delegates, Delegates everywhere" Владимир Миронов

More Related Content

What's hot

Viewers also liked

Similar to ​"Delegates, Delegates everywhere" Владимир Миронов

More from AvitoTech