התחברות לרשת

כדי לבצע פעולות רשת באפליקציה, המניפסט צריך לכלול את ההרשאות הבאות:

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

שיטות מומלצות לתקשורת מאובטחת ברשת

לפני שמוסיפים לאפליקציה פונקציונליות של רשתות, צריך לוודא שהנתונים והמידע באפליקציה יישארו בטוחים במהלך ההעברה ברשת. כדי לעשות זאת, פועלים לפי השיטות המומלצות הבאות לאבטחת הרשת:

• כדאי לצמצם את כמות נתוני המשתמשים הרגישים או האישיים שאתם מעבירים ברשת.
• שולחים את כל תעבורת הנתונים מהאפליקציה דרך SSL.
• מומלץ ליצור הגדרת אבטחת רשת, שמאפשרת לאפליקציה לבטוח ברשות אישורים (CA) בהתאמה אישית או להגביל את קבוצת רשויות ה-CA של המערכת שהיא סומכת עליהן לתקשורת מאובטחת.

מידע נוסף על יישום עקרונות של רשתות מאובטחות זמין בטיפים לאבטחת רשתות.

בחירת לקוח HTTP

רוב האפליקציות שמחוברות לרשת משתמשות ב-HTTP כדי לשלוח ולקבל נתונים. פלטפורמת Android כוללת את הלקוח HttpsURLConnection, שתומך ב-TLS, בהעלאות ובהורדות בסטרימינג, בזמני תפוגה שניתן להגדיר, ב-IPv6 ובאוסף חיבורים.

יש גם ספריות של צד שלישי שמציעות ממשקי API ברמה גבוהה יותר לפעולות ברשת. הם תומכים בתכונות נוחות שונות, כמו שרשור של גופי בקשות ופירוק שרשור של גופי תשובות.

• Retrofit: לקוח HTTP בטוח לסוגים של JVM מ-Square, שנבנה על גבי OkHttp. באמצעות Retrofit תוכלו ליצור ממשק לקוח באופן דקלרטיבי, ויש לו תמיכה בכמה ספריות סריאליזציה.
• Ktor: לקוח HTTP מ-JetBrains, שנוצר במיוחד עבור Kotlin ומבוסס על קורוטינים. ב-Ktor יש תמיכה במגוון מנועים, סריאליזטורים ופלטפורמות.

פתרון שאילתות DNS

במכשירים עם Android מגרסה 10 (API ברמה 29) ואילך יש תמיכה מובנית בחיפושים מיוחדים של DNS באמצעות חיפושים בטקסט ללא הצפנה ומצב DNS-over-TLS. ה-API DnsResolver מספק פתרון גנרי ואסינכרוני, שמאפשר לחפש רשומות מסוג SRV,‏ NAPTR וסוגים אחרים. האפליקציה היא זו שמנתחת את התשובה.

במכשירים עם Android מגרסה 9 (רמת API‏ 28) ומטה, פותר ה-DNS של הפלטפורמה תומך רק ברשומות A ו-AAAA. כך תוכלו לחפש את כתובות ה-IP המשויכות לשם, אבל לא תהיה תמיכה בסוגי רשומות אחרים.

למידע על אפליקציות שמבוססות על NDK, ראו android_res_nsend.

אנקפסולציה של פעולות רשת במאגר

כדי לפשט את תהליך ביצוע פעולות הרשת ולצמצם את הכפילויות בקוד בחלקים שונים של האפליקציה, אפשר להשתמש בתבנית העיצוב של המאגר. מאגר הוא סוג שמטפל בפעולות נתונים ומספק הפשטה נקייה של ממשק API על נתונים או משאבים ספציפיים.

אפשר להשתמש ב-Retrofit כדי להצהיר על ממשק שמציין את שיטת ה-HTTP, את כתובת ה-URL, את הארגומנטים ואת סוג התגובה של פעולות הרשת, כמו בדוגמה הבאה:

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

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

בתוך סוג מאגר, פונקציות יכולות להכיל פעולות רשת ולהציג את התוצאות שלהן. האנקפסולציה הזו מבטיחה שהרכיבים שמפעילים את המאגר לא צריכים לדעת איך הנתונים מאוחסנים. גם שינויים עתידיים באופן שבו הנתונים מאוחסנים מבודדים בכיתה של המאגר. לדוגמה, יכול להיות שתרצו לבצע שינוי מרחוק, כמו עדכון של נקודות קצה ל-API, או להטמיע אחסון במטמון מקומי.

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

class UserRepository {
    private UserService userService;

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

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

כדי למנוע יצירת ממשק משתמש שלא מגיב, אל תבצעו פעולות רשת בשרשור הראשי. כברירת מחדל, מערכת Android דורשת לבצע פעולות רשת בשרשור שאינו השרשור הראשי של ממשק המשתמש. אם מנסים לבצע פעולות רשת ב-thread הראשי, מתקבלת הודעת השגיאה NetworkOnMainThreadException.

בדוגמת הקוד הקודמת, פעולת הרשת לא מופעלת בפועל. מבצע הקריאה לפונקציה UserRepository חייב להטמיע את השרשור באמצעות פונקציות קורוטין או באמצעות הפונקציה enqueue(). מידע נוסף זמין בקודלאב קבלת נתונים מהאינטרנט, שבו מוסבר איך מטמיעים תהליכים באמצעות קורוטינים של Kotlin.

התמודדות עם שינויים בהגדרות

כשמתרחש שינוי בהגדרות, כמו סיבוב המסך, הפעילות או החלקיק נמחקים ונוצרים מחדש. כל נתון שלא נשמר במצב המכונה של פעילות הפלח, שיכול להכיל רק כמויות קטנות של נתונים, ילך לאיבוד. במקרה כזה, יכול להיות שתצטרכו לשלוח מחדש את בקשות הרשת.

אפשר להשתמש ב-ViewModel כדי שהנתונים יישארו גם אחרי שינויים בהגדרות. הרכיב ViewModel נועד לאחסון ולניהול נתונים שקשורים לממשק המשתמש, תוך התחשבות במחזור החיים שלהם. באמצעות UserRepository הקודם, ה-ViewModel יכול לשלוח את הבקשות הנדרשות לרשת ולספק את התוצאה לקטע או לפעילות באמצעות LiveData:

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
            }

        }
    }
}

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
            }
        });
    }
}

מדריכים קשורים

מידע נוסף בנושא זמין במדריכים הבאים:

• צמצום השימוש בסוללה ברשת: סקירה כללית
• צמצום ההשפעה של עדכונים שוטפים
• תוכן מבוסס-אינטרנט
• יסודות של אפליקציות
• מדריך לארכיטקטורה של אפליקציות