Retrofit und REST-APIs

Was ist Retrofit?

Abhängigkeiten hinzufügen

// app/build.gradle
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.11.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.11.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.12.0'
}

// AndroidManifest.xml — add internet permission:
// <uses-permission android:name="android.permission.INTERNET" />

API-Interface definieren

import retrofit2.http.*

data class Post(val id: Int, val title: String, val body: String, val userId: Int)

interface ApiService {

    @GET("posts")
    suspend fun getPosts(): List<Post>

    @GET("posts/{id}")
    suspend fun getPost(@Path("id") id: Int): Post

    @POST("posts")
    suspend fun createPost(@Body post: Post): Post

    @GET("posts")
    suspend fun getPostsByUser(@Query("userId") userId: Int): List<Post>
}

Retrofit-Instanz erstellen

import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory

object RetrofitClient {
    private const val BASE_URL = "https://jsonplaceholder.typicode.com/"

    val api: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

GET-Anfrage ausführen

class PostRepository {
    private val api = RetrofitClient.api

    suspend fun getPosts(): List<Post> {
        return api.getPosts()  // Retrofit handles threading for you
    }

    suspend fun getPost(id: Int): Post {
        return api.getPost(id)
    }
}

// In ViewModel:
fun loadPosts() {
    viewModelScope.launch {
        try {
            val posts = withContext(Dispatchers.IO) {
                repository.getPosts()
            }
            _posts.value = posts
        } catch (e: Exception) {
            _error.value = "Network error: ${e.message}"
        }
    }
}

Gson-JSON-Zuordnung

import com.google.gson.annotations.SerializedName

data class User(
    val id: Int,
    val name: String,
    val email: String,
    @SerializedName("phone_number")  // JSON key is 'phone_number'
    val phoneNumber: String,
    @SerializedName("created_at")
    val createdAt: String
)

POST-Anfrage mit Body

// API interface:
@POST("users")
suspend fun createUser(@Body user: User): User

// In Repository:
suspend fun createUser(name: String, email: String): User {
    val newUser = User(id = 0, name = name, email = email, phoneNumber = "", createdAt = "")
    return api.createUser(newUser)
}

// In ViewModel:
fun registerUser(name: String, email: String) {
    viewModelScope.launch {
        val user = withContext(Dispatchers.IO) {
            repo.createUser(name, email)
        }
        _registeredUser.value = user
    }
}

Header & Authentifizierung

import okhttp3.OkHttpClient
import okhttp3.Interceptor

val authClient = OkHttpClient.Builder()
    .addInterceptor { chain ->
        val request = chain.request().newBuilder()
            .addHeader("Authorization", "Bearer $token")
            .addHeader("Accept", "application/json")
            .build()
        chain.proceed(request)
    }
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl(BASE_URL)
    .client(authClient)  // use our authenticated client
    .addConverterFactory(GsonConverterFactory.create())
    .build()

HTTP-Fehler behandeln

Schnelltest

Zusammenfassung: Retrofit & APIs