Konsep Lanjutan

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Memperoleh data

Ada banyak cara untuk memperoleh data lokasi yang terkumpul. Di sini, kami menjelaskan dua teknik untuk memperoleh data yang akan digunakan dengan fitur snap to roads pada Roads API.

GPX

GPX adalah format terbuka berbasis XML untuk berbagi rute, jalur, dan titik jalan yang diambil oleh perangkat GPS. Contoh ini menggunakan parser XmlPull, parse XML ringan yang tersedia untuk server Java dan lingkungan seluler.

/**
 * 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;
}

Berikut adalah beberapa data GPX mentah yang dimuat ke peta.

Data GPX mentah pada peta

Layanan lokasi Android

Cara terbaik untuk mengambil data GPS dari perangkat Android bervariasi bergantung pada kasus penggunaan Anda. Lihat kelas pelatihan Android tentang Menerima Pembaruan Lokasi, serta Contoh Lokasi Google Play di GitHub.

Memproses jalur yang panjang

Karena fitur snap to roads menyimpulkan lokasi berdasarkan lokasi lengkap, bukan masing-masing titik, Anda perlu berhati-hati saat memproses jalur yang panjang (yaitu, jalur yang melebihi batas 100 titik per permintaan).

Untuk memperlakukan permintaan individual sebagai satu jalur panjang, Anda harus menyertakan beberapa tumpang-tindih, sehingga titik akhir dari permintaan sebelumnya disertakan sebagai titik pertama dari permintaan berikutnya. Jumlah titik yang disertakan bergantung pada akurasi data Anda. Anda harus menyertakan lebih banyak poin untuk permintaan dengan akurasi rendah.

Contoh ini menggunakan Klien Java untuk Layanan Google Maps guna mengirim permintaan halaman, lalu menggabungkan kembali data tersebut, termasuk titik interpolasi, ke dalam daftar yang ditampilkan.

/**
 * 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;
}

Berikut adalah data dari atas setelah menjalankan permintaan snap-to-road. Garis merah adalah data mentah dan garis biru adalah data yang diikat.

Contoh data yang telah dipaskan ke jalan

Penggunaan kuota yang efisien

Respons terhadap permintaan snap to roads mencakup daftar ID tempat yang dipetakan ke titik yang Anda berikan, mungkin dengan titik tambahan jika Anda menetapkan interpolate=true.

Untuk memanfaatkan kuota yang diizinkan secara efisien untuk permintaan batas kecepatan, Anda hanya boleh membuat kueri untuk ID tempat unik dalam permintaan. Contoh ini menggunakan Klien Java untuk Layanan Google Maps guna membuat kueri batas kecepatan dari daftar ID tempat.

/**
 * 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;
}

Berikut adalah data dari atas dengan batas kecepatan yang ditandai pada setiap ID tempat yang unik.

Rambu batas kecepatan di peta

Berinteraksi dengan API lain

Salah satu manfaat memiliki ID tempat yang ditampilkan dalam respons snap to roads adalah Anda dapat menggunakan ID tempat di banyak API Google Maps Platform. Contoh ini menggunakan Klien Java untuk Layanan Google Maps untuk melakukan geocoding terhadap tempat yang ditampilkan dari permintaan penunjuk posisi di atas.

/**
 * 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;
}

Di sini, penanda batas kecepatan telah dianotasi dengan alamat dari Geocoding API.

Alamat yang di-geocoding yang ditampilkan pada penanda

Kode contoh

Pertimbangan

Kode yang mendukung artikel ini tersedia sebagai aplikasi Android tunggal untuk tujuan ilustrasi. Dalam praktiknya Anda tidak boleh mendistribusikan kunci API sisi server di aplikasi Android karena kunci Anda tidak dapat diamankan dari akses yang tidak sah dari pihak ketiga. Sebagai gantinya, untuk mengamankan kunci, Anda harus men-deploy kode yang menghadap API sebagai proxy sisi server dan meminta aplikasi Android mengirimkan permintaan melalui proxy, sehingga memastikan permintaan diotorisasi.

Download

Download kode dari GitHub.