יצירת גבולות וירטואליים ומעקב אחריהם

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

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

בשיעור הזה נסביר איך להוסיף ולהסיר גבולות וירטואליים, ואז להאזין למעברים בין גבולות וירטואליים באמצעות BroadcastReceiver.

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

הגדרה למעקב אחר גבולות וירטואליים

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

מידע נוסף זמין במדריך בנושא בקשת הרשאות מיקום.

אם רוצים להשתמש ב-BroadcastReceiver כדי להאזין למעברים של גבולות וירטואליים, צריך להוסיף רכיב שמציין את שם השירות. הרכיב הזה חייב להיות צאצא של הרכיב <application>: 

<application
   android:allowBackup="true">
   ...
   <receiver android:name=".GeofenceBroadcastReceiver"/>
<application/>

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

Kotlin

lateinit var geofencingClient: GeofencingClient

override fun onCreate(savedInstanceState: Bundle?) {
    // ...
    geofencingClient = LocationServices.getGeofencingClient(this)
}

Java

private GeofencingClient geofencingClient;

@Override
public void onCreate(Bundle savedInstanceState) {
    // ...
    geofencingClient = LocationServices.getGeofencingClient(this);
}

יצירה והוספה של גבולות וירטואליים

כדי ליצור ולהוסיף גבולות וירטואליים, האפליקציה צריכה להשתמש במחלקת ה-builder של ה-location API כדי ליצור אובייקטים של גבולות וירטואליים, ובמחלקת הנוחות כדי להוסיף אותם. כדי לטפל ב-Intent שנשלחים משירותי המיקום כשמתרחשים מעברים בגבולות הווירטואליים, אפשר להגדיר PendingIntent כמו שמוצג בקטע הזה.

הערה: במכשירים עם משתמש יחיד, יש מגבלה של 100 גבולות וירטואליים לכל אפליקציה. במכשירים עם משתמשים מרובים, המגבלה היא 100 גבולות וירטואליים לכל אפליקציה לכל משתמש במכשיר.

יצירת אובייקטים של גבולות וירטואליים

קודם משתמשים ב- Geofence.Builder כדי ליצור גבול וירטואלי, ומגדירים את הרדיוס, משך הזמן וסוגי המעבר הרצויים לגבול הווירטואלי. לדוגמה, כדי לאכלס אובייקט רשימה:

Kotlin

geofenceList.add(Geofence.Builder()
    // Set the request ID of the geofence. This is a string to identify this
    // geofence.
    .setRequestId(entry.key)

    // Set the circular region of this geofence.
    .setCircularRegion(
        entry.value.latitude,
        entry.value.longitude,
        Constants.GEOFENCE_RADIUS_IN_METERS
    )

    // Set the expiration duration of the geofence. This geofence gets automatically
    // removed after this period of time.
    .setExpirationDuration(Constants.GEOFENCE_EXPIRATION_IN_MILLISECONDS)

    // Set the transition types of interest. Alerts are only generated for these
    // transition. We track entry and exit transitions in this sample.
    .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER or Geofence.GEOFENCE_TRANSITION_EXIT)

    // Create the geofence.
    .build())

Java

geofenceList.add(new Geofence.Builder()
    // Set the request ID of the geofence. This is a string to identify this
    // geofence.
    .setRequestId(entry.getKey())

    .setCircularRegion(
            entry.getValue().latitude,
            entry.getValue().longitude,
            Constants.GEOFENCE_RADIUS_IN_METERS
    )
    .setExpirationDuration(Constants.GEOFENCE_EXPIRATION_IN_MILLISECONDS)
    .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER |
            Geofence.GEOFENCE_TRANSITION_EXIT)
    .build());

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

הגדרת גבולות וירטואליים וטריגרים ראשוניים

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

Kotlin

private fun getGeofencingRequest(): GeofencingRequest {
    return GeofencingRequest.Builder().apply {
        setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER)
        addGeofences(geofenceList)
    }.build()
}

Java

private GeofencingRequest getGeofencingRequest() {
    GeofencingRequest.Builder builder = new GeofencingRequest.Builder();
    builder.setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER);
    builder.addGeofences(geofenceList);
    return builder.build();
}

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

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

הגדרת מקלט שידורים למעברים בין גבולות וירטואליים

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

בקטע הקוד הבא אפשר לראות איך מגדירים PendingIntent שמפעיל BroadcastReceiver:

Kotlin

class MainActivity : AppCompatActivity() {

    // ...

    private val geofencePendingIntent: PendingIntent by lazy {
        // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back when calling
        // addGeofences() and removeGeofences().
        val flags = PendingIntent.FLAG_UPDATE_CURRENT
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
            // Starting on Android S+ the pending intent has to be mutable.
            flags or PendingIntent.FLAG_MUTABLE
        }
        val intent = Intent(this, GeofenceBroadcastReceiver::class.java)
        PendingIntent.getBroadcast(this, 0, intent, flags)
    }

}

Java

public class MainActivity extends AppCompatActivity {

    // ...

    private PendingIntent getGeofencePendingIntent() {
        // Reuse the PendingIntent if we already have it.
        if (geofencePendingIntent != null) {
          return geofencePendingIntent;
        }
        // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back when calling
        // addGeofences() and removeGeofences().
        int flags = PendingIntent.FLAG_UPDATE_CURRENT;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
            // Starting on Android S+ the pending intent has to be mutable.
            flags |= PendingIntent.FLAG_MUTABLE;
        }
        Intent intent = new Intent(this, GeofenceBroadcastReceiver.class);
        geofencePendingIntent = PendingIntent.getBroadcast(this, 0, intent, flags);
        return geofencePendingIntent;
   }

}

הוספת גבולות וירטואליים

כדי להוסיף גבולות וירטואליים, משתמשים ב-method‏ GeofencingClient.addGeofences(). מציינים את האובייקט GeofencingRequest ואת PendingIntent. בקטע הקוד הבא אפשר לראות איך מעבדים את התוצאות:

Kotlin

geofencingClient?.addGeofences(getGeofencingRequest(), geofencePendingIntent)?.run {
    addOnSuccessListener {
        // Geofences added
        // ...
    }
    addOnFailureListener {
        // Failed to add geofences
        // ...
    }
}

Java

geofencingClient.addGeofences(getGeofencingRequest(), getGeofencePendingIntent())
        .addOnSuccessListener(this, new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                // Geofences added
                // ...
            }
        })
        .addOnFailureListener(this, new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Failed to add geofences
                // ...
            }
        });

טיפול במעברים בין גבולות וירטואליים

כששירותי המיקום מזהים שהמשתמש נכנס לגבולות הווירטואליים או יצא מהם, הם שולחים את ה-Intent שכלול ב-PendingIntent שכללתם בבקשה להוספת גבולות וירטואליים. מקלט שידור כמו GeofenceBroadcastReceiver מזהה שה-Intent הופעל, ואז יכול לקבל את אירוע הגבולות הווירטואליים מה-intent, לקבוע את סוגי המעברים של הגבולות הווירטואליים ולקבוע איזה מהגבולות הווירטואליים שהוגדרו הופעל. מקלט השידור יכול להורות לאפליקציה להתחיל לבצע עבודה ברקע, או לשלוח התראה כפלט, אם רוצים.

הערה: ב-Android 8.0 (רמת API‏ 26) ומעלה, אם אפליקציה פועלת ברקע בזמן מעקב אחרי גבולות וירטואליים, המכשיר מגיב לאירועים של גבולות וירטואליים כל כמה דקות. במאמר מגבלות על מיקום ברקע מוסבר איך להתאים את האפליקציה למגבלות התגובה האלה.

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

Kotlin

class GeofenceBroadcastReceiver : BroadcastReceiver() {
    // ...
    override fun onReceive(context: Context?, intent: Intent?) {
        val geofencingEvent = GeofencingEvent.fromIntent(intent)
        if (geofencingEvent.hasError()) {
            val errorMessage = GeofenceStatusCodes
                    .getStatusCodeString(geofencingEvent.errorCode)
            Log.e(TAG, errorMessage)
            return
        }

        // Get the transition type.
        val geofenceTransition = geofencingEvent.geofenceTransition

        // Test that the reported transition was of interest.
        if (geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ||
                geofenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) {

            // Get the geofences that were triggered. A single event can trigger
            // multiple geofences.
            val triggeringGeofences = geofencingEvent.triggeringGeofences

            // Get the transition details as a String.
            val geofenceTransitionDetails = getGeofenceTransitionDetails(
                    this,
                    geofenceTransition,
                    triggeringGeofences
            )

            // Send notification and log the transition details.
            sendNotification(geofenceTransitionDetails)
            Log.i(TAG, geofenceTransitionDetails)
        } else {
            // Log the error.
            Log.e(TAG, getString(R.string.geofence_transition_invalid_type,
                    geofenceTransition))
        }
    }
}

Java

public class GeofenceBroadcastReceiver extends BroadcastReceiver {
    // ...
    protected void onReceive(Context context, Intent intent) {
        GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
        if (geofencingEvent.hasError()) {
            String errorMessage = GeofenceStatusCodes
                    .getStatusCodeString(geofencingEvent.getErrorCode());
            Log.e(TAG, errorMessage);
            return;
        }

        // Get the transition type.
        int geofenceTransition = geofencingEvent.getGeofenceTransition();

        // Test that the reported transition was of interest.
        if (geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ||
                geofenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) {

            // Get the geofences that were triggered. A single event can trigger
            // multiple geofences.
            List<Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();

            // Get the transition details as a String.
            String geofenceTransitionDetails = getGeofenceTransitionDetails(
                    this,
                    geofenceTransition,
                    triggeringGeofences
            );

            // Send notification and log the transition details.
            sendNotification(geofenceTransitionDetails);
            Log.i(TAG, geofenceTransitionDetails);
        } else {
            // Log the error.
            Log.e(TAG, getString(R.string.geofence_transition_invalid_type,
                    geofenceTransition));
        }
    }
}

אחרי זיהוי אירוע המעבר באמצעות PendingIntent, ה-BroadcastReceiver מקבל את סוג המעבר של הגבול הווירטואלי ובודק אם הוא אחד מהאירועים שבהם האפליקציה משתמשת כדי להפעיל התראות – GEOFENCE_TRANSITION_ENTER או GEOFENCE_TRANSITION_EXIT במקרה הזה. לאחר מכן, השירות שולח התראה ומתעד את פרטי המעבר.

הפסקת המעקב אחרי הגבולות הווירטואליים

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

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

Kotlin

geofencingClient?.removeGeofences(geofencePendingIntent)?.run {
    addOnSuccessListener {
        // Geofences removed
        // ...
    }
    addOnFailureListener {
        // Failed to remove geofences
        // ...
    }
}

Java

geofencingClient.removeGeofences(getGeofencePendingIntent())
        .addOnSuccessListener(this, new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                // Geofences removed
                // ...
            }
        })
        .addOnFailureListener(this, new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Failed to remove geofences
                // ...
            }
        });

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

שיטות מומלצות לשימוש בגבולות וירטואליים

בקטע הזה מפורטות המלצות לשימוש בגבולות וירטואליים עם ממשקי ה-API למיקום ב-Android.

הפחתה של צריכת האנרגיה

אתם יכולים להשתמש בשיטות הבאות כדי לבצע אופטימיזציה של צריכת החשמל באפליקציות שמשתמשות בגבולות וירטואליים:

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

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

בחירת הרדיוס האופטימלי לגבול הווירטואלי

כדי לקבל את התוצאות הכי טובות, מומלץ להגדיר את הרדיוס המינימלי של הגבול הווירטואלי בין 100 ל-150 מטרים. כשיש חיבור Wi-Fi, זיהוי מיקום משופר הוא בדרך כלל בין 20 ל-50 מטרים. כשהמיקום בתוך מבנה זמין, טווח הדיוק יכול להיות קטן עד כדי 5 מטרים. אם אתם לא יודעים אם יש מיקום בתוך מבנה בגבולות הווירטואליים, הניחו שרמת הדיוק של המיקום באמצעות Wi-Fi היא כ-50 מטרים.

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

הסבירו למשתמשים למה האפליקציה שלכם משתמשת בגבולות וירטואליים

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

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

שימוש בסוג המעבר "שהייה" כדי לצמצם את כמות ההתראות

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

רישום מחדש של גבולות וירטואליים רק כשצריך

הגבולות הווירטואליים הרשומים נשמרים בתהליך com.google.process.location שבבעלות החבילה com.google.android.gms. האפליקציה לא צריכה לעשות שום דבר כדי לטפל באירועים הבאים, כי המערכת משחזרת את הגבולות הווירטואליים אחרי האירועים האלה:

  • ‫Google Play Services משודרגת.
  • המערכת סוגרת ומפעילה מחדש את Google Play Services בגלל הגבלת משאבים.
  • תהליך המיקום קורס.

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

  • המכשיר מופעל מחדש. האפליקציה צריכה להאזין לפעולת ההפעלה של המכשיר, ואז לרשום מחדש את הגבולות הווירטואליים הנדרשים.
  • האפליקציה הוסרה והותקנה מחדש.
  • נתוני האפליקציה נמחקים.
  • הנתונים של Google Play Services נמחקים.
  • האפליקציה קיבלה התראה מסוג GEOFENCE_NOT_AVAILABLE. בדרך כלל זה קורה אחרי שמשביתים את NLP (ספק המיקום ברשת של Android).

פתרון בעיות באירוע הכניסה לגבול הווירטואלי

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

יכולות להיות כמה סיבות לכך שההתראות לא פועלות כמו שצריך:

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

  • ה-Wi-Fi מושבת במכשיר. הפעלת ה-Wi-Fi יכולה לשפר משמעותית את דיוק המיקום. אם ה-Wi-Fi מושבת, יכול להיות שהאפליקציה לא תקבל התראות על גבולות וירטואליים, בהתאם להגדרות שונות, כולל הרדיוס של הגבול הווירטואלי, דגם המכשיר או גרסת Android. החל מ-Android 4.3 (רמת API‏ 18), הוספנו את האפשרות "מצב סריקת Wi-Fi בלבד", שמאפשרת למשתמשים להשבית את ה-Wi-Fi ועדיין לקבל מיקום טוב ברשת. מומלץ להציג למשתמשים בקשה וקיצור דרך להפעלת Wi-Fi או מצב סריקת Wi-Fi בלבד אם שניהם מושבתים. משתמשים ב- SettingsClient כדי לוודא שהגדרות המערכת של המכשיר מוגדרות בצורה נכונה לזיהוי מיקום אופטימלי.

    הערה: אם האפליקציה מיועדת ל-Android 10 (רמת API 29) או לגרסה מתקדמת יותר, אי אפשר להפעיל את WifiManager.setEnabled() ישירות, אלא אם האפליקציה היא אפליקציית מערכת או בקר מדיניות מכשיר (DPC). במקום זאת, צריך להשתמש בחלונית הגדרות.

  • אין חיבור יציב לרשת בתוך הגבולות הווירטואליים. אם אין חיבור נתונים מהימן, יכול להיות שלא ייווצרו התראות. הסיבה לכך היא ששירות הגבולות הווירטואליים תלוי בספק המיקום ברשת, שדורש חיבור נתונים.
  • ההתראות עלולות להגיע באיחור. שירות הגבולות הווירטואליים לא שולח שאילתות מיקום באופן רציף, לכן יכול להיות עיכוב בקבלת ההתראות. בדרך כלל זמן האחזור הוא פחות מ-2 דקות, ואפילו פחות מזה כשהמכשיר בתנועה. אם מגבלות המיקום ברקע מופעלות, זמן האחזור הוא כ-2-3 דקות בממוצע. אם המכשיר לא זז במשך זמן רב, זמן האחזור עשוי להתארך (עד 6 דקות).

מקורות מידע נוספים

מידע נוסף על גבולות וירטואליים זמין במקורות הבאים:

דוגמאות

אפליקציה לדוגמה ליצירת גבולות וירטואליים ולמעקב אחריהם.

הקודם
גישה למיקום ברקע
הבא
זיהוי של רגעים שבהם משתמשים מתחילים פעילות