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

מתבצע איסוף נתונים

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

שירותי המיקום של 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.