interface Base{
    fun text()
}
//被委托的類(lèi)(真實(shí)的類(lèi))
class BaseImpl(val x:String): Base {
    override fun text() {
        println(x)
    }
}
//委托類(lèi)
class Devices(b:Base):Base by b
fun main(){
    var b = BaseImpl("真實(shí)的類(lèi)")
    Devices(b).text()
}

public final class BaseImpl implements Base {
   @NotNull
   private final String x;
   public BaseImpl(@NotNull String x) {
      Intrinsics.checkNotNullParameter(x, "x");
      super();
      this.x = x;
   }
   @NotNull
   public final String getX() {
      return this.x;
   }
   public void text() {
      String var1 = this.x;
      System.out.println(var1);
   }
}
// Devices.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
@Metadata(
   mv = {1, 9, 0},
   k = 1,
   xi = 48,
   d1 = {"\u0000\u0012\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0003\n\u0002\u0010\u0002\n\u0000\u0018\u00002\u00020\u0001B\r\u0012\u0006\u0010\u0002\u001a\u00020\u0001￠\u0006\u0002\u0010\u0003J\t\u0010\u0004\u001a\u00020\u0005H\u0096\u0001¨\u0006\u0006"},
   d2 = {"Lcom/example/memoryoptimizing/delegate/Devices;", "Lcom/example/memoryoptimizing/delegate/Base;", "b", "(Lcom/example/memoryoptimizing/delegate/Base;)V", "text", "", "app_debug"}
)
public final class Devices implements Base {
   // $FF: synthetic field
   private final Base $$delegate_0;
   public Devices(@NotNull Base b) {
      Intrinsics.checkNotNullParameter(b, "b");
      super();
      this.$$delegate_0 = b;
   }
   public void text() {
      this.$$delegate_0.text();
   }
}
// BaseImplKt.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
@Metadata(
   mv = {1, 9, 0},
   k = 2,
   xi = 48,
   d1 = {"\u0000\b\n\u0000\n\u0002\u0010\u0002\n\u0000\u001a\u0006\u0010\u0000\u001a\u00020\u0001¨\u0006\u0002"},
   d2 = {"main", "", "app_debug"}
)
public final class BaseImplKt {
   public static final void main() {
      BaseImpl b = new BaseImpl("真實(shí)的類(lèi)");
      (new Devices((Base)b)).text();
   }
   // $FF: synthetic method
   public static void main(String[] args) {
      main();
   }
}

val/var <屬性名>:<類(lèi)型> by <表達(dá)式>

class B{
    //委托屬性
    var a : String by Text()
}
class Text {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "屬性擁有者 = $thisRef ,屬性的名字 = ‘${property.name}' 屬性的值"
    }
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("屬性的值 = $value 屬性的名字 = '${property.name}' 屬性擁有者 = $thisRef")
    }
}
fun main(){
    var b = B()
    println(b.a)
    b.a = "ahaha"
}

public final class B {
   // $FF: synthetic field
   static final KProperty[] $$delegatedProperties;
   @NotNull
   private final Text a$delegate = new Text();
   @NotNull
   public final String getA() {
      return this.a$delegate.getValue(this, $$delegatedProperties[0]);
   }
   public final void setA(@NotNull String var1) {
      Intrinsics.checkNotNullParameter(var1, "<set-?>");
      this.a$delegate.setValue(this, $$delegatedProperties[0], var1);
   }
   static {
      KProperty[] var0 = new KProperty[]{Reflection.mutableProperty1((MutablePropertyReference1)(new MutablePropertyReference1Impl(B.class, "a", "getA()Ljava/lang/String;", 0)))};
      $$delegatedProperties = var0;
   }
}
// Text.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import kotlin.reflect.KProperty;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@Metadata(
   mv = {1, 9, 0},
   k = 1,
   xi = 48,
   d1 = {"\u0000\"\n\u0002\u0018\u0002\n\u0002\u0010\u0000\n\u0002\b\u0002\n\u0002\u0010\u000e\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0010\u0002\n\u0002\b\u0002\u0018\u00002\u00020\u0001B\u0005￠\u0006\u0002\u0010\u0002J\u001f\u0010\u0003\u001a\u00020\u00042\b\u0010\u0005\u001a\u0004\u0018\u00010\u00012\n\u0010\u0006\u001a\u0006\u0012\u0002\b\u00030\u0007H\u0086\u0002J'\u0010\b\u001a\u00020\t2\b\u0010\u0005\u001a\u0004\u0018\u00010\u00012\n\u0010\u0006\u001a\u0006\u0012\u0002\b\u00030\u00072\u0006\u0010\n\u001a\u00020\u0004H\u0086\u0002¨\u0006\u000b"},
   d2 = {"Lcom/example/memoryoptimizing/delegate/Text;", "", "()V", "getValue", "", "thisRef", "property", "Lkotlin/reflect/KProperty;", "setValue", "", "value", "app_debug"}
)
public final class Text {
   @NotNull
   public final String getValue(@Nullable Object thisRef, @NotNull KProperty property) {
      Intrinsics.checkNotNullParameter(property, "property");
      return "屬性擁有者 = " + thisRef + " ,屬性的名字 = ‘" + property.getName() + "' 屬性的值";
   }
   public final void setValue(@Nullable Object thisRef, @NotNull KProperty property, @NotNull String value) {
      Intrinsics.checkNotNullParameter(property, "property");
      Intrinsics.checkNotNullParameter(value, "value");
      String var4 = "屬性的值 = " + value + " 屬性的名字 = '" + property.getName() + "' 屬性擁有者 = " + thisRef;
      System.out.println(var4);
   }
}
// TextKt.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
@Metadata(
   mv = {1, 9, 0},
   k = 2,
   xi = 48,
   d1 = {"\u0000\b\n\u0000\n\u0002\u0010\u0002\n\u0000\u001a\u0006\u0010\u0000\u001a\u00020\u0001¨\u0006\u0002"},
   d2 = {"main", "", "app_debug"}
)
public final class TextKt {
   public static final void main() {
      B b = new B();
      String var1 = b.getA();
      System.out.println(var1);
      b.setA("ahaha");
   }
   // $FF: synthetic method
   public static void main(String[] args) {
      main();
   }
}

public fun interface ReadOnlyProperty<in T, out V> {
    /**
     * Returns the value of the property for the given object.
     * @param thisRef the object for which the value is requested.
     * @param property the metadata for the property.
     * @return the property value.
     */
    public operator fun getValue(thisRef: T, property: KProperty<*>): V
}
/**
 * Base interface that can be used for implementing property delegates of read-write properties.
 *
 * This is provided only for convenience; you don't have to extend this interface
 * as long as your property delegate has methods with the same signatures.
 *
 * @param T the type of object which owns the delegated property.
 * @param V the type of the property value.
 */
public interface ReadWriteProperty<in T, V> : ReadOnlyProperty<T, V> {
    /**
     * Returns the value of the property for the given object.
     * @param thisRef the object for which the value is requested.
     * @param property the metadata for the property.
     * @return the property value.
     */
    public override operator fun getValue(thisRef: T, property: KProperty<*>): V
    /**
     * Sets the value of the property for the given object.
     * @param thisRef the object for which the value is requested.
     * @param property the metadata for the property.
     * @param value the value to set.
     */
    public operator fun setValue(thisRef: T, property: KProperty<*>, value: V)
}

class Text1:ReadOnlyProperty<Any,String>{
    override fun getValue(thisRef: Any, property: KProperty<*>): String {
        return "屬性擁有者 = $thisRef ,屬性的名字 = ‘${property.name}' 屬性的值"
    }
}
class Text2: ReadWriteProperty<Any,String>{
    override fun getValue(thisRef: Any, property: KProperty<*>): String {
        return "屬性擁有者 = $thisRef ,屬性的名字 = ‘${property.name}' 屬性的值"
    }
    override fun setValue(thisRef: Any, property: KProperty<*>, value: String) {
        println("屬性的值 = $value 屬性的名字 = '${property.name}' 屬性擁有者 = $thisRef")
    }
}

class B{
    val b :String by Text1()
    var c : String by Text2()
}

fun main(){
    var b = B()
    b.c = "1"
}

class Lazy{
    val name:String by lazy(LazyThreadSafetyMode.SYNCHRONIZED){
        println("第一次初始化")
        "aa"
    }
}
fun main(){
    var lazy = Lazy()
    println(lazy.name)
    println(lazy.name)
}

public final class Lazy {
   @NotNull
   private final kotlin.Lazy name$delegate;
   public Lazy() {
      this.name$delegate = kotlin.LazyKt.lazy( (Function0)null.INSTANCE);
   }
   @NotNull
   public final String getName() {
      kotlin.Lazy var1 = this.name$delegate;
      Object var2 = null;
      return (String)var1.getValue();
   }
}
// LazyKt.java
package com.example.memoryoptimizing.delegate;
import kotlin.Metadata;
@Metadata(
   mv = {1, 9, 0},
   k = 2,
   xi = 48,
   d1 = {"\u0000\b\n\u0000\n\u0002\u0010\u0002\n\u0000\u001a\u0006\u0010\u0000\u001a\u00020\u0001¨\u0006\u0002"},
   d2 = {"main", "", "app_debug"}
)
public final class LazyKt {
   public static final void main() {
      Lazy lazy = new Lazy();
      String var1 = lazy.getName();
      System.out.println(var1);
      var1 = lazy.getName();
      System.out.println(var1);
   }
   // $FF: synthetic method
   public static void main(String[] args) {
      main();
   }
}

public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    // final field is required to enable safe publication of constructed instance
    private val lock = lock ?: this
    override val value: T
        get() {
            val _v1 = _value
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }
            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                } else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }
    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE
    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."
    private fun writeReplace(): Any = InitializedLazyImpl(value)
}

public enum class LazyThreadSafetyMode {
    /**
     * Locks are used to ensure that only a single thread can initialize the [Lazy] instance.
     */
    SYNCHRONIZED,
    /**
     * Initializer function can be called several times on concurrent access to uninitialized [Lazy] instance value,
     * but only the first returned value will be used as the value of [Lazy] instance.
     */
    PUBLICATION,
    /**
     * No locks are used to synchronize an access to the [Lazy] instance value; if the instance is accessed from multiple threads, its behavior is undefined.
     *
     * This mode should not be used unless the [Lazy] instance is guaranteed never to be initialized from more than one thread.
     */
    NONE,
}

    val name :String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
        println("第一次調(diào)用初始化")
        "aa" }
}

class Observable {
    var a:String by Delegates.observable("默認(rèn)值"){
        property, oldValue, newValue ->
        println("${oldValue} -> ${newValue}")
    }
}
fun main(){
    var observable = Observable()
    observable.a = "第一次修改的值"
    observable.a = "第二次修改的值"
}

class Vetoable {
    var age:Int by Delegates.vetoable(0){
        property, oldValue, newValue ->
        println("oldValue = $oldValue -> oldValue = $newValue" )
        newValue > oldValue
    }
}
fun main() {
    var c = Vetoable()
    c.age = 5
    println(c.age)
    c.age = 10
    println(c.age)
    c.age = 8
    println(c.age)
    c.age = 20
    println(c.age)
}

class D(val map:Map<String,Any?>){
    val name:String by map
    val age:Int by map
}
fun main() {
    var d = D(
        mapOf(
            "name" to "小明",
            "age" to 12
        )
    )
    println("name = ${d.name},age = ${d.age}")
}

    private var backPressedTime by Delegates.observable(0L){pre,old,new ->
        //2次的時(shí)間間隔小于2秒就退出了
        if(new - old < 2000){
            finish()
        }else{
            Toast.makeText(this,"再按返回鍵退出",Toast.LENGTH_LONG)
        }
    }
    override fun onBackPressed() {
        super.onBackPressed()
        backPressedTime = System.currentTimeMillis()
    }

private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
class DelegateFragment : Fragment() {
    // TODO: Rename and change types of parameters
    private var param1: String? = null
    private var param2: String? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        arguments?.let {
            param1 = it.getString(ARG_PARAM1)
            param2 = it.getString(ARG_PARAM2)
        }
    }
    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_delegate, container, false)
    }
    companion object {
        /**
         * Use this factory method to create a new instance of
         * this fragment using the provided parameters.
         *
         * @param param1 Parameter 1.
         * @param param2 Parameter 2.
         * @return A new instance of fragment DelegateFragment.
         */
        // TODO: Rename and change types and number of parameters
        @JvmStatic
        fun newInstance(param1: String, param2: String) =
            DelegateFragment().apply {
                arguments = Bundle().apply {
                    putString(ARG_PARAM1, param1)
                    putString(ARG_PARAM2, param2)
                }
            }
    }
}

class DelegateFragment : Fragment() {
    private var param1: String? by argumentNullable()
    private var param2: String by argument("1")
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.d("DelegateFragment","param1 ${param1} param2 ${param2}")
    }
    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_delegate, container, false)
    }
    companion object {
        /**
         * Use this factory method to create a new instance of
         * this fragment using the provided parameters.
         *
         * @param param1 Parameter 1.
         * @param param2 Parameter 2.
         * @return A new instance of fragment DelegateFragment.
         */
        // TODO: Rename and change types and number of parameters
        @JvmStatic
        fun newInstance(param1: String, param2: String) =
            DelegateFragment().apply {
               this.param1 = param1
                this.param2 = param2
            }
    }
}

import android.os.Bundle
import android.os.Parcelable
import android.util.Log
import androidx.fragment.app.Fragment
import java.io.Serializable
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
fun <T> Fragment.argumentNullable() = FragmentArgumentPropertyNullable<T>()
fun <T> Fragment.argument(defaultValue:T? = null) = FragmentArgumentProperty<T>(defaultValue)
class FragmentArgumentPropertyNullable<T> : ReadWriteProperty<Fragment,T?>{
    override fun getValue(thisRef: Fragment, property: KProperty<*>): T? {
        return thisRef.arguments?.getValue(property.name)
    }
    override fun setValue(thisRef: Fragment, property: KProperty<*>, value: T?) {
        Log.d("DelegateFragment","property.name ${property.name} thisRef.arguments ${thisRef.arguments}")
        val arguments = thisRef.arguments?:Bundle().also {
            thisRef.arguments = it
        }
        if(arguments.containsKey(property.name)){
            return
        }
        arguments[property.name] = value
    }
}
class FragmentArgumentProperty<T> (private val defaultValue: T? = null): ReadWriteProperty<Fragment,T>{
    override fun getValue(thisRef: Fragment, property: KProperty<*>): T {
        return thisRef.arguments?.getValue(property.name) as? T
            ?:defaultValue
            ?:throw IllegalStateException("Property ${property.name} could not be read")
    }
    override fun setValue(thisRef: Fragment, property: KProperty<*>, value: T) {
        val arguments = thisRef.arguments?:Bundle().also {
            thisRef.arguments  = it
        }
        if(arguments.containsKey(property.name)){
            return
        }
        arguments[property.name] = value
    }
}
fun <T> Bundle.getValue(key:String):T?{
    return get(key) as T?
}
//操作符重載a[i] = b	set()	a.set(i, b)
operator fun <T> Bundle.set(key: String, value: T?) {
    when (value) {
        is Boolean -> putBoolean(key, value)
        is Byte -> putByte(key, value)
        is Char -> putChar(key, value)
        is Short -> putShort(key, value)
        is Int -> putInt(key, value)
        is Long -> putLong(key, value)
        is Float -> putFloat(key, value)
        is Double -> putDouble(key, value)
        is String? -> putString(key, value)
        is CharSequence? -> putCharSequence(key, value)
        is Serializable? -> putSerializable(key, value) // also ArrayList
        is Parcelable? -> putParcelable(key, value)
        is Bundle? -> putBundle(key, value)
        is BooleanArray? -> putBooleanArray(key, value)
        is ByteArray? -> putByteArray(key, value)
        is CharArray? -> putCharArray(key, value)
        is ShortArray? -> putShortArray(key, value)
        is IntArray? -> putIntArray(key, value)
        is LongArray? -> putLongArray(key, value)
        is FloatArray? -> putFloatArray(key, value)
        is DoubleArray? -> putDoubleArray(key, value)
        is ArrayList<*>? -> throw IllegalStateException("ArrayList<*> $key is not supported")
        is Array<*>? -> throw IllegalStateException("Array<*> $key is not supported")
        else -> throw IllegalStateException("Type $key is not supported")
    }
}

class DelegateFragment : Fragment(R.layout.fragment_delegate) {
    private var _binding: FragmentDelegateBinding? = null
    private val binding get() = _binding!!
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        _binding = FragmentDelegateBinding.bind(view)
        binding.tvName.text = "This is Hello World"
    }
    override fun onDestroyView() {
        super.onDestroyView()
        //置空，防止內(nèi)存泄漏
        _binding = null
    }
}

public final class FragmentDelegateBinding implements ViewBinding {
    private final ConstraintLayout rootView;
    public final TextView tvDisplay;
    private FragmentDelegateBinding(ConstraintLayout paramConstraintLayout1, TextView paramTextView)
        this.rootView = paramConstraintLayout1;
        this.tvDisplay = paramTextView;
    }
    public static FragmentDelegateBindingbind(View paramView) {
        TextView localTextView = (TextView)paramView.findViewById(2131165363);
        if (localTextView != null) {
            return new ActivityMainBinding((ConstraintLayout)paramView, localTextView);
        }else {
          paramView = "tvDisplay";
        }
        throw new NullPointerException("Missing required view with ID: ".concat(paramView));
    }
    public static FragmentDelegateBinding inflate(LayoutInflater paramLayoutInflater) {
        return inflate(paramLayoutInflater, null, false);
    }
    public static FragmentDelegateBinding inflate(LayoutInflater paramLayoutInflater, ViewGroup paramViewGroup, boolean paramBoolean) {
        paramLayoutInflater = paramLayoutInflater.inflate(2131361821, paramViewGroup, false);
        if (paramBoolean) {
            paramViewGroup.addView(paramLayoutInflater);
        }
        return bind(paramLayoutInflater);
    }
    public ConstraintLayout getRoot() {
        return this.rootView;
    }
}

package com.example.memoryoptimizing.delegate
import android.os.Handler
import android.os.Looper
import android.util.Log
import android.view.View
import androidx.fragment.app.Fragment
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.LifecycleOwner
import androidx.viewbinding.ViewBinding
import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty
//為什么使用inline fun<reified V>，方便直接拿到V::class.java
/**
 * fun <V> printClass() {
 *     println(V::class.java) // ? 編譯錯(cuò)誤：Cannot access 'java.lang.Class' for a type parameter V
 * }
 * inline fun <reified V> printClass() {
 *     println(V::class.java) // ? 輸出如：class kotlin.String
 * }
 */
//在屬性委托中，編譯器可以通過(guò)屬性聲明的類(lèi)型,如 FragmentDelegateBinding）來(lái)推斷泛型函數(shù)中的具體類(lèi)型參數(shù)；
// 而在普通函數(shù)調(diào)用中，僅憑返回值或賦值目標(biāo)無(wú)法反推出泛型參數(shù)的具體類(lèi)型。
/**
? 場(chǎng)景一：屬性委托 + reified 泛型函數(shù) ? 可以推斷
private val binding: FragmentDelegateBinding by viewBindingV1()
? 場(chǎng)景二：普通函數(shù)調(diào)用 ? 無(wú)法推斷
inline fun <reified V> getTypeName(): String {
    return V::class.java.name
}
val name: String = getTypeName()
 */
private const val TAG = "ViewBindingProperty"
//使用inline fun <reified V>可以在調(diào)用泛型函數(shù)時(shí)省略參數(shù)的傳遞，Kotlin會(huì)自動(dòng)根據(jù)泛型類(lèi)型幫你找到對(duì)應(yīng)的class<T>
public inline fun <reified V:ViewBinding> viewBindingV1() = viewBindingV1(V::class.java)
public inline fun <reified T:ViewBinding> viewBindingV1(clazz:Class<T>):FragmentViewBindingProperttV1<Fragment,T>{
    val bindMethod = clazz.getMethod("bind", View::class.java)
    return FragmentViewBindingProperttV1{ fragment->
        /**
         * 調(diào)用靜態(tài)方法bind(View view)，第一個(gè)參數(shù)為null(因?yàn)槭庆o態(tài)方法) 第二個(gè)參數(shù)是View，來(lái)自Fragment的requireView()
         * as T 將結(jié)果強(qiáng)制轉(zhuǎn)換為泛型T，即具體的ViewBinding子類(lèi)(如FragmentDelegateBinding)
         * FragmentDelegateBinding.bind(Fragment.requireView())
         */
        bindMethod.invoke(null,fragment.requireView()) as T
    }
}
/**
 * viewBinder 創(chuàng)建綁定類(lèi)對(duì)象
 */
class FragmentViewBindingProperttV1<in F:Fragment,out V: ViewBinding>(
    private val viewBinder:(F) ->V //給定一個(gè) Fragment（或其子類(lèi)），返回一個(gè)對(duì)應(yīng)的 ViewBinding 實(shí)例
):ReadOnlyProperty<F,V>{
    private var viewBinding:V? = null
    override fun getValue(thisRef: F, property: KProperty<*>): V {
        //viewBinding不為空說(shuō)明已經(jīng)綁定，直接返回
        viewBinding?.let {
            return it
        }
        //Fragment視圖的生命周期
        val lifecycle = thisRef.viewLifecycleOwner.lifecycle
        //實(shí)例化綁定類(lèi)對(duì)象
        val viewBinding = viewBinder(thisRef)
        if(lifecycle.currentState == Lifecycle.State.DESTROYED){
            Log.w(
                TAG, "Access to viewBinding after Lifecycle is destroyed or hasn't created yet. " +
                        "The instance of viewBinding will be not cached."
            )
        }else{
            lifecycle.addObserver(ClearOnDestroyLifecycleObserver())
            this.viewBinding = viewBinding
        }
        return viewBinding
    }
    fun clear(){
        viewBinding = null
    }
    private inner class ClearOnDestroyLifecycleObserver : LifecycleObserver{
        private val mainHandler = Handler(Looper.getMainLooper())
        fun onDestroy(owner:LifecycleOwner){
            owner.lifecycle.removeObserver(this)
            mainHandler.post {
                clear()
            }
        }
    }
}

class DelegateFragment : Fragment(R.layout.fragment_delegate) {
    private val binding : FragmentDelegateBinding by viewBindingV1()
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.tvName.text = "This is Hello World"
    }
}

inline fun <F:Fragment,V:ViewBinding> viewBindingV2(
    crossinline viewBinder:(View) -> V,//接受一個(gè)View，返回Binding實(shí)例
    crossinline viewProvider:(F) -> View = {
    fragment -> fragment.requireView() //這里的fragment就是F
    } //接受一個(gè)Fragment，返回它的View
) = FragmentViewBindingPropertyV2{ fragment:F ->
    viewBinder(viewProvider(fragment)) //FragmentDelegateBinding.bind(Fragment.requireView())
}//fragment它是 Kotlin 屬性委托機(jī)制在訪問(wèn) binding 屬性時(shí)自動(dòng)傳入的當(dāng)前 Fragment 實(shí)例
class FragmentViewBindingPropertyV2<in F:Fragment , out V: ViewBinding>(
    private val viewBinder:(F) -> V
):ReadOnlyProperty<F,V>{
    private var viewBinding: V? = null
    override fun getValue(thisRef: F, property: KProperty<*>): V {
        //viewBinding不為空說(shuō)明已經(jīng)綁定，直接返回
        viewBinding?.let {
            return it
        }
        //Fragment視圖的生命周期
        val lifecycle = thisRef.viewLifecycleOwner.lifecycle
        //實(shí)例化綁定類(lèi)對(duì)象
        val viewBinding = viewBinder(thisRef)
        if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
            Log.w(
                TAG, "Access to viewBinding after Lifecycle is destroyed or hasn't created yet. " +
                        "The instance of viewBinding will be not cached."
            )
        } else {
            lifecycle.addObserver(ClearOnDestroyLifecycleObserver())
            this.viewBinding = viewBinding
        }
        return viewBinding
    }
    fun clear() {
        viewBinding = null
    }
    private inner class ClearOnDestroyLifecycleObserver : LifecycleObserver {
        private val mainHandler = Handler(Looper.getMainLooper())
        fun onDestroy(owner: LifecycleOwner) {
            owner.lifecycle.removeObserver(this)
            mainHandler.post {
                clear()
            }
        }
    }
}

class DelegateFragment : Fragment(R.layout.fragment_delegate) {
    private val binding : FragmentDelegateBinding by viewBindingV2(FragmentDelegateBinding::bind)
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.tvName.text = "This is Hello World"
    }
}