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

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

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

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

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

הגדרה של מעקב אחר גיאופנסינג

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

מידע נוסף על בקשת הרשאות מיקום

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

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

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

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 ליצירת אובייקטים של גדרות וירטואליות, ומחלקת הנוחות להוספתן. בנוסף, כדי לטפל ב-intents שנשלחים משירותי המיקום כשמתרחשים מעברים בין גיאופנסים, אפשר להגדיר 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 היא דרך טובה לטפל במעבר של גדר וירטואלית. ‫A 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;
   }

}

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

כדי להוסיף גדרות וירטואליות, משתמשים בשיטה 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 דקות).

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

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

דוגמיות

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

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