Połącz z siecią

Aby wykonywać operacje sieciowe w aplikacji, plik manifestu musi zawierać 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 bezpieczeństwo danych i informacji w aplikacji podczas przesyłania ich przez sieć. Aby to zrobić, postępuj zgodnie z tymi sprawdzonymi metodami dotyczącymi bezpieczeństwa sieci:

  • Ogranicz ilość przesyłanych przez sieć danych użytkowników, które są wrażliwe lub mają charakter osobisty.
  • Wysyłaj cały ruch sieciowy z aplikacji przez SSL.
  • Rozważ utworzenie konfiguracji zabezpieczeń sieci, która umożliwia aplikacji ufanie niestandardowym urzędom certyfikacji lub ograniczenie zestawu urzędów certyfikacji systemu, którym ufa w przypadku bezpiecznej komunikacji.

Więcej informacji o stosowaniu zasad bezpiecznej sieci znajdziesz w wskazówkach dotyczących 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 Android zawiera klienta HttpsURLConnection, który obsługuje TLS, przesyłanie strumieniowe i pobieranie, konfigurowalne limity czasu, IPv6 i pule 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 serializacja treści żądań i deserializacja treści odpowiedzi.

  • Retrofit: bezpieczny pod względem typów 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 w języku Kotlin 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łego tekstu, jak i w trybie DNS-over-TLS. Interfejs DnsResolver API zapewnia ogólne, asynchroniczne rozwiązywanie problemów, które umożliwia wyszukiwanie rekordów SRV, NAPTR i innych typów. Analiza odpowiedzi należy do aplikacji.

Na urządzeniach z Androidem 9 (poziom interfejsu API 28) lub starszym program rozpoznawania nazw DNS platformy obsługuje tylko rekordy A i AAAA. 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 zobacz android_res_nsend.

Hermetyzacja 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ą biblioteki 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ą obejmować operacje sieciowe i udostępniać ich wyniki. Ta hermetyzacja zapewnia, że komponenty wywołujące repozytorium nie muszą wiedzieć, jak dane są przechowywane. Wszelkie przyszłe zmiany sposobu przechowywania danych są również odizolowane w klasie repozytorium. Może to być na przykład zmiana zdalna, taka jak aktualizacja punktów końcowych interfejsu API, lub możesz chcieć wdrożyć 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 interfejsu użytkownika, który nie odpowiada, nie wykonuj operacji sieciowych w głównym wątku. Domyślnie Android wymaga wykonywania operacji sieciowych w wątku innym niż główny wątek interfejsu. 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 w rzeczywistości wywoływana. Wywołujący funkcję UserRepository musi zaimplementować wątkowość za pomocą korutyn lub funkcji enqueue(). Więcej informacji znajdziesz w samouczku Pobieranie danych z internetu, w którym pokazujemy, jak zaimplementować wielowątkowość za pomocą korutyn w Kotlinie.

Przetrwanie zmian konfiguracji

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

Możesz użyć ViewModel, aby dane przetrwały zmiany konfiguracji. Komponent ViewModel służy do przechowywania danych związanych z interfejsem i zarządzania nimi w sposób uwzględniający cykl życia. Korzystając z podanego wyżej UserRepository, ViewModel może wysyłać niezbędne żądania sieciowe i przekazywać wyniki do fragmentu 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
            }
        });
    }
}

Aby dowiedzieć się więcej na ten temat, zapoznaj się z tymi przewodnikami: