קונספטים מתקדמים

הוספת נתונים

יש הרבה דרכים לקבל את נתוני המיקום שנאספו. במאמר הזה מתוארות שתי טכניקות לאיסוף נתונים לשימוש בתכונה הצמדה לכבישים של Roads API.

GPX

‫GPX הוא פורמט פתוח מבוסס XML לשיתוף מסלולים, עקבות ונקודות ציון שצולמו על ידי מכשירי GPS. בדוגמה הזו נעשה שימוש במנתח התגים XmlPull, שהוא מנתח תגי XML קל משקל שזמין גם בסביבות שרת Java וגם בסביבות ניידות.

/**
 * Parses the waypoint (wpt tags) data into native objects from a GPX stream.
 */
private List<LatLng> loadGpxData(XmlPullParser parser, InputStream gpxIn)
        throws XmlPullParserException, IOException {
    // We use a List<> as we need subList for paging later
    List<LatLng> latLngs = new ArrayList<>();
    parser.setInput(gpxIn, null);
    parser.nextTag();

    while (parser.next() != XmlPullParser.END_DOCUMENT) {
        if (parser.getEventType() != XmlPullParser.START_TAG) {
            continue;
        }

        if (parser.getName().equals("wpt")) {
            // Save the discovered latitude/longitude attributes in each <wpt>.
            latLngs.add(new LatLng(
                    Double.valueOf(parser.getAttributeValue(null, "lat")),
                    Double.valueOf(parser.getAttributeValue(null, "lon"))));
        }
        // Otherwise, skip irrelevant data
    }

    return latLngs;
}

כאן מוצגים נתוני GPX גולמיים שנטענו במפה.

נתוני GPX גולמיים במפה

שירותי מיקום ב-Android

הדרך הכי טובה לאיסוף נתוני GPS ממכשיר Android משתנה בהתאם לתרחיש השימוש. כדאי לעיין בשיעור ההדרכה של Android בנושא קבלת עדכוני מיקום, וגם בדוגמאות למיקום ב-Google Play ב-GitHub.

עיבוד נתיבים ארוכים

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

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

בדוגמה הזו נעשה שימוש ב-Java Client for Google Maps Services כדי לשלוח בקשות עם חלוקה לדפים, ואז לאחד מחדש את הנתונים, כולל נקודות שעברו אינטרפולציה, לרשימה שמוחזרת.

/**
 * Snaps the points to their most likely position on roads using the Roads API.
 */
private List<SnappedPoint> snapToRoads(GeoApiContext context) throws Exception {
    List<SnappedPoint> snappedPoints = new ArrayList<>();

    int offset = 0;
    while (offset < mCapturedLocations.size()) {
        // Calculate which points to include in this request. We can't exceed the API's
        // maximum and we want to ensure some overlap so the API can infer a good location for
        // the first few points in each request.
        if (offset > 0) {
            offset -= PAGINATION_OVERLAP;   // Rewind to include some previous points.
        }
        int lowerBound = offset;
        int upperBound = Math.min(offset + PAGE_SIZE_LIMIT, mCapturedLocations.size());

        // Get the data we need for this page.
        LatLng[] page = mCapturedLocations
                .subList(lowerBound, upperBound)
                .toArray(new LatLng[upperBound - lowerBound]);

        // Perform the request. Because we have interpolate=true, we will get extra data points
        // between our originally requested path. To ensure we can concatenate these points, we
        // only start adding once we've hit the first new point (that is, skip the overlap).
        SnappedPoint[] points = RoadsApi.snapToRoads(context, true, page).await();
        boolean passedOverlap = false;
        for (SnappedPoint point : points) {
            if (offset == 0 || point.originalIndex >= PAGINATION_OVERLAP - 1) {
                passedOverlap = true;
            }
            if (passedOverlap) {
                snappedPoints.add(point);
            }
        }

        offset = upperBound;
    }

    return snappedPoints;
}

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

דוגמה לנתונים שהוצמדו לכבישים

שימוש יעיל במכסה

התשובה לבקשת הצמדה לכבישים כוללת רשימה של מזהי מקומות שמתאימים לנקודות שסיפקתם, ויכול להיות שיהיו בה נקודות נוספות אם הגדרתם את interpolate=true.

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

/**
 * Retrieves speed limits for the previously-snapped points. This method is efficient in terms
 * of quota usage as it will only query for unique places.
 *
 * Note: Speed limit data is only available for requests using an API key enabled for a
 * Google Maps APIs Premium Plan license.
 */
private Map<String, SpeedLimit> getSpeedLimits(GeoApiContext context, List<SnappedPoint> points)
        throws Exception {
    Map<String, SpeedLimit> placeSpeeds = new HashMap<>();

    // Pro tip: Save on quota by filtering to unique place IDs.
    for (SnappedPoint point : points) {
        placeSpeeds.put(point.placeId, null);
    }

    String[] uniquePlaceIds =
            placeSpeeds.keySet().toArray(new String[placeSpeeds.keySet().size()]);

    // Loop through the places, one page (API request) at a time.
    for (int i = 0; i < uniquePlaceIds.length; i += PAGE_SIZE_LIMIT) {
        String[] page = Arrays.copyOfRange(uniquePlaceIds, i,
                Math.min(i + PAGE_SIZE_LIMIT, uniquePlaceIds.length));

        // Execute!
        SpeedLimit[] placeLimits = RoadsApi.speedLimits(context, page).await();
        for (SpeedLimit sl : placeLimits) {
            placeSpeeds.put(sl.placeId, sl);
        }
    }

    return placeSpeeds;
}

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

תמרורי מהירות מותרת במפה

אינטראקציה עם ממשקי API אחרים

אחד היתרונות של החזרת מזהי מקומות בתגובות של snap to roads הוא שאפשר להשתמש במזהה המקום בהרבה ממשקי Google Maps Platform API. בדוגמה הזו נעשה שימוש בלקוח Java לשירותי מפות Google כדי לבצע קידוד גיאוגרפי של מקום שהוחזר מהבקשה שלמעלה להצמדת נקודה לכביש.

/**
 * Geocodes a snapped point using the place ID.
 */
private GeocodingResult geocodeSnappedPoint(GeoApiContext context, SnappedPoint point) throws Exception {
    GeocodingResult[] results = GeocodingApi.newRequest(context)
            .place(point.placeId)
            .await();

    if (results.length > 0) {
        return results[0];
    }
    return null;
}

כאן סומן תמרור המהירות המותרת עם הכתובת מ-Geocoding API.

כתובת שהומרה לקואורדינטות ומוצגת בסמן

קוד לדוגמה

שיקולים

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

הורדה

מורידים את הקוד מ-GitHub.