Android Kotlin SharedPreferences

Usage:

var value:String by Preference("name","Onlly Archibald")
        println("now value is $value")

        value = "Mark"
        println("after value is $value")

        var person:Person by Preference("person",Person(name = "Onlly",age = 25))
        println("now person is $person")

        person = Person(name = "Onlly",age = 26)
        println("after person is $person")

data class Person(private val name:String,private val age:Int):Serializable

OUTPUT:

Preference.kt

class Preference<T>(private val name:String,private val default:T){
    companion object{
        private val pref: SharedPreferences by lazy{
            OCOMPayApplicationLike.INSTANCE.getSharedPreferences("test", Context.MODE_PRIVATE)
        }
    }

    operator fun getValue(thisRef:Any?,property:KProperty<*>):T = with(pref){
        val res:Any = when(default){
            is Long -> getLong(name,default)
            is String -> getString(name, default)
            is Int -> getInt(name, default)
            is Boolean -> getBoolean(name, default)
            is Float -> getFloat(name, default)
            else -> deSerialization(getString(name,serialize(default)))
        }
        return res as T
    }

    operator fun setValue(thisRef:Any?,property: KProperty<*>,value:T) = with(pref.edit()){
        when(value){
            is Long -> putLong(name,value)
            is Float -> putFloat(name,value)
            is Boolean -> putBoolean(name,value)
            is Int -> putInt(name,value)
            is String -> putString(name,value)
            else -> putString(name,serialize(value))
        }.commit()
    }

    @Throws(IOException::class)
    private fun<A> serialize(obj: A): String {
        val byteArrayOutputStream = ByteArrayOutputStream()
        val objectOutputStream = ObjectOutputStream(
            byteArrayOutputStream)
        objectOutputStream.writeObject(obj)
        var serStr = byteArrayOutputStream.toString("ISO-8859-1")
        serStr = java.net.URLEncoder.encode(serStr, "UTF-8")
        objectOutputStream.close()
        byteArrayOutputStream.close()
        return serStr
    }

    @Suppress("UNCHECKED_CAST")
    @Throws(IOException::class, ClassNotFoundException::class)
    private fun<A> deSerialization(str: String?): A {
        val redStr = java.net.URLDecoder.decode(str, "UTF-8")
        val byteArrayInputStream = ByteArrayInputStream(
            redStr.toByteArray(charset("ISO-8859-1")))
        val objectInputStream = ObjectInputStream(
            byteArrayInputStream)
        val obj = objectInputStream.readObject() as A
        objectInputStream.close()
        byteArrayInputStream.close()
        return obj
    }
}