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

רכישת נתונים

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

כאן, לחצו על סמן המהירות עם הכתובת של ה-API של Geocoding.

כתובת גיאוגרפית מוצגת בסמן

קוד לדוגמה

שיקולים

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

הורדה

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