gRPC on Android

Copy code// user.proto
syntax = "proto3";
package com.example;
option java_multiple_files = true;
option java_package = "com.example.grpc";

message UserRequest {
  string user_id = 1;
}

message UserResponse {
  string id = 1;
  string name = 2;
  string email = 3;
}

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse);
  rpc StreamUserUpdates (UserRequest) returns (stream UserResponse);
}

Copy code// build.gradle.kts (module)
plugins {
    id("com.google.protobuf") version "0.9.4"
}

dependencies {
    implementation("io.grpc:grpc-kotlin-stub:1.4.1")
    implementation("io.grpc:grpc-okhttp:1.62.2")       // transport for Android
    implementation("com.google.protobuf:protobuf-kotlin:3.25.3")
}

protobuf {
    protoc { artifact = "com.google.protobuf:protoc:3.25.3" }
    plugins {
        create("grpc") { artifact = "io.grpc:protoc-gen-grpc-java:1.62.2" }
        create("grpckt") { artifact = "io.grpc:protoc-gen-grpc-kotlin:1.4.1:jdk8@jar" }
    }
    generateProtoTasks {
        all().forEach { task ->
            task.plugins {
                create("grpc")
                create("grpckt")
            }
            task.builtins { create("kotlin") }
        }
    }
}

Copy codeclass GrpcUserRepository(private val host: String, private val port: Int) {

    private val channel: ManagedChannel = ManagedChannelBuilder
        .forAddress(host, port)
        .usePlaintext()     // ⚠️ TLS only in production; use .useTransportSecurity()
        .build()

    private val stub = UserServiceGrpcKt.UserServiceCoroutineStub(channel)

    // Unary call — one request, one response
    suspend fun getUser(userId: String): UserResponse {
        val request = userRequest { this.userId = userId }
        return stub.getUser(request)
    }

    // Server streaming — one request, stream of responses
    fun streamUserUpdates(userId: String): Flow<UserResponse> {
        val request = userRequest { this.userId = userId }
        return stub.streamUserUpdates(request)
    }

    fun shutdown() = channel.shutdown().awaitTermination(5, TimeUnit.SECONDS)
}

Copy codeclass AuthInterceptor(private val tokenProvider: () -> String) : ClientInterceptor {
    override fun <Req, Resp> interceptCall(
        method: MethodDescriptor<Req, Resp>,
        callOptions: CallOptions,
        next: Channel
    ): ClientCall<Req, Resp> {
        return object : ForwardingClientCall.SimpleForwardingClientCall<Req, Resp>(
            next.newCall(method, callOptions)
        ) {
            override fun start(responseListener: Listener<Resp>, headers: Metadata) {
                headers.put(
                    Metadata.Key.of("authorization", Metadata.ASCII_STRING_MARSHALLER),
                    "Bearer ${tokenProvider()}"
                )
                super.start(responseListener, headers)
            }
        }
    }
}

// Apply to channel
val channel = ManagedChannelBuilder
    .forAddress(host, port)
    .intercept(AuthInterceptor { tokenStore.getToken() })
    .build()

Copy codetry {
    val user = stub.getUser(request)
} catch (e: StatusException) {
    when (e.status.code) {
        Status.Code.NOT_FOUND -> showError("User not found")
        Status.Code.UNAUTHENTICATED -> refreshTokenAndRetry()
        Status.Code.UNAVAILABLE -> showOfflineError()
        else -> showGenericError(e.message)
    }
}