Retrofit в Android: REST API интеграция для стабильной разработки

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

dependencies {
// Retrofit
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
// Gson конвертер
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
// OkHttp
implementation 'com.squareup.okhttp3:okhttp:4.9.1'
implementation 'com.squareup.okhttp3:logging-interceptor:4.9.1'
}

// Создаем интерцептор для логирования
val loggingInterceptor = HttpLoggingInterceptor().apply {
level = if (BuildConfig.DEBUG) 
HttpLoggingInterceptor.Level.BODY 
else 
HttpLoggingInterceptor.Level.NONE
}

// Настраиваем OkHttpClient
val okHttpClient = OkHttpClient.Builder()
.addInterceptor(loggingInterceptor)
.connectTimeout(15, TimeUnit.SECONDS)
.readTimeout(15, TimeUnit.SECONDS)
.writeTimeout(15, TimeUnit.SECONDS)
.build()

// Создаем экземпляр Retrofit
val retrofit = Retrofit.Builder()
.baseUrl("https://api.example.com/")
.client(okHttpClient)
.addConverterFactory(GsonConverterFactory.create())
.build()

// Создаем сервис API из интерфейса
val apiService = retrofit.create(ApiService::class.java)

// Создаем менеджер доверенных сертификатов
val trustManagerFactory = TrustManagerFactory.getInstance(
TrustManagerFactory.getDefaultAlgorithm()
)
trustManagerFactory.init(null as KeyStore?)
val trustManagers = trustManagerFactory.trustManagers

// Настраиваем SSL
val sslContext = SSLContext.getInstance("TLS")
sslContext.init(null, trustManagers, null)

// Добавляем в OkHttpClient
val okHttpClient = OkHttpClient.Builder()
.sslSocketFactory(sslContext.socketFactory, trustManagers[0] as X509TrustManager)
.hostnameVerifier { hostname, session -> true }
.build()

interface UserApiService {
@GET("users")
suspend fun getUsers(): Response<List<User>>

@GET("users/{id}")
suspend fun getUserById(@Path("id") userId: Int): Response<User>

@POST("users")
suspend fun createUser(@Body user: User): Response<User>

@PUT("users/{id}")
suspend fun updateUser(
@Path("id") userId: Int,
@Body user: User
): Response<User>

@DELETE("users/{id}")
suspend fun deleteUser(@Path("id") userId: Int): Response<Void>
}

@GET("products")
suspend fun searchProducts(
@Query("category") category: String,
@Query("min_price") minPrice: Double? = null,
@Query("max_price") maxPrice: Double? = null,
@Query("sort") sortOrder: String = "popularity",
@Query("page") page: Int = 1,
@Query("per_page") perPage: Int = 20
): Response<PagedResponse<Product>>

@Multipart
@POST("upload")
suspend fun uploadProfilePicture(
@Part("user_id") userId: RequestBody,
@Part profileImage: MultipartBody.Part
): Response<UploadResult>

// Пример использования
fun createUploadRequest(userId: String, imageFile: File) {
val userIdPart = RequestBody.create(MediaType.parse("text/plain"), userId)

val requestFile = RequestBody.create(
MediaType.parse(getContentResolver().getType(imageUri)),
imageFile
)

val imagePart = MultipartBody.Part.createFormData(
"profile_image", 
imageFile.name, 
requestFile
)

val response = apiService.uploadProfilePicture(userIdPart, imagePart)
// Обработка ответа
}

interface EcommerceApiService {
@GET("products/{productId}")
fun getProductDetails(
@Path("productId") productId: String,
@Query("include") includeSections: List<String>,
@Header("Accept-Language") language: String = "en"
): Call<ProductDetails>

@FormUrlEncoded
@POST("auth/login")
fun login(
@Field("email") email: String,
@Field("password") password: String,
@Field("device_id") deviceId: String
): Call<AuthResponse>

@GET
fun downloadFile(@Url fileUrl: String): Call<ResponseBody>

@Headers("Cache-Control: max-age=640000")
@GET("config")
fun getConfiguration(): Call<AppConfig>

@PATCH("cart/{cartId}")
fun updateCartItem(
@Path("cartId") cartId: String,
@Body updateRequest: CartItemUpdate
): Call<Cart>

@HTTP(method = "DELETE", path = "bookmarks", hasBody = true)
fun removeBookmarks(@Body bookmarkIds: List<String>): Call<Void>
}

apiService.getUserProfile(userId).enqueue(object : Callback<UserProfile> {
override fun onResponse(call: Call<UserProfile>, response: Response<UserProfile>) {
if (response.isSuccessful) {
val userProfile = response.body()
// Обновляем UI с полученными данными
updateUserInterface(userProfile)
} else {
// Обрабатываем ошибку от сервера
handleApiError(response.code(), response.errorBody())
}
}

override fun onFailure(call: Call<UserProfile>, t: Throwable) {
// Обрабатываем сетевую ошибку
handleNetworkError(t)
}
})

// В ViewModel или другом компоненте с CoroutineScope
viewModelScope.launch {
try {
val response = apiService.getUserProfile(userId)
if (response.isSuccessful) {
val userProfile = response.body()
// Обрабатываем успешный ответ
_userProfileLiveData.value = userProfile
} else {
// Обрабатываем ошибку API
_errorState.value = parseErrorResponse(response.errorBody())
}
} catch (e: IOException) {
// Обрабатываем сетевую ошибку
_errorState.value = NetworkError("Проверьте подключение к интернету")
} catch (e: Exception) {
// Обрабатываем прочие ошибки
_errorState.value = UnknownError("Произошла неизвестная ошибка")
}
}

sealed class Result<out T> {
data class Success<T>(val data: T) : Result<T>()
data class Error(val exception: Throwable) : Result<Nothing>()
object Loading : Result<Nothing>()
}

// Репозиторий с обработкой ошибок
class UserRepository(private val apiService: UserApiService) {
suspend fun getUserProfile(userId: String): Result<UserProfile> {
return try {
val response = apiService.getUserProfile(userId)
if (response.isSuccessful) {
Result.Success(response.body()!!)
} else {
Result.Error(HttpException(response))
}
} catch (e: Exception) {
Result.Error(e)
}
}
}

// Использование в ViewModel
viewModelScope.launch {
_profileState.value = Result.Loading
when (val result = userRepository.getUserProfile(userId)) {
is Result.Success -> {
_profileState.value = Result.Success(result.data)
}
is Result.Error -> {
_profileState.value = Result.Error(result.exception)
}
Result.Loading -> { /* уже установлено */ }
}
}

// Создаем Job для отслеживания и отмены запроса
val fetchJob = viewModelScope.launch {
try {
val response = apiService.getLargeDataSet()
// Обработка ответа
} catch (e: CancellationException) {
// Запрос был отменен, ничего делать не нужно
} catch (e: Exception) {
// Обработка других ошибок
}
}

// Отмена запроса при необходимости
fun cancelRequest() {
fetchJob.cancel()
}

// Автоматическая отмена при уничтожении ViewModel
override fun onCleared() {
super.onCleared()
viewModelScope.cancel() // Отменяет все запросы
}

class AuthInterceptor(
private val tokenManager: TokenManager,
private val authService: AuthService
) : Interceptor {

@Synchronized
override fun intercept(chain: Interceptor.Chain): Response {
// Добавляем текущий токен
val originalRequest = chain.request().newBuilder()
.header("Authorization", "Bearer ${tokenManager.getAccessToken()}")
.build()

// Делаем запрос
val response = chain.proceed(originalRequest)

// Если токен истек (код 401), пробуем обновить
if (response.code() == 401) {
val newToken = refreshToken()
if (newToken != null) {
// Повторяем оригинальный запрос с новым токеном
val newRequest = originalRequest.newBuilder()
.header("Authorization", "Bearer $newToken")
.build()

response.close()
return chain.proceed(newRequest)
}
}

return response
}

private fun refreshToken(): String? {
// Синхронный запрос для обновления токена
val refreshTokenResponse = authService.refreshToken(
tokenManager.getRefreshToken()
).execute()

return if (refreshTokenResponse.isSuccessful) {
val tokens = refreshTokenResponse.body()!!
tokenManager.saveTokens(tokens.accessToken, tokens.refreshToken)
tokens.accessToken
} else {
// Перенаправление на экран авторизации
null
}
}
}

// Настройка кэширования в OkHttpClient
val cacheSize = 10 * 1024 * 1024 // 10 МБ
val cache = Cache(File(context.cacheDir, "http_cache"), cacheSize.toLong())

val okHttpClient = OkHttpClient.Builder()
.cache(cache)
.addNetworkInterceptor { chain ->
// Кэшируем все успешные GET-запросы на 1 час
val response = chain.proceed(chain.request())
if (chain.request().method() == "GET" && response.code() == 200) {
response.newBuilder()
.header("Cache-Control", "public, max-age=3600")
.build()
} else {
response
}
}
.addInterceptor { chain ->
var request = chain.request()

// В режиме оффлайн пытаемся использовать кэш
if (!isNetworkAvailable()) {
request = request.newBuilder()
.header("Cache-Control", "public, only-if-cached, max-stale=2419200")
.build()
}

chain.proceed(request)
}
.build()

class DynamicBaseUrlInterceptor(
private val configProvider: ConfigProvider
) : Interceptor {

override fun intercept(chain: Interceptor.Chain): Response {
val originalRequest = chain.request()

// Получаем текущий тенант из провайдера конфигурации
val currentTenant = configProvider.getCurrentTenant()
val baseUrl = getTenantBaseUrl(currentTenant)

// Создаем новый URL, заменяя хост и базовый путь
val newUrl = originalRequest.url().newBuilder()
.scheme("https")
.host(baseUrl.host())
.port(baseUrl.port())
.build()

val newRequest = originalRequest.newBuilder()
.url(newUrl)
.build()

return chain.proceed(newRequest)
}

private fun getTenantBaseUrl(tenant: String): HttpUrl {
return when (tenant) {
"tenant1" -> HttpUrl.parse("https://api.tenant1.com")!!
"tenant2" -> HttpUrl.parse("https://api.tenant2.com")!!
else -> HttpUrl.parse("https://api.default.com")!!
}
}
}

// Параллельное выполнение независимых запросов
suspend fun loadDashboardData(): DashboardData = coroutineScope {
val userProfileDeferred = async { apiService.getUserProfile() }
val notificationsDeferred = async { apiService.getNotifications() }
val recentOrdersDeferred = async { apiService.getRecentOrders(5) }

// Дожидаемся выполнения всех запросов
val userProfile = userProfileDeferred.await()
val notifications = notificationsDeferred.await()
val recentOrders = recentOrdersDeferred.await()

// Комбинируем результаты
DashboardData(userProfile, notifications, recentOrders)
}

// Последовательное выполнение зависимых запросов
suspend fun processOrder(productId: String, quantity: Int): OrderResult {
// 1. Проверяем наличие товара
val stockCheck = apiService.checkStock(productId, quantity)
if (!stockCheck.available) {
return OrderResult.OutOfStock(stockCheck.availableQuantity)
}

// 2. Добавляем в корзину
val cartResponse = apiService.addToCart(productId, quantity)

// 3. Создаем заказ
val orderResponse = apiService.createOrder(cartResponse.cartId)

// 4. Выполняем оплату
return when (val paymentResult = apiService.processPayment(orderResponse.orderId)) {
is PaymentSuccessful -> OrderResult.Success(orderResponse.orderId)
is PaymentFailed -> OrderResult.PaymentFailed(paymentResult.reason)
}
}

interface GraphQLService {
@POST("graphql")
suspend fun performQuery(
@Body query: GraphQLQuery
): Response<GraphQLResponse>
}

// Класс запроса GraphQL
data class GraphQLQuery(
val query: String,
val variables: Map<String, Any> = emptyMap()
)

// Класс ответа
data class GraphQLResponse(
val data: Map<String, Any>?,
val errors: List<GraphQLError>?
)

// Пример использования
val query = """
query GetUserAndOrders($userId: ID!) {
user(id: $userId) {
id
name
email
orders {
id
date
total
}
}
}
"""

val variables = mapOf("userId" to "user123")
val graphQLQuery = GraphQLQuery(query, variables)

viewModelScope.launch {
val response = graphQLService.performQuery(graphQLQuery)
if (response.isSuccessful) {
val graphQLResponse = response.body()!!
if (graphQLResponse.errors == null) {
// Извлекаем данные из ответа
val userData = graphQLResponse.data?.get("user") as Map<String, Any>
// Обрабатываем данные
} else {
// Обрабатываем ошибки GraphQL
}
} else {
// Обрабатываем HTTP-ошибки
}
}