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

איסוף נתונים

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

GPX

GPX הוא פורמט פתוח מבוסס-XML לשיתוף מסלולים, מסלולי הליכה ונקודות ציון שצולמו באמצעות מכשירי GPS. בדוגמה הזו נעשה שימוש ב-parser‏ 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 Location ב-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.