package com.example.aidl;
// Calculator.aidl
interface Calculator {
    int sum(int first, int second);
}

class BoundService : Service() {
    override fun onBind(intent: Intent?): IBinder? {
        return object : Calculator.Stub() {
            override fun sum(first: Int, second: Int): Int {
                return first + second // реализация метода
            }
        }
    }
}

<service
    android:name=".BoundService"
    android:process=":remote"
    android:exported="true">
    <intent-filter>
        <action android:name="com.example.aidl.REMOTE_CONNECTION" />
    </intent-filter>
</service>

private fun createExplicitIntent(): Intent {
    val intent = Intent("com.example.aidl.REMOTE_CONNECTION")
    val services = packageManager.queryIntentServices(intent, 0)
    if (services.isEmpty()) {
        throw IllegalStateException("Приложение-сервер не установлено")
    }
    return Intent(intent).apply {
        val resolveInfo = services[0]
        val packageName = resolveInfo.serviceInfo.packageName
        val className = resolveInfo.serviceInfo.name
        component = ComponentName(packageName, className)
    }
}

<queries>
    <intent>
        <action android:name="com.example.aidl.REMOTE_CONNECTION" />
    </intent>
</queries>

private var calculator: Calculator? = null
private val serviceConnection = object : ServiceConnection {
    override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
        calculator = Calculator.Stub.asInterface(service)
    }
    override fun onServiceDisconnected(name: ComponentName?) {
        calculator = null
    }
}
override fun onStart() {
    super.onStart()
    bindService(createExplicitIntent(), serviceConnection, Context.BIND_AUTO_CREATE)
}
override fun onStop() {
    super.onStop()
    unbindService(serviceConnection)
}

@Parcelize
data class Sum(val sum: Int) : Parcelable

package com.example.aidl;
import com.example.aidl.Sum;
// Calculator.aidl
interface Calculator {
    Sum sum(int first, int second);
}

package com.example.aidl;
import com.example.aidl.Sum;
// AsyncCallback.aidl
interface AsyncCallback {
    void onSuccess(in Sum sum);
}

// AidlExample.aidl
interface AidlExample {
    void fillArray(in String[] array);
}

package com.example.aidl;
import com.example.aidl.AsyncCallback;
// Calculator.aidl
interface Calculator {
    void sum(int first, int second, AsyncCallback callback);
}

package com.example.aidl;
import com.example.aidl.AsyncCallback;
// Calculator.aidl
interface Calculator {
    // P.S слово oneway применимо только к void-методам
    oneway void sum(int first, int second, AsyncCallback callback);
}

// BoundService.kt
override fun sum(first: Int, second: Int, callback: AsyncCallback?) {
    try {
        val sum = Sum(first + second)
        Thread.sleep(2000) // делаем что-то тяжелое
        callback?.onSuccess(sum)
    } catch (e: RemoteException) {
        Log.e("BoundService", e.message, e)
    }
}

private val appUpdateReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        if (intent?.data?.schemeSpecificPart == "com.example.appserver") {
            unregisterReceiver(this)
            reconnect()
        }
    }
}
private fun reconnect() {
    bindService(createExplicitIntent(), serviceConnection, Context.BIND_AUTO_CREATE)
    registerReceiver(appUpdateReceiver, IntentFilter().apply {
        addAction(Intent.ACTION_PACKAGE_REPLACED)
        addDataScheme("package")
    })
}

package com.example.aidl;
import com.example.aidl.Sum;
import java.lang.RuntimeException;
// AsyncCallback.aidl
interface AsyncCallback {
    void onSuccess(in Sum sum);
    void onError(in RuntimeException exception);
}

@Parcelize
class ExceptionHolder(val exception: RuntimeException): Parcelable

package com.example.aidl;
import com.example.aidl.ExceptionHolder;
import com.example.aidl.Sum;
// AsyncCallback.aidl
interface AsyncCallback {
    void onSuccess(in Sum sum);
    void onError(in ExceptionHolder exception);
}

@Parcelize
class AidlException(
    private val errorMessage: String?,
    private val errorCode: Int = RUNTIME_EXCEPTION
) : Parcelable {
    companion object {
        const val RUNTIME_EXCEPTION = 1000
        const val ARITHMETIC_EXCEPTION = 1001
        // TODO другие коды ошибок...
    }
    // конвертация на стороне клиента
    fun toException(): Exception {
        return when (errorCode) {
            RUNTIME_EXCEPTION -> RuntimeException(errorMessage)
            ARITHMETIC_EXCEPTION -> ArithmeticException(errorMessage)
            else -> RuntimeException(errorMessage)
        }
    }
}

package com.example.aidl;
import com.example.aidl.AidlException;
import com.example.aidl.Sum;
// AsyncCallback.aidl
interface AsyncCallback {
    void onSuccess(in Sum sum);
    void onError(in AidlException aidlException);
}

override fun sum(first: Int, second: Int, callback: AsyncCallback?) {
    try {
        val sum = Sum(first + second)
        Thread.sleep(2000) // делаем что-то тяжелое
        throw ArithmeticException("Unable to calculate the result") // не получилось :(
        callback?.onSuccess(sum)
    } catch (e: Throwable) {
        Log.e("BoundService", e.message, e)
        if (e is ArithmeticException) {
            val aidlException = AidlException(e.message, AidlException.ARITHMETIC_EXCEPTION)
            callback?.onError(aidlException)
        }
    }
}

calculator?.sum(2, 2, object : AsyncCallback.Stub() {
    override fun onSuccess(sum: Sum?) {
        Toast.makeText(this@MainActivity, sum.toString(), Toast.LENGTH_SHORT).show()
    }
    override fun onError(aidlException: AidlException?) {
        val exception = aidlException?.toException()
        Toast.makeText(this@MainActivity, exception?.message, Toast.LENGTH_SHORT).show()
    }
})

@Parcelize
data class AidlResult<T : Parcelable>(val data: T) : Parcelable

package com.example.aidl;
// опять импорты вручную менять! >:(
import com.example.aidl.AidlException;
import com.example.aidl.AidlResult;
// AsyncCallback.aidl
interface AsyncCallback {
    void onSuccess(in AidlResult aidlResult);
    void onError(in AidlException aidlException);
}

override fun sum(first: Int, second: Int, callback: AsyncCallback?) {
    try {
        val sum = Sum(first + second)
        val aidlResult = AidlResult(sum)
        Thread.sleep(2000) // делаем что-то тяжелое
        callback?.onSuccess(aidlResult)
    } catch (e: Throwable) {
        // ...
    }
}

calculator?.sum(2, 2, object : AsyncCallback.Stub() {
    override fun onSuccess(aidlResult: AidlResult<*>?) {
        val sum = aidlResult?.data as? Sum
        Toast.makeText(this@MainActivity, sum.toString(), Toast.LENGTH_SHORT).show()
    }
    override fun onError(aidlException: AidlException?) {
        val exception = aidlException?.toException()
        Toast.makeText(this@MainActivity, exception?.message, Toast.LENGTH_SHORT).show()
    }
})

/**
* https://youtrack.jetbrains.com/issue/KT-25807
*/
data class AidlResult<T : Parcelable>(
    private var data: T?,
    private var classType: Class<T>?
) : Parcelable {
    @Suppress("UNCHECKED_CAST")
    constructor(parcel: Parcel) : this(null, null) {
        classType = parcel.readSerializable() as? Class<T>
        data = parcel.readParcelable(classType?.classLoader) as? T
    }
    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeSerializable(classType)
        parcel.writeParcelable(data, flags)
    }
    override fun describeContents(): Int = 0
    companion object CREATOR : Parcelable.Creator<AidlResult<out Parcelable>> {
        override fun createFromParcel(parcel: Parcel): AidlResult<out Parcelable> {
            return AidlResult(parcel)
        }
        override fun newArray(size: Int): Array<AidlResult<out Parcelable>?> {
            return arrayOfNulls(size)
        }
    }
}