Połącz z siecią

Aby wykonywać operacje sieciowe w aplikacji, musisz dodać do manifestu te uprawnienia:

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

Sprawdzone metody bezpiecznej komunikacji sieciowej

Zanim dodasz do aplikacji funkcje sieciowe, musisz zadbać o to, aby dane i informacje w aplikacji były bezpieczne podczas przesyłania ich przez sieć. Aby to zrobić, postępuj zgodnie z tymi sprawdzonymi metodami dotyczącymi bezpieczeństwa sieciowego:

Więcej informacji o tym, jak stosować zasady bezpiecznej komunikacji sieciowej, znajdziesz w sekcji Wskazówki dotyczące bezpieczeństwa sieci.

Wybieranie klienta HTTP

Większość aplikacji połączonych z siecią używa protokołu HTTP do wysyłania i odbierania danych. Platforma Androida zawiera klienta HttpsURLConnection, który obsługuje TLS, przesyłanie strumieniowe i pobieranie, konfigurowalne limity czasu, IPv6 i pulę połączeń.

Dostępne są też biblioteki innych firm, które oferują interfejsy API wyższego poziomu do operacji sieciowych. Obsługują one różne przydatne funkcje, takie jak the serializacja treści żądań i deserializacja treści odpowiedzi.

  • Retrofit: bezpieczny typowo klient HTTP dla JVM od Square, oparty na OkHttp. Retrofit umożliwia deklaratywne tworzenie interfejsu klienta i obsługuje kilka bibliotek serializacji.
  • Ktor: klient HTTP od JetBrains, stworzony w całości dla Kotlina i oparty na korutynach. Ktor obsługuje różne silniki, serializatory i platformy.

Rozwiązywanie zapytań DNS

Urządzenia z Androidem 10 (poziom interfejsu API 29) i nowszym mają wbudowaną obsługę specjalistycznych wyszukiwań DNS zarówno w trybie zwykłym, jak i w trybie DNS-over-TLS. Interfejs DnsResolver API zapewnia ogólne, asynchroniczne rozpoznawanie nazw, które umożliwia wyszukiwanie rekordów SRV, NAPTR i innych typów. Parsowanie odpowiedzi należy do aplikacji.

Na urządzeniach z Androidem 9 (poziom interfejsu API 28) i starszym resolver DNS platformy obsługuje tylko A i AAAA rekordy. Umożliwia to wyszukiwanie adresów IP powiązanych z nazwą, ale nie obsługuje innych typów rekordów.

W przypadku aplikacji opartych na NDK zapoznaj się z dokumentacją android_res_nsend.

Hermetyzowanie operacji sieciowych za pomocą repozytorium

Aby uprościć proces wykonywania operacji sieciowych i zmniejszyć duplikowanie kodu w różnych częściach aplikacji, możesz użyć wzorca projektowego repozytorium. Repozytorium to klasa, która obsługuje operacje na danych i zapewnia czystą abstrakcję interfejsu API nad określonymi danymi lub zasobami.

Za pomocą Retrofit możesz zadeklarować interfejs, który określa metodę HTTP, adres URL, argumenty i typ odpowiedzi dla operacji sieciowych, jak w tym przykładzie:

Kotlin

interface UserService {
    @GET("/users/{id}")
    suspend fun getUser(@Path("id") id: String): User
}

Java

public interface UserService {
    @GET("/user/{id}")
    Call<User> getUserById(@Path("id") String id);
}

W klasie repozytorium funkcje mogą hermetyzować operacje sieciowe i udostępniać ich wyniki. Ta hermetyzacja zapewnia, że komponenty wywołujące repozytorium nie muszą wiedzieć, jak są przechowywane dane. Wszelkie przyszłe zmiany w sposobie przechowywania danych są również izolowane w klasie repozytorium. Możesz na przykład wprowadzić zmianę zdalną, taką jak aktualizacja punktów końcowych interfejsu API, lub zaimplementować lokalne buforowanie.

Kotlin

class UserRepository constructor(
    private val userService: UserService
) {
    suspend fun getUserById(id: String): User {
        return userService.getUser(id)
    }
}

Java

class UserRepository {
    private UserService userService;

    public UserRepository(
            UserService userService
    ) {
        this.userService = userService;
    }

    public Call<User> getUserById(String id) {
        return userService.getUser(id);
    }
}

Aby uniknąć tworzenia nieodpowiadającego interfejsu, nie wykonuj operacji sieciowych w wątku głównym. Domyślnie Android wymaga wykonywania operacji sieciowych w wątku innym niż główny wątek UI. Jeśli spróbujesz wykonać operacje sieciowe w wątku głównym, zostanie zgłoszony wyjątek NetworkOnMainThreadException.

W poprzednim przykładzie kodu operacja sieciowa nie jest faktycznie wywoływana. Wywołujący UserRepository musi zaimplementować obsługę wątków za pomocą korutyn lub funkcji enqueue(). Więcej informacji znajdziesz w ćwiczeniu z programowania Pobieranie danych z internetu, które pokazuje, jak zaimplementować obsługę wątków za pomocą korutyn Kotlin.

Przetrwanie zmian konfiguracji

Gdy nastąpi zmiana konfiguracji, np. obrócenie ekranu, fragment lub aktywność zostaną zniszczone i ponownie utworzone. Wszystkie dane, które nie zostały zapisane w stanie instancji fragmentu aktywności, który może przechowywać tylko niewielkie ilości danych, zostaną utracone. W takim przypadku może być konieczne ponowne wysłanie żądań sieciowych.

Aby dane przetrwały zmiany konfiguracji, możesz użyć ViewModel do let. Komponent ViewModel jest przeznaczony do przechowywania danych związanych z interfejsem i zarządzania nimi w sposób uwzględniający cykl życia. Korzystając z poprzedniego UserRepository, ViewModel może wysyłać niezbędne żądania sieciowe i udostępniać wynik fragmentowi lub aktywności za pomocą LiveData:

Kotlin

class MainViewModel constructor(
    savedStateHandle: SavedStateHandle,
    userRepository: UserRepository
) : ViewModel() {
    private val userId: String = savedStateHandle["uid"] ?:
        throw IllegalArgumentException("Missing user ID")

    private val _user = MutableLiveData<User>()
    val user = _user as LiveData<User>

    init {
        viewModelScope.launch {
            try {
                // Calling the repository is safe as it moves execution off
                // the main thread
                val user = userRepository.getUserById(userId)
                _user.value = user
            } catch (error: Exception) {
                // Show error message to user
            }

        }
    }
}

Java

class MainViewModel extends ViewModel {

    private final MutableLiveData<User> _user = new MutableLiveData<>();
    LiveData<User> user = (LiveData<User>) _user;

    public MainViewModel(
            SavedStateHandle savedStateHandle,
            UserRepository userRepository
    ) {
        String userId = savedStateHandle.get("uid");
        Call<User> userCall = userRepository.getUserById(userId);
        userCall.enqueue(new Callback<User>() {
            @Override
            public void onResponse(Call<User> call, Response<User> response) {
                if (response.isSuccessful()) {
                    _user.setValue(response.body());
                }
            }

            @Override
            public void onFailure(Call<User> call, Throwable t) {
                // Show error message to user
            }
        });
    }
}

Więcej informacji na ten temat znajdziesz w tych powiązanych przewodnikach: