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

צירוף נתונים

יש הרבה דרכים לקבל נתוני מיקום שנאספים. בקטע הזה מתוארות שתי שיטות לקבלת נתונים לשימוש עם התכונה הצמדה לכבישים של 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 לשירותי מפות Google כדי לשלוח בקשות לפי חלוקה לדפים, ואז מצרפת מחדש את הנתונים, כולל נקודות אינטרפולציה, לרשימה שהוחזרה.

/**
 * 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 אחרים

אחד היתרונות של החזרת מזהי מקומות בתגובות לפנייה לכבישים הוא שאפשר להשתמש במזהה המקום ברבים מממשקי ה-API של הפלטפורמה של מפות Google. בדוגמה זו נעשה שימוש בלקוח 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 כשרת proxy בצד השרת, ולבקש מאפליקציית Android לשלוח בקשות דרך שרת ה-proxy כדי לוודא שהבקשות מאושרות.

הורדה

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