Google Data » Google Maps

Geolocation and Firebase for the Internet of Things

Maps Devel — Wed, 21 Dec 2016 17:48:00 +0000

Posted by Ken Nevarez, Industry Solutions Lead at Google

GPS is the workhorse of location based services, but there are use cases where you may want to avoid the cost and power consumption of GPS hardware or locate devices in places where GPS lacks accuracy, such as in urban environments or buildings.

We've seen recent growth in Internet of Things (IoT) applications using the Google Maps Geolocation API instead of GPS for asset tracking, theft prevention, usage optimization, asset servicing, and more. As part of my 20 percent project at Industry Solutions, I created a prototype IoT device that can locate itself using surrounding WiFi networks and the Google Maps Geolocation API. In this post, I’ll discuss some interesting implementation features and outline how you can create the prototype yourself.

I built a device that scans for local WiFi and writes results (WiFi hotspots and their signal strength) to a Firebase Realtime Database. A back-end service then reads this data and uses the Google Maps Geolocation API to turn this into a real-world location, which can be plotted on a map.

Set up the Device & Write Locally

For this proof of concept, I used the Intel Edison as a Linux-based computing platform and augmented it with Sparkfun’s Edison Blocks. To build the device, you will need an Intel Edison, a Base Block, a Battery Block and a Hardware pack.

Developing for the Edison is straightforward using the Intel XDK IDE. We will be creating a simple Node.js application in JavaScript. I relied on 3 libraries: Firebase for the database connection, wireless-tools/iwlist to capture WiFi networks, and macaddress to capture the device MAC. Installation instructions can be found on the linked pages.

Step 1: get the device MAC address and connect to Firebase:

function initialize() {
    macaddress.one('wlan0', function (err, mac) {
        mac_address = mac;
        if (mac === null) {
            console.log('exiting due to null mac Address');
            process.exit(1);
        }
        firebase.initializeApp({
            serviceAccount: '/node_app_slot/.json',
            databaseURL: 'https://.firebaseio.com/'
        });
        var db = firebase.database();
        ref_samples = db.ref('/samples');
        locationSample();
    });
}

The above code contains two placeholders:

The service-account-key is a private key you create in the Firebase Console. Follow the gear icon in the upper left of console, select “settings”, and click Generate New Private Key. Place this key on your Edison in the directory /node_app_slot/. See this Firebase documentation for more information.
The project-id in the database URL is found in the Firebase console database page after you have linked your Google project with Firebase.

Step 2: scan for WiFi networks every 10 seconds and write locally:

function locationSample() {
    var t = new Date();
    iwlist.scan('wlan0', function(err, networks) {
        if(err === null) {
            ref_samples.push({
                mac: mac_address,
                t_usec: t.getTime(),
                t_locale_string: t.toLocaleString(),
                networks: networks,
            });
        } else {
            console.log(err);
        }        
    });
    setTimeout(locationSample, 10000);
}

Write to the cloud

The locationSample() function above writes detectable WiFi networks to a Firebase database that syncs to the cloud when connected to a network.

Caveat: To configure access rights and authentication to Firebase, I set up the device as a “server”. Instructions for this configuration are on the Firebase website. For this proof of concept, I made the assumption that the device was secure enough to house our credentials. If this is not the case for your implementation you should instead follow the instructions for setting up the client JavaScript SDK.

The database uses 3 queues to manage workload: a WiFi samples queue, a geolocation results queue and a visualization data queue. The workflow will be: samples from the device go into a samples queue, which gets consumed to produce geolocations that are put into a geolocations queue. Geolocations are consumed and formatted for presentation, organized by device, and the output is stored in a visualizations bucket for use by our front end website.

Below is an example of a sample, a geolocation, and our visualization data written by the device and seen in the Firebase Database Console.

Processing the Data with Google App Engine

To execute the processing of the sample data I used a long running Google App Engine Backend Module and a custom version of the Java Client for Google Maps Services.

Caveat: To use Firebase with App Engine, you must use manual scaling. Firebase uses background threads to listen for changes and App Engine only allows long-lived background threads on manually scaled backend instances.

The Java Client for Google Maps Services takes care of a lot of the communications code required to use the Maps APIs and follows our published best practices for error handling and retry strategies that respect rate limits. The GeolocateWifiSample() function below is registered as an event listener with Firebase. It loops over each network reported by the device and incorporates it into the geolocation request.

private void GeolocateWifiSample(DataSnapshot sample,  Firebase db_geolocations, Firebase db_errors) {
    // initalize the context and request
    GeoApiContext context = new GeoApiContext(new GaeRequestHandler()).setApiKey("");
    GeolocationApiRequest request = GeolocationApi.newRequest(context)
            .ConsiderIp(false);
    // for every network that was reported in this sample...
    for (DataSnapshot wap : sample.child("networks").getChildren()) {
        // extract the network data from the database so it’s easier to work with
        String wapMac = wap.child("address").getValue(String.class);
        int wapSignalToNoise = wap.child("quality").getValue(int.class);
        int wapStrength = wap.child("signal").getValue(int.class);
        // include this network in our request
        request.AddWifiAccessPoint(new WifiAccessPoint.WifiAccessPointBuilder()
                .MacAddress(wapMac)
                .SignalStrength(wapStrength)
                .SignalToNoiseRatio(wapSignalToNoise)
                .createWifiAccessPoint());
    }
    ...
    try {
        // call the api
        GeolocationResult result = request.CreatePayload().await();
        ...
        // write results to the database and remove the original sample
    } catch (final NotFoundException e) {
        ...
    } catch (final Throwable e) {
        ...
    }
}

Register the GeolocateWifiSample() function as an event handler. The other listeners that process geolocation results and create the visualization data are built in a similar pattern.

ChildEventListener samplesListener = new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot dataSnapshot, String previousChildName) {
        // geolocate and write to new location
        GeolocateWifiSample(dataSnapshot, db_geolocations, db_errors);
    }
    ...
};
db_samples.addChildEventListener(samplesListener);

Visualize the Data

To visualize the device locations I used Google App Engine to serve stored data from Firebase and the Google Maps JavaScript API to create a simple web page that displays the results. The index.html page contains an empty

with id “map”. I initialized this

to contain the Google Map object. I also added “child_added” and “child_removed” event handlers to update the map as the data changes over time.

function initMap() {
    // attach listeners
    firebase.database().ref('/visualization').on('child_added', function(data) {
        ...
        data.ref.on('child_added', function(vizData) {
            circles[vizData.key]= new CircleRoyale(map,
                                vizData.val().lat,
                                vizData.val().lng,
                                vizData.val().accuracy,
                                color);
          set_latest_position(data.key, vizData.val().lat, vizData.val().lng);
        });
        data.ref.on('child_removed', function(data) {
            circles[data.key].removeFromMap();
        });
    });
    // create the map
    map = new google.maps.Map(document.getElementById('map'), {
      center: get_next_device(),
      zoom: 20,
      scaleControl: true,
    });
    ...
}

Since the API returns not only a location but also an indication of accuracy, I’ve created a custom marker that has a pulsing radius to indicate the accuracy component.

Two devices (red and blue) and their last five known positions

What’s next?

In this post I’ve outlined how you can build an IoT device that uses Google Maps Geolocation API to track any internet-connected device - from robotics to wearables. The App Engine processing module can be expanded to use other Google Maps APIs Web Services providing geographic data such as directions, elevation, place or time zone information. Happy building!

As an alternative, you can achieve a similar solution using Google Cloud Platform as a replacement for Firebase—this article shows you how.

About Ken: Ken is a Lead on the Industry Solutions team. He works with customers to bring innovative solutions to market.

Engage holiday shoppers with Promoted Places in Google Maps

Rob Newton — Thu, 15 Dec 2016 17:00:00 +0000

During the busy holiday season, on-the-go shoppers are using their smartphones to find the perfect stocking stuffers, festive decor and gifts for loved ones. In fact, 70% of smartphone users who bought something in a store first turned to their devices for information relevant to that purchase. One in four of them also used a map through a web browser or an app before making the purchase.¹ This year, a number of brands are testing Promoted Places in Google Maps to showcase special offers and announcements to drive more foot traffic to their stores.

Some users have started seeing a limited test of Promoted Places in the Google Maps for Android app. It integrates seamlessly with the browsing experience, where places of interest are visually marked with icons to help users orient themselves and explore the world around them. With Promoted Places, advertisers can improve awareness for their stores by branding their location icons with their logo. Clicks on a business’s logo will reveal promotions such as in-store sales or new products and services to help consumers decide where to go. They can also view the business’s place page to see store hours, check live updates to Popular Times, get directions, and more.

“We’re looking forward to testing Promoted Places to help us deliver a more branded and customized experience on Google Maps. It will allow us to spotlight our latest products with the goal of driving more shoppers in-store to get the full M·A·C Cosmetics experience.”
- Laura Elkins, SVP of Global Marketing

“Innovation is part of our DNA and we’re continually evaluating meaningful and contextually relevant ways to connect with our customers. Staying top of mind, especially during the competitive holiday season, requires a mix of tried and true, including breakthrough strategies. Promoted Places in Google Maps can help drive incremental store traffic and promote Walgreens as a go-to destination for small gifts. This gives us a new and different way to highlight seasonal offerings through visuals and engaging copy. Combined with the breadth of our store locations in the community, this aligns with our goals of driving loyalty and giving customers more reasons to choose Walgreens for their holiday needs.”
- Andrea Kaduk, Director of SEM & Social

"With Promoted Places, we can enhance our presence on Google Maps and give users a glimpse of our brand and coffeehouses before they even get there. Having our logo on the map helps our locations jump out and promoting our favourite menu items gives people a reason to choose us."
- Jamie McQuary, Senior Marketing Manager

This holiday season, Promoted Places will help businesses stand out to busy shoppers in the moments they’re figuring out where to go. We’re excited to test new experiences that help consumers discover nearby sales and promotions and allow businesses to reach more people through Google Maps.

Posted by: Cynthia Johanson, Product Manager, AdWords

1. Google/Purchased Digital Diary: How Consumers Solve Their Needs in the Moment, May 2016, Smartphone users = 1000. Offline Purchasers = 696

Address Geocoding in the Google Maps APIs

Maps Devel — Tue, 22 Nov 2016 23:43:00 +0000

Forward Geocoding is the process of converting addresses (like a street address) into geographic coordinates (latitude and longitude), which you can use to place markers on a map or position the map. The Google Maps APIs have several services that you can use to convert addresses into coordinates - the Geocoding API, the Place Autocomplete service in Places API, and the Place Search service in Places API. What are the differences between them and when should you use each one? Here’s where to start.

Note that while this blog focuses on the server-side Places and Geocoding APIs, these best practices also apply to the client-side Places and Geocoding services in the Google Maps JavaScript API.

Geocoding API

The Geocoding API is best for handling unambiguous queries: complete postal address strings (for example, “48 Pirrama Rd, Pyrmont, NSW, Australia”). Compared to other Google APIs, the Geocoding API provides the best quality matching of addresses globally for these types of complete, unambiguous queries. However, Geocoding API is not recommended if your application handles ambiguous or incomplete queries, such as “123 Main St”, or if it handles queries that may contain non-address information such as apartment numbers or business names.

Geocoding API is best used for unambiguous complete addresses, such as "48 Pirrama Rd, Pyrmont, NSW, Australia"

Places API

The Places API allows users to discover both addresses and semantic locations, such as cafes or parks, by name or type. In contrast to the Geocoding API, it handles ambiguous or incomplete requests in a more robust way. If your application handles user interaction, or addresses that are ambiguous or incomplete, consider the following services.

Place Autocomplete service

For applications that respond in real time to user input, we recommend using the Place Autocomplete service in the Places API. This service is designed to return multiple possible addresses and allow the user to choose between them. The autocomplete lookup function can also be biased to return results specific to a location, enabling high quality results to be returned for incomplete queries such as “123 Main St”. Since the Place Autocomplete service is optimized for responding to user input, it also has very low latency, usually at least 10x lower than the Geocoding API. It’s also good at handling misspelled queries, or queries containing non-address information, since as the user types, they can see suggestions and correct their spelling if needed.

Typing "123 Main St" into a Place Autocomplete search box lets the user choose from multiple results. Results can also be biased to prefer those near the area shown on the map or near the current user location

Place Search service

The Place Autocomplete service relies on a user to choose the best option from multiple results. What if you have an application that handles ambiguous or incomplete queries in an automated fashion, with no user able to provide input?

For geocoding ambiguous or incomplete addresses in automated systems, when there is no user to select one of the autocomplete suggestions, we recommend the Place Search service in Places API. Place Search is better at coping with ambiguous queries than the Geocoding API, and lets you restrict your search to a specified area, or rank results by distance, allowing more precise filtering and ranking of results for ambiguous or incomplete queries. Place search is also more robust at responding to queries with additional non-address information such as business names or apartment numbers.

Future Changes to Geocoding API

We plan to roll out an update to the Geocoding API at the end of November 2016 that will increase the difference between Geocoding and Places performance for ambiguous and unambiguous queries. This change will improve the quality of Geocoding results for unambiguous queries, but will be more likely to return ZERO_RESULTS for ambiguous or incomplete queries where the Geocoding API was unable to find a high quality result.

If you are already using the above best practices, you should see an improvement in your Geocoding API results. If you are currently using the Geocoding API for incomplete or ambiguous queries, or for queries that may contain non-address information such as business names or apartment numbers, we recommend that you switch to the Places API instead, as it is likely to give better quality results for your use case.

You can try the new Geocoding service ahead of launch by adding an optional parameter, new_forward_geocoder=true, to your Geocoding API request. For example:

https://maps.googleapis.com/maps/api/geocode/json?new_forward_geocoder=true&address=1600+Amphitheatre+Parkway,+Mountain+View,+CA&key=YOUR_API_KEY

If you want to try the new Geocoding service in the JavaScript Maps API Geocoding Service, you can set the new optional parameter newForwardGeocoder: true in the GeocoderRequest object. The new Geocoding service will launch for both the Geocoding API and the Geocoding Service in the JavaScript Maps API at the same time. All of the recommendations in this blog post apply to both the server-side and client-side APIs.

If you have any bug reports or feature requests for the new Geocoding service, please let us know using our public issue tracker.

In Summary

The following table sums up when we recommend you use the Geocoding API, Place Autocomplete service and Place Search service.

	Geocoding API	Place Search	Place Autocomplete
Scope	Addresses only	Semantic locations and addresses, including businesses and points of interest
Strengths	Unambiguous complete addresses	Ambiguous or incomplete addresses in automated systems	Responding to real-time user input

If your application does not yet follow these best practices, you may get worse results from Geocoding API in future, so we recommend you test how your application works with the new Geocoding service and update your application to use the above best practices if required. Try the upcoming Geocoding service by setting new_forward_geocoder=true in your geocoding request.

For more information on the Google Maps Geocoding API, Place Autocomplete in the Places API and Place Search in the Places API, please see the developer documentation. Also see this more detailed best practices guide in our documentation for more details on Geocoding best practices for various use cases, including minimizing latency when querying Directions API with addresses.

Finally, a big thank you to all the developers who use the Google Maps Geocoding API and provide feedback via the issue tracker. Getting feedback from developers is vital for us to be able to keep improving our products, so if you have any bug reports or feature requests, please let us know!

Posted by Elena Kelareva, Product Manager, Google Maps APIs

Smart scrolling comes to mobile web maps

Maps Devel — Wed, 16 Nov 2016 00:23:00 +0000

If you’re building a website today, your users are more likely to view it on a mobile device than on a desktop or laptop. Google has plenty of resources to help developers make their websites stand out on mobile, from a guide to building mobile-friendly websites, to a mobile-friendly testing tool, to promoting new mobile web technologies such as Accelerated Mobile Pages and Progressive Web Apps.

Mobile web users often get frustrated when trying to scroll the page, but an embedded map captures their swipe and pans the map instead. This can even lead to users getting stuck on the map and having to reload the page in order to get back to the rest of the page.

Today we're introducing intuitive scrolling for sites with embedded maps and making the full-screen control visible by default on mobile devices. This should give your users a more intuitive and less frustrating map interaction experience on mobile browsers.

The map trap

We have added a new gestureHandling option to the Google Maps JavaScript API. This setting controls how touch gestures* on the map are handled.

Values:

"cooperative": Two-finger touch gestures pan and zoom the map, as do all mouse gestures. One-finger touch gestures are ignored by the map. In this mode, the map cooperates with the page, so that one-finger touch gestures can pan the page.
"greedy": All touch gestures pan or zoom the map. This was the previous behaviour.
"none": The map cannot be panned or zoomed by user gestures.
"auto": Gesture handling is automatically set to either cooperative or greedy, depending on whether the page is scrollable or not (defined by a comparison of the page body dimensions and the window dimensions).
If the page is scrollable, “auto” sets the gesture handling mode to cooperative.
If the page is not scrollable, “auto” sets the gesture handling to greedy.
If the map is in an iFrame, “auto” sets the gesture handling to cooperative because the API can’t determine whether the page is scrollable.

*Note that there is currently no way to change the gesture handling mode for Street View; these options only affect the way gestures are handled by the map. If you’d like to see this extended to Street View in future, please let us know on our public issue tracker.

You can enable any of these four gesture handling modes by adding the corresponding field to the MapOptions object. For example:

map = new google.maps.Map(document.getElementById('map-div'), {
gestureHandling: 'cooperative',
center: {lat: -34.397, lng: 150.644},
zoom: 8
});

If the gestureHandling option is not set, the default value is auto, since that automatically chooses what we expect to be the best behavior based on what the browser can detect about the placement of your map in the page. If you prefer to always use the old map gesture handling mode for users viewing your site on mobile devices, change the value of gestureHandling to greedy, which sends all user gestures to the map.

Maps viewed within a scrollable website on a mobile device will display this overlay on touch

The option draggable: false has now been superseded by gestureHandling: 'none'. The old option draggable is now deprecated, but we’ll maintain backwards compatibility. Developers who previously turned off map interaction by setting draggable to false will keep their existing non-interactive maps.

Maximizing the map when you need it

Many users in our user studies said they found small embedded maps on mobile devices hard to interact with and they preferred to interact with a larger map. To address this request, we've made the fullscreen control visible by default on mobile devices. The fullscreen control allows the user to make the map larger. When the map is in fullscreen mode, the user can pan the map using one finger. As a developer, you can enable or disable fullscreen control, by setting the fullscreenControl option to true or false in the MapOptions object. When the map is in fullscreen mode, one finger will always pan the map, since there is no surrounding page to pan.

The default setting of fullscreenControl is true on mobile browsers, and false on desktop browsers, since the problem of maps being too small for interaction usually only occurs on mobile devices.

The fullscreen control allows the user to make the map larger for easier interaction

View this demo on a mobile device to see how the fullscreen button and cooperative gesture handling mode (or auto gesture handling mode on a scrollable site) will look to your users.

For more information on the Google Maps JavaScript API, please see the developer documentation or review the latest release notes.

A big thank you to all the developers who use the Google Maps JavaScript API and provide feedback via the issue tracker. Getting feedback from developers is vital for us to be able to keep improving our products, so if you have any bug reports or feature requests, please let us know.

Posted by Elena Kelareva, Product Manager, Google Maps APIs

Key Improvements for Your Maps API Experience

Maps Devel — Tue, 04 Oct 2016 20:31:00 +0000

Originally posted on the Google Developers blog.
Posted by Israel Shalom, Product Manager

Here at Google, we’re serving more than a hundred APIs to ensure that developers have the resources to build amazing experiences with them. We provide a reliable infrastructure and make it as simple as possible so developers can focus on building the future. With this in mind, we’re introducing a few improvements for the API experience: more flexible keys, a streamlined 'getting-started' experience, and easy monitoring.

Faster, more flexible key generation

Keys are a standard way for APIs to identify callers, and one of the very first steps in interacting with a Google API. Tens of thousands of keys are created every day for Google APIs, so we’re making this step simpler -- reducing the old multi-step process with a single click:

You no longer need to choose your platform and various other restrictions at the time of creation, but we still encourage scope management as a best practice:

Streamlined getting started flow

We realize that many developers want to get straight to creation and don’t necessarily want to step into the console. We’ve just introduced an in-flow credential set up procedure directly embedded within the developer documentation:

Click the 'Get a Key' button, choose or create a project, and then let us take care of enabling the API and creating a key.

We are currently rolling this out for the Google Maps APIs and over the next few months we'll bring it to the rest of our documentation.

API Dashboard

We’re not just making it easier to get started, we’re simplifying the on-going usage experience, too. For developers who use one or more APIs frequently, we've built the new API Dashboard to easily view usage and quotas.

If you’ve enabled any APIs, the dashboard is front and center in the API Console. There you can view all the APIs you’re using along with usage, error and latency data:

Clicking on an API will jump to a detailed report, where you’ll see the traffic sliced by methods, credentials, versions and response code (available on select APIs):

We hope these new features make your API usage easier, and we can't wait to see what you’re going to build next!

A sizzling open source release for the Australian Election site

Maps Devel — Tue, 27 Sep 2016 16:58:00 +0000

One of the best parts of my job at Google is 20 percent time. While I was hired to help developers use Google’s APIs, I value the time I'm afforded to be a student myself—to learn new technologies and solve real-world problems. A few weeks prior to the recent Australian election an opportunity presented itself. A small team in Sydney set their sights on helping the 15 million voters stay informed of how to participate, track real-time results, and (of course) find the closest election sausage sizzle!

Our team of designers, engineers and product managers didn't have an immediate sense of how to attack the problem. What we did have was the power of Google’s APIs, programming languages, and Cloud hosting with Firebase and Google Cloud Platform.

The result is a mish-mash of some technologies we'd been wanting to learn more about. We're open sourcing the ausvotes.withgoogle.com repository to give developers a sense of what happens when you get a handful of engineers in a room with a clear goal and a immovable deadline.

The Election AU 2016 repository uses:

Go from Google App Engine instances to serve the appropriate level of detail for users' viewport queries from memory at very low latency, and
Dart to render the live result maps on top of Google Maps JavaScript API using Firebase real time database updates.

A product is only as good as the attention and usage is receives. Our team was really happy with the results of our work:

406,000 people used our maps, including 217,000 on election day.
We had 139 stories in the media.
Our map was also embedded in major news websites, such as Sky News.

Complete setup and installation instructions are available in the Github README.

Posted by Brett Morgan, Developer Programs Engineer

Custom map styling with the Google Maps APIs on Android and iOS

Maps Devel — Wed, 21 Sep 2016 21:49:00 +0000

Your app, your map style. For iOS and Android.

Cross-platform custom map styling is here—change the color palette of your maps, hide labels, vary road density and toggle points of interest. Your maps can now match your brand and style across your website and your apps!

The Google Maps APIs now support you in creating beautiful styled maps for your Android and iOS apps as well as your website using the same JSON style object.

Easily create your style

The new Google Maps APIs Styling Wizard helps you to create a map style in a few clicks. Use one of our pre-built styles or create your own style from scratch.

Access advanced options for further control over every available aspect of your map style including visibility, fills & stroke weight.

Use the styling wizard for point and click custom style creation.

Show what’s important, hide the rest

Custom map styling provides you with ways to tailor your map for a particular use case. Got your own transit stops and want to turn the Google ones off? We’ve got you covered. Want to hide highways and highlight water features? Done. You can control the visibility of labels, landscapes, transit icons, points of interest, roads and more to create the look that reflects your brand and purpose. See the samples for Android, iOS and JavaScript.

Both the iOS and the Android SDKs now support business points of interest as well; this means you’ll now see hotels, restaurants and shops on your maps. They’ll only be visible when you compile with the latest SDKs and you can control their visibility via styling.

Style once, use on any platform

When you’re happy with your new map style, you can export & use the same JSON styling object in our iOS, Android and JavaScript Maps APIs. The Styling Wizard also provides the URL for you to use with the Google Static Maps API.

To enable a custom style in your app or website, take a look at the code samples: Android, iOS & JavaScript.

You can distribute the styles with your app, fetch them dynamically, and even change them at runtime.

Custom styles now work on native iOS and Android apps as well as the web.

The Android and iOS release notes contain details of bugs fixed as well as the custom basemap styling features mentioned in this post. Read the Maps APIs styling guides for Android, iOS and JavaScript, and watch the Styling your Maps Geocast (embedded below).

A big thank you to Android and iOS developers everywhere for using the Google Maps Android API and the Google Maps SDK for iOS and submitting feedback via the issue tracker. We heard you!

Share your styled basemaps on Twitter and G+ via #mapstyle and show us what you’ve done!

Posted by Megan Boundey, Product Manager, Google Maps Mobile APIs

Making the most of the Google Maps Web Service APIs

Maps Devel — Thu, 15 Sep 2016 16:31:00 +0000

When it comes to app development, there can be a disconnect between the robust app we intended to build and the code we actually get into a minimum viable product. These shortcuts end up causing error conditions once under load in production.

The Google Maps API team maintains client libraries that give you the power to develop with the confidence that your app will scale smoothly. We provide client libraries for Python, Java, and Go, which are used by thousands of developers around the world. We're excited to announce the recent addition of Node.js to the client library family.

When building mobile applications, it is a best practice to use native APIS like Places API for Android and Places API for iOS where you can, but when you find that your use case requires data that is only available via the Google Maps APIs Web Services, such as Elevation, then using these client libraries is the best way forward.

These libraries help you implement API request best practices such as:

Requests are sent at the default rate limit for each web service, but of course this is configurable.
The client libraries will automatically retry any request if the API sends a 5xx error. Retries use exponential back-off, which helps in the event of intermittent failures.
The client libraries make it easy to authenticate with your freely available API Key. Google Maps APIs Premium Plan customers can alternatively use their client ID and secret.
The Java and Go libraries return native objects for each of the API responses. The Python and Node.js libraries return the structure as it is received from the API.

The client libraries can help you in a variety of ways. One of them is exposing the result sets in a format that makes most sense for the language in question. For example, the Java and Go client libraries include object hierarchies that are type-safe representations of the potential results for each API. This allows you to write code in the comfort of your editor with the knowledge that the compiler will catch any mistakes.

With 3 million apps and websites using Google Maps APIs, we have an important tip for ensuring reliability when using web services: call APIs from a server rather than directly from Android or iOS. This secures your API key so that your quota can't be consumed by a bad actor, along with being able to add caching to handle common requests quickly.

A server instance acts as a proxy that takes requests from your Android and iOS apps and then forwards them to the Google Maps Web Service APIs on your app’s behalf. The easiest way to create a server side proxy is using the Google Maps Web Service client libraries from Google App Engine instances. For more detail, please watch Laurence Moroney’s Google I/O 2016 session “Building geo services that scale”.

You can learn more about the Google Maps API web services in our documentation. The easiest way to use these APIs and follow best practices is to use the Client Libraries for Google Maps Web Services. Download the client libraries for Java, Python, Go or Node.js from Github to start using them today!

Posted by Brett Morgan, Developer Programs Engineer

New JavaScript Street View renderer brings rendering improvements and better mobile support

Maps Devel — Thu, 18 Aug 2016 00:05:00 +0000

Street View is one of Google Maps’ most loved features, providing users with a way to explore and experience the world around them. Developers all over the world use Street View in the Google Maps JavaScript API to make their apps more unique and exciting, giving their users a sense of what it’s like to visit a place in real life.

Today we’re making Street View even better, especially on mobile devices, by launching a new Street View renderer in the Google Maps JavaScript API. Read on for the full details of what we’ve improved!

Better display

Smoother Transitions

Transitions from one point to another in Street View now include more animation frames, creating the effect of gliding smoothly to the next location. Transitions in the old renderer looked like jumping from one location to another.

Old renderer	New renderer

Smoother Loading Animations

The old renderer repeats images while loading new content, resulting in a stuttering effect. The new renderer uses lower resolution imagery while loading, resulting in a smoother animation when rotating an image in Street View.

Old renderer	New renderer

Object modeling improvements

Objects in Street View look better in the new renderer because it builds a 360-degree model that considers all possible perspectives. For example, this high rise building has wavy lines in the old renderer, as opposed to crisp lines in the new renderer.

Old renderer	New renderer

In another example: for imagery on an incline, such as a street with a steep hill, the new renderer corrects the objects to be vertical, whereas the old renderer would have shown the objects at an angle.

Old renderer	New renderer

Better mobile support

WebGL imagery

The new renderer uses WebGL (on browsers that support it) which results in a higher frame rate and better rendering, especially on mobile devices. On mobile devices, the old renderer would display a fish-eye projection of the image, whereas WebGL allows us to present a rendered sphere that looks as it would in reality. For example, the street in the image below is straight, but the old renderer made it look curved on mobile devices.

Old renderer	New renderer

Touch support

As mobile web usage grows, users expect familiar touch-based interactions to work everywhere. The new renderer supports the same natural touch-based gestures on mobile which have been available in the Google Maps Android app: pinch-to-zoom and double-tap-to-go. In the old renderer, zooming was only available through the +/- buttons, and movement was only possible by clicking the arrows on the ground.

Motion tracking on mobile devices

Mobile devices give developers the opportunity to provide their users with more natural ways to explore and interact with their applications. We’ve enabled support for device orientation events on Street View so that users on mobile devices can look around in Street View by moving their phone. Developers have the option to turn this off if they prefer. Please see the developer documentation for more details, or open the documentation link on a mobile device to see motion tracking in action.

Better controls

X Forward

When using a desktop device with a mouse or trackpad, users will see a small "X" at the cursor location that indicates the next camera location if they choose to move forward. Arrows indicate the direction of movement. Wall rectangles identify the direction the camera will point towards.

Next image targets	Next centered image target

Cleaner street names, labels and targets

Street names and labels are now separated from controls, removing overlap issues and allowing for clean display in right-to-left and left-to-right languages.

Old renderer	New renderer

We hope you enjoy using the new and improved Street View renderer! Also a big thank you to all the developers who use the Google Maps JavaScript API and provide feedback via the issue tracker. Getting feedback from developers is vital for us to be able to keep improving our products, so if you have any bug reports or feature requests, please let us know!

For more information on Street View in the Google Maps JavaScript API, please see the developer documentation.

Posted by Elena Kelareva, Product Manager, Google Maps APIs

Keep users focused on what’s important with the latest Google Maps Android API

Maps Devel — Mon, 01 Aug 2016 23:44:00 +0000

Released today, the latest version of the Google Maps Android API includes more developer requested features: you can now track camera movements more accurately via our new camera listeners, set the minimum & maximum zoom levels on your map, and restrict the user’s panning to particular lat/lng bounds of the camera target. In addition, we’ve added a new marker Tag property so you can now associate your own data object with a marker.

Track camera movements more accurately

As one of our top requests, developers have been asking for a better way to track camera movements and the ability to see why the camera is moving, whether caused by user gestures, built-in API animations or developer controlled movements [Issue 4636]. Our new camera change listeners support you in doing this. Your app can now receive notifications for camera start, ongoing, and end events.

See the developer’s guide to camera change events and take a look at this code sample which shows you how to detect when the user drags the map, and draws a line to track this movement when it happens.

Control the zooming, panning and scrolling experience

Have you ever wanted to be able to control how much your user can zoom in and out and pan around on your map so that you can more tightly control the experience? Or have you got tile overlays only for zoom levels 15 through 20 and wish you could limit the zooming capability of both the map and your tile overlays to those particular levels?

You can now set the min and max zoom levels on your map by using GoogleMap.setMinZoomPreference() and GoogleMap.setMaxZoomPreference() [Issue 4663]. These zoom levels will also apply to any tile overlays you have on your map.

In addition, you can also constrain the lat/lng center bounds of the focal point of the map (the camera target) so that users can only scroll and pan within these bounds using GoogleMap.setLatLngBoundsForCameraTarget(). This is awesome if you want your users to stay within the map area of your tile overlays, or you wish to confine the map in your app to a particular local area.

Pan and zoom limits on a map for Adelaide, a beautiful city in South Australia

See the developer’s guide to learn more about setting boundaries on the map as well as this code sample.

Marker tags

Does your app cater for different types of markers and you want to treat them differently when a user taps on them? Or do you want to assign priorities to your markers? The new marker Tag property allows you to associate whatever data object you like with a marker, supporting you in doing this and more [Issue 4650].

A big thank you to Android developers everywhere for using the Google Maps Android API and submitting feedback via the issue tracker.

Our release notes contain details of bugs fixed as well as the features mentioned in this post. Take a look and start using our new features today!

Posted by Megan Boundey, Product Manager, Google Maps Mobile APIs

Google Places API for iOS & Google Maps SDK for iOS are now in separate CocoaPods

Maps Devel — Tue, 26 Jul 2016 00:27:00 +0000

In today’s release, the Google Places API for iOS 2.0 and the Google Maps SDK for iOS 2.0 are now in separate CocoaPods. For developers who only use the Google Places API for iOS, this will significantly reduce the binary size of their app.

What does this mean for me? What do I have to do?

Nothing immediately for your current implementation, but we strongly suggest that you upgrade within the next year to the new Google Maps SDK for iOS 2.0 and Google Places API for iOS 2.0. The Google Maps for iOS SDK Version 1.x will become unsupported in one year’s time.

If you are using the Standard Plan Google Maps SDK for iOS 1.x, and haven’t specified a version in your podfile, you will be automatically upgraded to the new Google Maps SDK for iOS 2.0 when you run ‘pod update’. If you use any Places functionality, we’ve created this migration guide for the Places API to step you through the process of migrating to the new Google Places API for iOS 2.0.

In addition, we’ve documented how to extract all the frameworks (Maps, Places) from the relevant CocoaPods so you can manually include the SDKs in your project rather than using CocoaPods if you wish. [Issue 8856]

What does this mean for Premium Plan Maps SDK customers?

There is no longer a separate Google Maps Premium Plan SDK. Instead it has been replaced with the new streamlined Google Maps SDK for iOS 2.0 for both Standard and Premium Plan developers.

We’ve created a Premium Plan migration guide that will step you through the process of migrating to the new Google Maps SDK for iOS 2.0. We’ve also documented how to extract the frameworks from the CocoaPods so you can manually include the SDKs in your project if you’d prefer that. Your Enterprise Maps key will continue to work, as will your Premium Plan.

Please note:
The Google Maps SDK for iOS Premium Plan SDK 1.13.2 (current version) will be supported for one year during which time we suggest you upgrade to the new streamlined Google Maps SDK for iOS 2.0.

Take a look at our release notes and start using version 2.0 today!

Posted by Megan Boundey, Product Manager, Google Maps Mobile APIs

I/O session: Location and Proximity Superpowers: Eddystone + Google Beacon Platform

Maps Devel — Mon, 25 Jul 2016 15:05:00 +0000

Bluetooth beacons mark important places and objects in a way that your phone understands. Last year, we introduced the Google beacon platform including Eddystone, Nearby Messages and the Proximity Beacon API that helps developers build beacon-powered proximity and location features in their apps.

Since then, we’ve learned that when deployment of physical infrastructure is involved, it’s important to get the best possible value from your investment. That’s why the Google beacon platform works differently from the traditional approach.

We don’t think of beacons as only pointing to a single feature in an app, or a single web resource. Instead, the Google beacon platform enables extensible location infrastructure that you can manage through your Google Developer project and reuse many times. Each beacon can take part in several different interactions: through your app, through other developers’ apps, through Google services, and the web. All of this functionality works transparently across Eddystone-UID and Eddystone-EID -- because using our APIs means you never have to think about monitoring for the individual bytes that a beacon is broadcasting.

For example, we’re excited that the City of Amsterdam has adopted Eddystone and the newly released publicly visible namespace feature for the foundation of their open beacon network. Or, through Nearby Notifications, Eddystone and the Google beacon platform enable explorers of the BFG Dream Jar Trail to discover cloud-updateable content in Dream Jars across London.

To make getting started as easy as possible we’ve provided a set of tools to help developers, including links to beacon manufacturers that can help you with Eddystone, Beacon Tools (for Android and iOS), the Beacon Dashboard, a codelab and of course our documentation. And, if you were not able to attend Google I/O in person this year, you can watch my session, Location and Proximity Superpowers: Eddystone + Google Beacon Platform:

We can’t wait to see what you build!

About Peter: I am a Product Manager for the Google beacon platform, including the open beacon format Eddystone, and Google's cloud services that integrate beacon technology with first and third party apps. When I’m not working at Google I enjoy taking my dog, Oscar, for walks on Hampstead Heath.

Announcing marker clustering in the Google Maps SDK for iOS Utility Library

Maps Devel — Tue, 19 Jul 2016 01:02:00 +0000

Today we’ve added marker clustering to the Google Maps SDK for iOS Utility Library! This much-requested feature is now available for iOS in addition to Android and JavaScript.

Do you ever feel that your map just has too many markers on it, making it feel cluttered and hard to comprehend? Or, perhaps you want to show where the popular restaurants are in your city, but you still want your map to look clean?

Marker clustering supports you in doing this. As the zoom levels of the map change, you can aggregate markers, indicating clearly to your users exactly where those popular restaurants are located. As your user zooms in, the markers progressively split out until all of the individual markers are displayed.

Using the new marker clustering feature in the Google Maps SDK for iOS Utility Library is an easy 4 step process:

Add ‘Google-Maps-iOS-Utils’ to your Podfile
Instantiate the GMUClusterManager
Implement the GMUClusterItem protocol for your marker objects
Add the marker objects to the cluster manager

We provide the default algorithm, renderer and icon generator to support you in doing this. In addition, you can also fully customize each of these by extending the default implementations, or by providing your own implementation of these protocols: GMUClusterAlgorithm, GMUClusterRenderer, GMUClusterIconGenerator.

Take a look at the documentation and demo samples, and start using marker clustering in the Google Maps SDK for iOS Utility Library today!

Posted by Megan Boundey, Product Manager, Google Maps Mobile APIs

I/O session live: Building geo services that scale

Maps Devel — Thu, 14 Jul 2016 18:57:00 +0000

Posted by Laurence Moroney, Developer Advocate at Google

While at Google I/O, l had the opportunity to present the session ‘Building geo services that scale’. I’m pleased to share it more broadly for those of you who were not able to be there in person:

Building geo services that scale
Not all map and geo applications run entirely on your mobile device. Perhaps you want to protect your keys or other API access data from reverse engineering by putting them in the cloud, or you have custom business logic that you run on your server that you don't want to distribute via mobile. To protect your keys and API access data you'll need to operate some kind of service. In this session you'll learn how to build that service on the Google Cloud Platform and consume it in a mobile application that uses the Google Maps APIs.

About Laurence: I am a Developer Advocate at Google, working on mobile services, specializing in cross-platform developer technologies. As the host of 'Coffee with a Googler' on the Google Developers channel I’m able to meet with some of those most creative and inspiring developers at Google and learn about the projects they’re leading. When I’m not Googling, I’m involved in many things, including working on the revival comics for the Stargate TV shows, and enjoying the geek cred that this brings.

Behind the Australian Elections Map: Mapping democracy in real-time

Maps Devel — Fri, 01 Jul 2016 23:53:00 +0000

It's elections time in Australia! With 94% of eligible Australians registered to vote, there will be close to 15 million participants this year.

Googlers in the Sydney office were recently chatting about the upcoming election and realized we all had similar questions: what were the results last cycle, where are the closest polling stations, and where do we look for real-time results on election day? Friends and family were asking the same questions, so we decided to build a solution using Google Maps APIs, Firebase, Google App Engine, Google Cloud Compute, Angular 2, the Google Translation Toolkit and Go.

The aim of the election map was to provide all the information that Australians would need to participate in the voting process. We wanted to cover pre-, mid- and post-election needs, including:

A polling place locator with searchable addresses, suburbs, and electorates
Directions and navigation to the polling places, accessible via the election map
Real-time election results once polling has closed and counting has started
The ability to share and embed maps.

UX mockup: map and fake election results using testing data

The pre-election map displays static electorate data, polling booths and ballot papers. It also indicates who won the electorate in the last 2013 election. To do this, we sourced 2013 election data from the Australian Electoral Commission (AEC) and stored it in a Go application intended for Google App Engine so that it could be served to the website frontend. The AEC provided us with data about electorate boundaries and polling place locations.

The website frontend was built using Angular 2 and we've used several open source projects, including GDAL, mapshaper and a point clustering library. These libraries allowed us to send only the required details for a user's viewport, while keeping data usage reasonably low and reducing visual noise.

Polling location information with address and directions intent

Day-of website visitors will have the ability to search for polling stations and learn about what services are available at each location (accessibility, sausage sizzle and/or cake stand). We sourced the sausage sizzle and cake stand data from Democracy Sausage and Snagvotes. We used the polling place ID to match these to the AEC polling place identifiers. We built a small Google Compute Engine app which sources the data from our sausage sizzle data sources and broadcasts it out to our live web application using Firebase Realtime Database.

Autocomplete searches for polling locations

To enable the search functionality, we use two different services in parallel. We first attempt to match the search query against the electorate list on the client. We also use the Google Maps Javascript API Places Library with Autocomplete to provide suggestions of what users might be searching for, including suburbs, places of interest and addresses. This gives our users the ability to select recommendations instead of having to type full queries.

Voters also need to plan their trip to the polling booths. We relied on Google Maps' existing real-time traffic information and turn-by-turn directions to provide directions functionality.

After 6pm on election night and when votes begin to be counted, we will switch the site to show real time election results. To do this, again we are using the AEC data feed and Firebase Realtime Database.

To make it really easy for people to visualize the elections results we employed a hemicycle (half donut circle) in the left sidebar to display real-time results. We also added "share" and "embed" features so people and media can easily share information about the election.

This project was put together by a cross-functional group of Google volunteers including software engineers, UX Designers, product managers and the legal and marketing teams. We'll all be voting on July 2nd, cake in hand. See you at the polls!

About Taylah: I am an Associate Product Manager at Google’s Sydney office where I work on Google Maps for Android Auto. I love working on Google Maps as you get to help millions of people explore the world every day. When I’m not at work, I love exploring beautiful places, shopping in thrift stores, painting and spending time with my family and friends.

Kick off your summer travels with these new Google Maps features

Lat Long — Thu, 30 Jun 2016 13:00:00 +0000

The weather’s heating up, kids are out of school, and that means only one thing: summer’s officially here. Summer brings weekend road trips, faraway escapes and all kinds of getaways in between. And with the latest update to Google Maps, we're introducing two new features to get you where you’re going and help you remember your travels in a brand new way.

Road trip warriors can now get multi-stop directions in Google Maps on Android (coming soon to iOS). Just open the app, enter a destination, tap the corner menu, and then click “Add a stop”. To rearrange the order of your stops, tap and hold the three dot menu to the left of “Add stop” and drag it to the position you want – you can even search for types of places like gas stations or restaurants like you normally would. Once you’ve added all your stops, tap “Done” and your multi-stop route is complete. When you enter navigation mode you’ll have the same seamless driving experience you’re used to, whether you’re going from errand to errand or hitting scenic spots along Route 66.

A lot of the fun of traveling is the memories created while exploring new places with friends, family or even solo. Pictures are a traditional way to remember those moments, but now Your Timeline users on Android can preserve their travel memories and info in a new way. Google Maps users with Location History enabled can open Your Timeline, select a date from their recent vacation or everyday life and add notes to help remember what they did that day—or save important notes for later.

No matter where your travels take you this summer and beyond, these new Google Maps features will get you there and help keep track of all the memories you make along the way.

Posted by Liz Davidoff, Communications Manager, Google Maps

Marker zIndex and more come to the Google Maps Android API

Maps Devel — Mon, 27 Jun 2016 23:36:00 +0000

Released today, the latest version of the Google Maps Android API includes several popular developer requested features including the ability to order the display of markers on the map with the new marker zIndex property, the ability to set the transparency of your tile overlays, and a new circle click listener.

Marker zIndex

Marker zIndex is one of the most requested features on our issue tracker - today's release gives you the ability to control the order in which markers are displayed on the map [Issue 7762]. This gives you control over which tap target your user is most likely to hit by setting the zIndex property on each marker. The markers are drawn in order of the zIndex, with the the highest zIndex marker drawn on top.


Before: No control over the marker zIndex. The plane will be obscured by some of the cars.	After: The zIndex of the plane is set to be the highest. The plane is now always visible on top.

Tile overlay transparency

Just like ground overlays, you can now set the transparency of your tile overlay to allow the basemap to show through [Issue 4765].

Circle clickability

Just like polylines and polygons, apps compiled with the latest release can now have circle clickability via the OnCircleClickListener. You can enable or disable the clickability of circles by calling setClickable(boolean) on the relevant circle.

getMapAsync() now required

In December 2014 we deprecated getMap() in favor of getMapAsync(). From this release onwards, you'll need to use getMapAsync() in order to compile your apps. Note that existing apps in the wild on your users' devices won't be impacted by this change as the getMap() method still exists within the Google Play Services APK that is delivered to Android devices.

If you haven't already done so, follow these steps:

Here's a sample fragment using the deprecated getMap(), with a fictitious doStuff() method that would implement the fragment's initial logic:

import android.os.Bundle;
 import android.support.v4.app.FragmentActivity;
 import com.google.android.gms.maps.GoogleMap;
 import com.google.android.gms.maps.SupportMapFragment;

 public class MainActivity extends FragmentActivity {

     private GoogleMap mMap;

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         mMap = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)).getMap();
         doStuff();
     }

 }

The above however was error prone, since getMap() could potentially return null. Here's the same sample using getMapAsync():

import android.os.Bundle;
 import android.support.v4.app.FragmentActivity;
 import com.google.android.gms.maps.GoogleMap;
 import com.google.android.gms.maps.OnMapReadyCallback;
 import com.google.android.gms.maps.SupportMapFragment;

 public class MainActivity extends FragmentActivity implements OnMapReadyCallback {

     private GoogleMap mMap;

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)).getMapAsync(this);
     }

     @Override
     public void onMapReady(GoogleMap map) {
         mMap = map;
         doStuff();
     }

 }

You can see we now implement the OnMapReadyCallback interface which defines the onMapReady() method, which will be called when the GoogleMap instance is ready. We’ve also moved the call to the fictitious doStuff() method into onMapReady(), since this is where we now want to start the fragment's initial logic.

A big thank you to Android developers everywhere for using the Google Maps Android API and submitting feedback via the issue tracker.

Our release notes contain details of bugs fixed, deprecation notices, as well as the features mentioned in this post. Take a look and start using our new features today!

Posted by Megan Boundey, Product Manager, Google Maps Mobile APIs.

Building for Scale: Updates to Google Maps APIs Standard Plan

Maps Devel — Wed, 22 Jun 2016 22:51:00 +0000

Eleven years after a developer first reverse-engineered a Google Map, there are more than three million location-informed apps and websites generating billions of requests daily, all powered by Google Maps APIs. From unicorns to passion projects to public service, the power of maps and location data is limited only by the creativity of developers.

The Internet landscape has dramatically shifted from desktops to mobile devices in the last decade, and as a result, our services have evolved to meet the needs of our developers and their users. More devices means exponentially more requests, and hundreds of millions of global users are just coming online. Therefore, today we are announcing a few updates to bring more simplicity and consistency to our Standard Plan limits and pricing.

As of June 22, 2016 we are making the following changes to the Google Maps APIs Standard Plan:

We no longer support keyless access (any request that doesn't include an API key). Future product updates are only available for requests made with an API key. API keys allow us to contact developers when required and help us identify misbehaving implementations.
We have implemented a simple 25,000 map loads per day free limit to new Google Maps JavaScript API, Static Maps API, and Street View Image API implementations. The confusing 90-consecutive-day grace period for these APIs is being retired on October 12, 2016. With this change, developers can predictably plan for growth while media sites and US nonprofits can request more quota at no charge via our dedicated support programs.
We have reduced the daily map load maximum limit you can purchase for Google Maps JavaScript API, Static Maps API, and Street View Image API from 1,000,000 to 100,000 requests per API.* We believe higher-volume developers are best served with a Premium Plan license, which includes technical support and a Service Level Agreement, and with this change we've also created consistency between Standard Plan quotas across our maps and web service APIs.
We now count Google Maps JavaScript API client-side requests towards the daily limit of the associated web service API.*

The new policies will apply immediately to all Maps API implementations created on or after June 22nd, 2016.

Existing applications have been grandfathered based on their current usage to ensure that they continue to function both now and in the future. We will also be proactively contacting all existing API key users who, based on usage growth patterns, may be impacted in the future. If you’re an existing user, please take the time to read our Policy Update for Standard Plan summary for details on how each of these changes might affect your implementation.

Posted by Ken Hoetmer, Product Manager, Google Maps APIs

* Exceptions may apply for implementations that were exceeding new quotas prior to June 22, 2016.

Learn about developing geo applications over coffee with Ankur Kotwal and Ken Hoetmer

Maps Devel — Tue, 21 Jun 2016 16:19:00 +0000

Posted by Laurence Moroney, Developer Advocate at Google

While at Google I/O, I had a chance to sit down for a cup of coffee with Ankur Kotwal, Developer Advocate at Google and Ken Hoetmer, Product Manager for the Google Maps APIs. Both had an interesting perspective on how maps have evolved and where they are headed.

In Ankur’s session we discussed technologies beyond the visualization aspects of maps, including the Directions API, Places API and Roads API. He highlighted innovative ways developers are using Google Maps APIs including VR, marker clustering and heatmaps. We also spoke about Santa Tracker, which Ankur has been a part of for four years (he also revealed what Santa likes to do during his time off). Ankur announced the new Google Maps APIs Beta program, so if you have not signed-up, head over to the site to apply.

Learn about developing Geo applications over Coffee with Ankur Kotwal

While speaking with Ken, we discussed how he started working with maps and the Google Maps API as well as how he eventually landed at Google on the Sydney maps team. Ken spoke about how use cases have evolved from interactive maps to more powerful applications and insights driven by location information made available through the APIs. He shared details about some newer APIs including native iOS and Android Places API, Roads API, Directions API and Predictive Travel Time (estimating travel time and routes based on now or in the future). He also highlighted some notable location-based intelligence use cases including Uber, GoJek, Dash Labs and the city of Sydney.

Google Maps APIs and Coffee with Product Manager Ken Hoetmer

More descriptive JavaScript console error messages

Maps Devel — Thu, 16 Jun 2016 17:49:00 +0000

Posted by Kosuke Mizubayashi, Technical Solutions Engineer at Google

Over the past few months we've rolled out several JavaScript console error message improvements designed to help developers implement Google Maps JavaScript API into web apps. Our goal was to:

Give developers more descriptive error messages
Provide developers with a suggested solution to resolve the error
Avoid popups for displaying error messages
Create a positive experience for end-users in the event an error occurs

How do developers usually use the JavaScript console? When? Why?
Web developers use browser tools to develop and debug their applications. They can find various messages in the JavaScript console to which their application, libraries or APIs write. For users of our Google Maps JavaScript API, we have returned error messages in the JavaScript console for some types of Maps API errors. But, these messages were often not descriptive enough for web developers to investigate the issue and find solutions.

What happened when users saw the old error messages?
Our previous popup error messages showed up on the top of the web page. This JavaScript alert prevented users from interacting with the page until the “OK” button was clicked, even if they were not interacting with the map. We served 4 basic error messages that pointed to the general troubleshooting page of our website.

What do developers and users see now?
We now display 21 different error messages in the console —you can see the full list in our developer documentation. In addition, we've provided direct links from specific errors to self-service solutions on the developer site. We've also simplified the error messages displayed to end users -the improved error appears in the map div itself, allowing users to interact with the rest of the page even if the map load fails.

We hope these changes will improve your implementation and interactions with your end users.

About Kosuke: I’ve been a Technical Solutions Engineer at Google for 6 years. I enjoy working on the Google Maps APIs because there is always a new discovery on maps. Outside of Google, I love beer, especially after skiing in the mountains.

Google I/O session live: Streamlining developer experiences with the Google Maps APIs

Maps Devel — Tue, 14 Jun 2016 18:18:00 +0000

Posted by Ankur Kotwal, Developer Advocate at Google

While at Google I/O, Laurence Moroney and I had a chance to present our session titled ‘Streamlining developer experiences with the Google Maps APIs’. We’re pleased to share it more broadly for those of you who were not able to be there in person:

Streamlining developer experiences with the Google Maps APIs
The Google Maps APIs provide a seamless experience for developers of all levels. Some want to offer a map or directions but don't want to build these things themselves; this can be achieved with just a few lines of code. Other developers prefer to integrate natively with off-the-shelf widgets. Finally, some developers want complete control over every aspect of the presentation. This session highlights the Maps APIs that represent the full gamut of the developer experiences, enabling you to get going immediately and scale as necessary. You'll see how widgets and services can be added over time with a suite of Maps APIs, services and libraries.

About Ankur: I am a Developer Advocate at Google experienced in building on Android and the Google Maps API. I am based out of the Google Sydney office and lead the Geo Developer Relations & Next Billion Users Developer Relations team to inspire developers towards building on the Google developer platform. When I’m not at Google inspiring other developers, I enjoy spending time with my kids.

Introducing the Google Maps APIs Udacity course

Maps Devel — Wed, 08 Jun 2016 21:46:00 +0000

Posted by Emily Keller, Technical Program Manager for Google Maps APIs

The Google Maps Operations team gets to work with thousands of developers each year to create great user experiences and powerful analytics built on maps and location data. We drew from these experiences to create a brand new Google Maps APIs course, in collaboration with Udacity, that teaches developers best practices when using our web APIs.

The new course, available today for free, gives you step-by-step tutorials that demonstrate how to integrate maps and location features into your website, and how to get useful location related data using various Web Service APIs.

You’ll walk through building a real-estate listings site using a uniquely styled Google map, data visualization, and street view panoramas. You’ll practice developing location-related features: calculate distance between locations, get directions, and view places of interest data.

You’ll also see other examples of Google Maps APIs in action and learn how to secure and monitor your deployment using the Google APIs Console. At the end of the course, you’ll have built your first map-enabled site and be ready to create your own projects using location data, services, and maps!

Whether you’re new to Google Maps APIs or just want a refresher, head over to Udacity to learn about how to start adding location features and map visualizations into your websites, today!

About Emily: I happily joined Google in September, 2015. I love working with the Google Maps APIs because they are easy to build with and enable end users to have an intuitive, familiar experience in any site or app. Outside of Google I like to play Zelda, eat pizza and drink coffee with my dog.

Google I/O session live: Understand your Place in this world

Maps Devel — Tue, 07 Jun 2016 20:57:00 +0000

Posted by Florian Bertele, Product Manager on the Google Maps APIs team

At Google I/O, Ravi Palanki, Android Place API technical lead and I presented our session titled ‘Understand your Place in this world’. Even if you were not able to attend Google I/O in person, you can now watch our session:

Understand your Place in this world
Humans navigate a world made up of places with names, addresses and phone numbers—not lat/long coordinates. The Google Places API enables an app or website to present location data to users in a human-centered fashion. In this session we shared how you can use the Places API to discover your environment. I walked the audience through the main use cases and Places API functionalities, across mobile and web. We also showed off some newly-released mobile widgets, and Ravi did a deep-dive into the benefits of the mobile platform, such as optimization for mobile device battery life and increased device accuracy. This session is a great starting point to learn how the Places API can make all your apps -- not just map-centric ones -- smarter.

With the Google Places API you get data from the same database used by Google Maps and Google+ Local. Places features more than 100 million businesses and points of interest that are updated frequently through owner-verified listings and user-moderated contributions.

Use the power of mobile to give your users contextual information about where they are, when they’re there with the Places API for Android.
Search for and retrieve rich information about local businesses and points of interest, available on every screen with the Places API Web Service.
Add autocomplete to any application, providing type-ahead location-based predictions like the search on Google Maps.

I am a product manager on the Maps API team. In my role, I focus on the Places API across all platforms and geographies. When I’m not at Google, I love running coastal trails, playing the piano and enjoying the fantastic lifestyle in Sydney!

One Day in at Google I/O

Maps Devel — Thu, 19 May 2016 15:32:00 +0000

Posted by Ken Hoetmer, Product Manager, Google Maps APIs

Day 1 done! We had a great first day at Google I/O—more than 800 developers visited our Geo sandbox to check out apps, play with 360 degree cameras and most importantly, chat with our engineers, product managers, and developer advocates about the apps they’re building.

The Geo sandbox features Sugarbear, a 1959 PD-4104 General Motors Coach that measures 35’ long by 8’ wide with a diesel engine outfitted for biodiesel. Sugarbear made an epic trip across the USA after last year’s I/O and we’ve brought her back this year for more demo fun. You can engage with interactive maps experiences and check out customer applications inside the bus. Climb Yosemite's El Capitan, calculate your solar potential with Project Sunroof, and see how Nest and the Environmental Defense Fund use location data to make our lives better. Sugarbear also features Google Maps APIs customers Trucker Path, Zendrive, Postmates, GTX Corp and Vagabond.

The Google I/O event shuttle buses are also being tracked and visualized in real time by an app we built using Firebase and Google Maps APIs. Within the Geo sandbox you can check out the app on the big screen and chat with the developers about how it works on the inside (hint: ask for Brett).

Geo also hosted one session yesterday: Location and Proximity Superpowers: Eddystone + Google Beacon Platform and we have several additional sessions on Thursday and Friday, including Understand your Place in this world and Building geo services that scale.

Finally, don’t forget about our office hours—scheduled for Thursday, May 19 at 4pm. We’ll be in the tent for an hour...bring your Maps and Location questions for our Product Managers and Developer Advocates.

Google Maps APIs Sessions Set for Google I/O

Maps Devel — Tue, 17 May 2016 14:40:00 +0000

Posted by Jac de Haan, Developer Marketing for the Google Maps APIs

Google I/O starts in just 24 hours! We’re looking forward to three days of insightful developer conversations, amazing technology and great weather. This year, Google Maps APIs engineers, technical support engineers, product managers, ux-ers, technical writers and developer advocates are traveling from Sydney, New York and Seattle to spend time in the Geo sandbox and demonstrate the power of our APIs. We'll also hold Office Hours to answer your implementation questions.

Here are three of our featured sessions for this year’s event:

Understand your place in this world
May 19, 9:00 AM
Humans navigate a world made up of places with names, addresses and phone numbers—not lat/long coordinates. The Google Places API enables an app or website to present location data to users in a human-friendly fashion. In this session we’ll do a deep dive into how you can use the Places API to discover your environment. We’ll give detailed insights into how to use the APIs on web and mobile, show off some newly-released widgets, and take a look at how you can optimize for mobile device battery life. You’ll learn how the Places API can make all your apps— not just map-centric ones—smarter.

Building geo services that scale
May 19, 2:00 PM
Not all map and geo applications run entirely on your mobile device. Perhaps you want to protect your keys or other API access data from reverse engineering by putting them in the cloud, or you have custom business logic that you run on your server that you don't want to distribute via mobile. To protect your keys and API access data you'll need to operate some kind of service. In this session you'll learn how to build that service on the Google Cloud Platform and consume it in a mobile application that uses the Google Maps APIs.

Streamlining developer experiences with the Google Maps APIs
May 20, 9:00 AM
The Google Maps APIs provide a seamless experience for developers of all levels. Some want to offer a map or navigation but don't want to build these things themselves; this can be achieved with just a few lines of code. Other developers prefer to integrate natively with off-the-shelf widgets. Finally, some developers want complete control over every aspect of the presentation. This session will highlight the Maps APIs representing the full gamut of the developer experiences, enabling you to get going immediately and scale as necessary. You'll see how widgets and services can be added over time with a suite of Maps APIs, services and libraries.

We hope you’re able to attend at least one of these sessions to learn directly from Google Maps APIs experts. And, don’t forget to stop by the Geo sandbox to chat—just look for the big bus! If you’re not able to join us in person this year, you can always keep up with our activities via Twitter or G+.

Get our API Release Notes automagically via RSS

Maps Devel — Thu, 12 May 2016 18:41:00 +0000

Posted by Sarah Maddox, technical writer for the Google Maps APIs

The Google Maps APIs team are keen to ensure that our customers and developer community has the most up to date and useful information about using our APIs. With that goal in mind, we’ve added RSS feeds to the Release Notes for all the Maps and Places APIs.

Until now, if you wanted to see news about our releases, you’d need to visit individual API release notes pages periodically. We don't typically announce bug-fix or other small releases via the blog or social media but these are often critical for segments of our developer community.

You can now subscribe to individual API feeds and receive updates automatically when release notes are published. We'll continue to publish all Release Notes on the website as well. Feeds available today:
Google Maps Android API
Google Maps SDK for iOS
Google Maps JavaScript API
Google Maps Directions API
Google Maps Distance Matrix API
Google Places API for Android
Google Places API for iOS
Google Maps Android API Premium Plan
Google Maps SDK for iOS Premium Plan

I’ve been a technical writer at Google since 2013. I love my job because it gives me the opportunity to play with code and words, and to make them play nicely with each other. Maps are beautiful, and the docs help people weave stories around geography and places.

I’ll be at I/O next week, so I hope to see you there at our Geo sandbox (just look for the bus). Happy mapping!

Advanced marker animations and more with Google Maps SDK for iOS 1.13

Maps Devel — Mon, 04 Apr 2016 17:01:00 +0000

Last week we launched the Google Maps SDK for iOS 1.13. This release includes the ability to create advanced marker animations, the option of auto refreshing info windows, the ability to set the frame rate up to 60 frames per second, further custom styling for the Place Autocomplete widget, and a new mapViewSnapshotReady event.

Advanced marker animations and auto-refreshing of info windows

Ever wanted to have rotating markers or use a grow and glow marker animation?

With the Google Maps SDK for iOS 1.13, we have introduced an iconView property for marker icons, giving you the animation capabilities of a UIView. Because iconView accepts a UIView, you can have a hierarchy of standard UI controls defining your markers, each view having the standard set of animation capabilities. The iconView property supports animation of all animatable properties of UIView except frame and center. Take a look at our documentation to get started.

We've also included the option to auto-refresh info windows, which is particularly useful if you want to use a static web page as info window content but it hasn’t downloaded by the time you create your info window. By using the new marker property tracksInfoWindowChanges, you can have the info window automatically refresh when the static web page loads.

Frame rate up to 60 fps with graceful fallback

You can now take advantage of a new enum, GMSFrameRate, which has three options: kGMSFrameRatePowerSave (15fps), kGMSFrameRateConservative (30fps), and the default kGMSFrameRateMaximum (60fps with 30fps fallback). In order to protect devices that don't handle 60fps well, we do a run-time device model check and the preferredFrameRate is silently downgraded to 30fps when necessary on older devices.

Autocomplete widget styling

In Google Maps SDK for iOS 1.12 we announced the iOS Places autocomplete widget. With the release of iOS 1.13, you can now add further custom styling to your autocomplete widget to create a consistent visual identity.

To set widget UI element colors:

Use the native iOS Appearance Proxy system when possible to globally style UI controls. The Places autocomplete widget will honor these settings.
Use the new SDK methods on widget classes to set colors which the Appearance Proxy system doesn't support.

Our documentation highlights which elements can be customized using the Appearance Proxy, and which can be customized by using the SDK methods.

mapViewSnapshotReady event

We heard your requests to provide a clear signal that all tiles have been rendered and the map has finished loading. In Google Maps SDK for iOS 1.11 we included start/finish events for map tile and Street View panorama rendering.

In this release, we've added a mapViewSnapshotReady event that indicates that the map is stable (tiles loaded, labels rendered, camera idle) and overlay objects have been rendered. This is useful if you want to do a transition away from the map, but need a static image of the map in case you want to transition back. The mapViewSnapshotReady event will ensure that the static image will truly represent the state of the map.

A big thank you to iOS developers for using the Google Maps SDK and submitting feedback via the issue tracker!

Take a look at our release notes and update to Google Maps SDK for iOS 1.13 today.

Posted by Megan Boundey, Product Manager, Google Maps Mobile APIs

Changes and quality improvements in Google Places API Search

Maps Devel — Tue, 16 Feb 2016 17:00:00 +0000

Many of you have been asking for Google Places API search results that more closely reflect those on maps.google.com. With that goal in mind, we’ve integrated the Places API with Google Maps search. We’re pleased to offer more consistent search results across Maps and the Places API, which results in better overall search quality for API responses.

In conjunction with this change, we are also modifying how we support place type restrictions in the Places API web service and JavaScript library. Beginning Feb 16, 2016, we are replacing the types restriction parameter with a new type search parameter. If you have been using the types parameter for Nearby Search, Text Search or Radar Search you will be affected.

Type search works similarly to types restriction, but it only supports one type per request.

Requests using the types parameter and those specifying multiple types (for example, types=hospital|pharmacy|doctor) will continue to return results until Feb 16, 2017, but we do not recommend using multiple types in a search request. After that date, requests with multiple types will no longer be supported. To ensure the best possible search results for your users, we recommend using a single type in search requests.

Using the new type search feature is straightforward. Here is an example of a Text Search request:

https://maps.googleapis.com/maps/api/place/textsearch/json
?type=airport
&location=-33.87,151.21
&radius=5000
&key=

In addition, we are amending the list of supported types. The types establishment, food, health, general_contractor, finance and place_of_worship, will not be available as searchable types from Feb 16, 2017. However these types will still be returned in search and details results.

Posted by Marcelo Camelo, on behalf of the Google Places API team

A look back at Google Maps in 2015

Lat Long — Fri, 01 Jan 2016 01:01:00 +0000

2016 is just around the corner. Before we pop champagne and ring in the New Year, let’s take a look back at the enhancements we’ve made to Google Maps over the past year. From using Google Maps offline to discovering new places with Explore, we’re proud to not only get you from point A to point B quickly and easily, but to also help you explore the world around you with confidence.

Below is a list of the new features you might’ve missed, along with a handy chart showing you where you’ll find them. If you got a new phone this holiday season, now’s the time to give the Google Maps app a go.

2015 Google Maps New Features

2015 is ticking away, but you can take a look back at the places you’ve traveled with Your Timeline.
Always know when your favorite stores are open with up-to-date holiday hours and alerts.
Whether you’re in a parking garage with no signal or traveling in country with expensive data, search for places, get directions, and turn-by-turn navigation–all offline.
Always stay on the fastest route and beat bumper-to-bumper traffic with real-time traffic updates and dynamic re-routing.
Never run low on fuel with up-to-date gas prices in search results and on the map.
Make quick pit stops without long detours–search for places along your route without leaving navigation mode.
Find the best local spots to eat and drink with curated recommendations.
Get all your travel options and compare ETAs across driving, walking, biking and transit–all on one screen.
Get the scoop on when the lines are shortest and shops least crowded by checking businesses’ most popular times–by day, by hour.
Get the lay of the land before you arrive by using Street View thumbnail.
Never miss a bus or train with real-time transit information (schedules, fares, updates) in more than 18,000 cities across 64 countries.
Get directions, turn-by-turn navigation and real-time traffic updates from your wrist with the Google Maps app on Android Wear and Apple Watch.

To see these new features in action, take a look back at our Maps Minutes Holiday Hacks series.

2015 New Features by iOS and Android Availability

Feature	Android	iOS
Up-to-Date Holiday Business Hours and Warnings	X	X
Location Search and Turn-by-Turn Navigation While Offline	X	X
A Look Back at the Places You’ve Visited through “Your Timeline”	X
Real-time Spoken Traffic Alerts	X	X
Gas Prices on Map	X	X
Location Search Without Leaving Navigation Mode	X
Updated “Explore” Experience with New Curated Content	X	X
Compare ETAs on One Screen	X	X
The Most Popular Times to Visit a Business	X	X
Street View Thumbnails	X	X
Real-time Traffic View of Your Route	X	X
Directions and Turn-by-Turn Navigation on Wearables	X (Android Wear)	X (Apple Watch)

Join us in a virtual toast to a New Year of helping you explore and navigate your far away travels as well as your everyday life.

Posted by the Google Maps team

Maps Minutes Hack #8: Set your home and work addresses for easy navigation

Lat Long — Thu, 24 Dec 2015 00:32:00 +0000

Part of our series on how to save time this holiday season with Google Maps.

It’s crunch time. There are holiday parties to attend and last-minute gifts to be bought and wrapped. When the holidays are only days away even the small things can make a difference. So here’s another helpful trick for how you can save a few extra minutes every time you use Google Maps for directions or navigation.

You can save your home and work addresses in Google Maps, and then select “home” or “work” rather than typing the locations every single time. Just go to “your places” on the side menu and you’ll see “home” and “work” under “labeled places”. Enter the address for each and next time you’re navigating to or from home or work, you can get your directions a little quicker and easier than before.

Every minute matters. Save more every day with Maps Minutes Hacks. Next up: how to get home fast and safe on New Year’s Eve.

Posted by Olga Suvorova, Product Marketing Manager, Google Maps

Code the Road Europe Recap: Our last stop in London

Maps Devel — Wed, 23 Dec 2015 16:54:00 +0000

We celebrated our last ‘Code the Road’ Europe stop in London where the team got an early start in our Code Lab building an Android app using the Google Maps APIs.

Ed Boiling, Maps API sales engineer, led the Code Lab workshop where developers created an Android application using the Google Maps Android API and connected it to a Google Cloud Platform datastore. The Code Lab covered concepts including using Android Studio, creating a Google Maps activity, drawing data on the map, capturing the user's location, and adding location based rules to control the application logic. It also introduced the developers to Google Cloud Platform via the Cloud Endpoints integration in Android studio, allowing them to easily add and deploy a Google App Engine based API and datastore for their application to use.

This was not before trying out a Code the Road favorite—Pegman Skydiving. Using a camera, Maps APIs, and your arms the program can detect how you might look skydiving over a specific locale.

In the afternoon Kerstin Pittl, a lead engineer for Maps APIs from OniGroup, discussed how companies can use the “blue dot” on Google Maps in their applications and how partners can help them integrate it into their map.

Pittl was followed by Dan Hubert, the founder of Appyparking. Appyparking helps drivers across the United Kingdom understand parking regulations and find open parking spaces. The app color codes parking spots to show drivers where there’s free parking, where restrictions apply and where special types of spaces – such as electric-car charging and motorbike spots – are located.

We’re already planning our next roadtrip. We hope to see you at one of our future Code the Road stops!

Posted by Michael St. Germain, Associate Product Marketing Manager, Google Maps APIs

Code the Road Europe Recap: The Hamburg Hackathon for Refugees

Maps Devel — Tue, 22 Dec 2015 17:17:00 +0000

People around the world want to know how they can help the refugees and migrants caught up in the crisis in Europe, the Middle East and Northern Africa. As part of Code the Road Europe, we partnered with Ubilabs, a Google Maps for Work partner, to host a 24-hour hackathon dedicated to helping expand RefugeeMaps.eu, Ubilabs’ open sourced platform to help the refugees in Hamburg and throughout Europe.

RefugeeMaps.eu highlights local points of interest that are relevant to refugees new to a particular area, including libraries, recreational facilities and other important landmarks. The goal is to take local knowledge from volunteers and make it easy for someone new to the area to orient themselves and find resources that will help them settle in quickly.

We kicked-off the hackathon with a presentation from Barbara Kopf, a refugee activist and the manager of the institution ‘Freizeithaus Kirchdorf’. She provided context for what refugees need and how they can help. Then, we had Thomas Steiner, an engineer in the Google Hamburg office, and Martin Kleppe from Ubilabs talk about the technical aspects around the platform. To support the effort, Ed Boiling, Google Maps APIs Sales Engineer, presented 10 Google Maps APIs in 10 minutes, then it was time to start start coding.

Six groups of developers formed and spent the rest of the night designing, coding, and working together to find ways to improve RefugeeMaps.eu with, of course, lots of coffee and snacks.

After 24 hours, we all came together to review the improvements which included:

Improvement to the front end design and UX optimization based on language preferences, making it easier for refugees to navigate the platform based on their preference for Arabic, English or German.
A function that makes it easier for refugees to print out select, zoomed-in areas of the map. Not all refugees have cell phones, especially women and children, so one group decided it was important to make sure it was easy for someone to print out maps to make it truly offline.
Addition of new places. Currently, only local volunteers with access to a master spreadsheet can add locations; however, one group added a function that makes it easier for anyone to add in a location through the interface of the map. This then updates the master spreadsheet.
A native offline Android app. Offline is important for the refugees that might not have data plans, so one group created a native Android app that could be used offline.
No server solution. To make it easier to run the platform, developers made a solution that did not require a server-side.
A performance boost. Developers added back-end changes to allow for caching of resources for offline use.

Here is the improvement we made to the front end design:

We were so impressed by all of the improvements that the developers made over the 24 hour period. While the hackathon is officially over, we also extend our invitation to collaborate on the project to external developers who could not attend the hackathon. You can find the code and all info on GitHub as well as a live demo instance of RefugeeMaps.eu online.

Posted by Hena Haines, Product Marketing Manager, Google Maps APIs

Code the Road Europe Recap: Our Visit to Berlin for a Developer Meetup

Maps Devel — Mon, 21 Dec 2015 17:42:00 +0000

After a great trip to Tel Aviv, we were excited to be in Germany with our Code the Road bus. Our first stop was in Berlin, and then we were on to Hamburg for our 24-hour Hackathon.

We hosted our first event in the Factory, Germany's largest startup campus. The Factory provides working spaces, communities and events for freelancers and startups to connect and empowers entrepreneurs and innovators in a beautiful space in Berlin.

Before the event developers had a great time exploring the Code the Road bus and enjoying a coffee at our Location Cafe. They also had a chance to play multiple games including the Maps Skydiving game.

Ed Boiling and Matt Toon kicked-off the event with a great Codelab focused on building an app that allows users to check into any mountain when going on a hike or visiting a new destination. Corien, a web developer and student, said, “It was great to learn more how to use Google Maps APIs on Android, a platform I don’t usually develop on as well as learn from the other developers at the event. It was great to see everyone working together and learning a thing or two about Google Maps APIs.”

Then, we had Ed Parsons kick off our presentation by explaining how location technology is changing the way we interact with the world to create a more dynamic, emotive experience.

Next up, Oliver from Kia Motors spoke about how Kia is using Google Maps APIs in the Kia cee’d Surprise Drive digital marketing campaign. Martin Kleppe from Ubilabs followed up with the specific technical points on how this digital marketing campaign was developed with Distance Matrix API, Directions API and custom pins. He also gave our attendees some tips and tricks about how to get their maps looking snazzy with Image Tiles, clustering, Marker Images, Data Layer and more. He even share his presentation for our attendees to reference.

Finally, our technical lead from Sydney, Enoch, presented on a range of topics from keys to quotas to JavaScripts tips and tricks.

Shenouda, a developer from Egypt told us, “The presentations gave a great overview of the functionality of the technology and how to use the APIs to the best of their abilities.” He plans to take what he learned on styling and overlaying data on a map as well as using the Elevation API to incorporate into applications to give users a really interactive and exciting user experience.

We had a great time in Berlin. Next we were on to Hamburg and London!

Posted by Tobias Espig, Head of Global Field Marketing, Google Maps APIs

Code the Road Europe Recap: Our first stop in Tel Aviv

Maps Devel — Fri, 18 Dec 2015 18:12:00 +0000

We had a fantastic start to our ‘Code the Road’ Europe tour at the Google Tel Aviv Campus. We were thrilled to have so many enthusiastic developers to help kick off our first event.

It was great to be in Tel Aviv to feel the excitement and energy of their thriving startup community and to see how these talented developers were using location and Google Maps APIs in their applications.

There we brought a Maps Dive gaming experience to the campus area as well as a full-size copy our Code the Road 1970s Volkswagen Tour bus. (The actual bus and the trailer were waiting for us in Berlin for our next stop on the 12th of November)

For our first talk, Ed Parsons, Geospatial Technologist, Google Maps, gave a talk titled "Everything, everywhere: The evolving world of ambient location.” Next up was, Enoch Lau, Technical Lead, Javascript Maps API, who gave some tricks and tips to make Google Maps APIs run even smoother.

We also welcomed Lidor Dvir, Head of Development from Gett who shared a talk titled "Using Google Maps API to build a multi-million user product". Lidor presented on how Gett uses multiple Google Maps APIs on multiple platforms to help both users and businesses get where they need to go and get the things they need. He described how the Google Maps Places API, Directions API and Roads APIs helps users easily find the places they need to go and the best way to get there. They also use heat maps, marker clustering, customize markers and animations to layer information on the map in beautiful visualizations.

We spent the afternoon with a packed house for Codelab were we built a ‘Munro bagging’ Android app on Google Maps and Google Cloud Platform. We had a great time working with the developers helping them with the app.

Tel Aviv was just the start of our journey. The next stop was Berlin!

Posted by Tobias Espig, Head of Global Field Marketing, Google Maps APIs

New Autocomplete widget helps users with places and address entry in mobile apps

Maps Devel — Fri, 18 Dec 2015 00:02:00 +0000

Posted by Florian Bertele, Product Manager, Google Places API

Today, we're announcing two new ways to help users enter places and addresses in your apps with less typing. Autocomplete functionality assists users by automatically completing the name and address of a place as they type. The autocomplete widget on iOS and Android makes it easier for you to add autocomplete functionality to your application with just a small amount of code. Also, we are adding autocomplete functionality to the place picker.

The new autocomplete widget UI comes in two different flavors: overlay and full screen.

Full screen autocomplete widget

Overlay autocomplete widget

On Android, you can add the autocomplete widget as a Fragment and add an event listener to retrieve the autocompleted place reference back in the application. Alternatively, you can invoke the autocomplete widget with an Intent.

Adding a Fragment In the XML layout file for your Activity:

Adding an Event Listener in your Activity's onCreate() method:

// 
PlaceAutocompleteFragment fragment = (PlaceAutocompleteFragment)
    getFragmentManager().findFragmentById(R.id.place_autocomplete_fragment);

fragment.setOnPlaceSelectedListener(new PlaceSelectionListener() {
   @Override
   public void onPlaceSelected(Place place) { // Handle the selected Place
   }
   @Override
   public void onError(Status status) { // Handle the error
   }

Creating an intent to invoke the autocomplete widget:

try {
   Intent intent =
            new PlaceAutocomplete.IntentBuilder(PlaceAutocomplete.MODE_FULLSCREEN)
           .build(this);
   startActivityForResult(intent, PLACE_AUTOCOMPLETE_REQUEST_CODE);
} catch (GooglePlayServicesRepairableException e) {
   GooglePlayServicesUtil
           .getErrorDialog(e.getConnectionStatusCode(), getActivity(), 0);
} catch (GooglePlayServicesNotAvailableException e) {
   // Handle the exception
}

On iOS (Objective-C), you can implement autocomplete’s delegate to respond to a place selection:

@interface MyViewController () 
@end

@implementation ViewController
.
.
.
- (IBAction)onLaunchClicked:(id)sender {
  // Present the Autocomplete view controller when the button is pressed.
  GMSAutocompleteViewController *acController = [[GMSAutocompleteViewController alloc] init];
  acController.delegate = self;
  [self presentViewController:acController animated:YES completion:nil];
}

- (void)viewController:(GMSAutocompleteViewController *)viewController
    didAutocompleteWithPlace:(GMSPlace *)place {
  // The user has selected a place.
  [self dismissViewControllerAnimated:YES completion:nil];
}

- (void)viewController:(GMSAutocompleteViewController *)viewController
    didAutocompleteWithError:(NSError *)error {
  [self dismissViewControllerAnimated:YES completion:nil];
}

// User pressed cancel button.
- (void)wasCancelled:(GMSAutocompleteViewController *)viewController {
  [self dismissViewControllerAnimated:YES completion:nil];
}

@end

And in Swift:

import UIKit
import GoogleMaps

class MyViewController: UIViewController {
    
    @IBAction func onLaunchClicked(sender: AnyObject) {
        let acController = GMSAutocompleteViewController()
        acController.delegate = self
        self.presentViewController(acController, animated: true, completion: nil)
    }
}

extension MyViewController: GMSAutocompleteViewControllerDelegate {
    
    func viewController(viewController: GMSAutocompleteViewController!, didAutocompleteWithPlace place: GMSPlace!) {
        // The user has selected a place.
        self.dismissViewControllerAnimated(true, completion: nil)
    }
    
    func viewController(viewController: GMSAutocompleteViewController!, didAutocompleteWithError error: NSError!) {
        self.dismissViewControllerAnimated(true, completion: nil)
    }
    
    func wasCancelled(viewController: GMSAutocompleteViewController!) {
        self.dismissViewControllerAnimated(true, completion: nil)
    }
}

We have also added the autocomplete functionality to the place picker—a UI widget that helps users communicate their current location, such as a place, address or location on a map. This makes it even easier to pick a specific place by starting to type its name or address. If your app already uses the place picker it will automatically gain the autocomplete feature with no action required on your part.

To get started, check out the documentation and code samples. You can always send us any questions via Stack Overflow or the Google Maps API issue tracker if you have ideas for improvement.

Maps Minutes Hack #5: Make your holiday detours easier with Google Maps

Lat Long — Wed, 16 Dec 2015 19:59:00 +0000

Part of our series on how to save time this holiday season with Google Maps.

Forget the eggnog for a holiday party? On the road to grandma's and need to gas up along the way? Or maybe you need to pick up a last-minute gift on the way to your in-laws’ house?

One poorly planned pit stop can add a lot of time to your trip – especially during the holidays when crowds can be bigger and traffic heavier. The good news is that Google Maps can help you make quick pit stops without long detours.

On Google Maps for Android, you can now search for places like a gas station, grocery store or coffee shop, navigate there, and then pick back up on your original route—all without leaving navigation mode (coming soon to iOS).

Here’s how it works: When you’re in navigation mode, simply tap the magnifying glass at the top right corner in the app. Pick a category from the drop down menu and you'll see a few options, along with ratings of businesses, prices at gas stations, and how much time the detour will add to your trip. Once you choose a place, the stop is automatically incorporated into your route. Can’t type and tap while driving? You can use voice commands instead.

Every minute counts. Save more time with Google Maps hacks. Next up: turn-by-turn navigation even when you’re offline.

Posted by Dai Pham, Head of Geo and Google Maps Marketing

Introducing the Google My Business API

Maps Devel — Tue, 15 Dec 2015 21:44:00 +0000

Google My Business is helping businesses around the world connect with their customers when they search for them on Google. Today we’re introducing the Google My Business API to make it easier for large businesses and third parties to integrate with the Google My Business platform and publish updates to customers on Google Search & Maps. For example, you can now set your special hours for the holiday season and update them across all of your locations using the Google My Business API.

Through the new Google My Business API, developers can:

Create business locations with information such as name, address, phone number, category, business hours, and more
Manage special hours
Mark a business location as permanently closed
Manage business photos
List, invite and remove managers on locations and business accounts
Read listing state to identify Google updated, duplicate and suspended locations
Search/Filter locations by name, category and label
Set the service area for a business either by specifying a point and radius or Place IDs

Here's a sample java function that creates a new location and sets special holiday hours:

public static Location createLocation(String accountName) throws Exception {
  Location location = new Location();

  // Street address
  Address address = new Address();
  List addressLines = Arrays.asList("740 Valencia Street");
  address.setAddressLines(addressLines);
  address.setLocality("San Francisco");
  address.setAdministrativeArea("CA");
  address.setCountry("US");
  address.setPostalCode("94110");
  location.setAddress(address);

  // Business hours
  BusinessHours businessHours = new BusinessHours();
  List periods = new ArrayList<>();
  List days = Arrays.asList("Monday", "Tuesday", "Wednesday", "Thursday", "Friday");
  for (String day : days) {
    TimePeriod period = new TimePeriod();
    period.setOpenDay(day);
    period.setOpenTime("11:00");
    period.setCloseTime("20:00");
    period.setCloseDay(day);
    periods.add(period);
  }
  businessHours.setPeriods(periods);
  location.setBusinessHours(businessHours);

  // Special hours
    Date christmasEve = new Date().setYear(2015).setMonth(12).setDay(24);
    Date christmasDay = new Date().setYear(2015).setMonth(12).setDay(25);
    List periods = new ArrayList<>();
    periods.add(new SpecialHourPeriod()
        .setStartDate(christmasEve)
        .setOpenTime("11:00")
        .setCloseTime("20:00")
        .setEndDate(christmasEve));
    periods.add(new SpecialHourPeriod()
        .setStartDate(christmasDay)
        .setIsClosed(true));
   SpecialHours specialHours = new SpecialHours()
        .setSpecialHourPeriods(periods);

  location.setSpecialHours(specialHours);

  location.setLocationName("Dandelion Chocolate");
  location.setStoreCode("DC1");
  location.setPrimaryPhone("415 349-0942");
  location.setPrimaryCategory(new Category().setCategoryId("gcid:chocolate_shop"));
  location.setWebsiteUrl("https://www.dandelionchocolate.com/");

  // Create Location
  CreateLocationRequest createLocationRequest = new CreateLocationRequest();
  // RequestId is a unique id for each location created
  createLocationRequest.setRequestId(“1a84939c-ab7d-4581-8930-ee35af6fefac”);
  createLocationRequest.setLocation(location);
  createLocationRequest.setLanguageCode("en-US");
  Mybusiness.Accounts.Locations.Create createLocation =
      mybusiness.accounts().locations().create(accountName, createLocationRequest);

  Location createdLocation = createLocation.execute();

  System.out.printf("Created Location:n%s", createdLocation.toPrettyString());
 
  return createdLocation;
}

When special hours are set in Google My Business, we will tell customers that they’re seeing holiday-specific opening hours on Google:

To learn more about the Google My Business API and to apply for access, visit our developer page.

Questions or feedback? Contact the API team on the Google My Business API Forum.

Posted by Aditya Tendulkar, Product Manager, Google My Business

Holiday Maps Minutes Hack #1: Save time beating bumper-to-bumper traffic

Lat Long — Tue, 01 Dec 2015 23:28:00 +0000

This post is the first in a series about how you can use Google Maps to save time this holiday season.

Your time is finite. But what if you could save all the minutes you waste in traffic, standing in lines, or shopping and spend them on what you love?

In December when things sometimes get a tad bit crazier, make the most of the time you do have. In the next few weeks we’ll share simple Google Maps hacks you can use to save time during the holidays.

We’re starting with…traffic. Why? Because no one likes traffic. Whether you’re driving to your once-a-year family gathering or trying to get to the mall in time for last-minute shopping, beating bumper-to-bumper traffic just might be one of the best holiday gifts you receive this year.

Google Maps gives you the best route, based on real-time traffic and historic traffic information. All you need to do is hit the navigation button and Google Maps takes care of the rest. You’ll even get an explanation for why it's the fastest route and updates when your ETA changes.

If you find yourself in a jam caused by an accident or construction, Google Maps lets you know how long you'll be at a standstill and automatically re-routes you if there’s a faster path.

Every minute counts, so hit the road and enjoy the ride—Google Maps has your back this holiday season.

Stay tuned for more Maps Minutes hacks. Next up: flying through airports with indoor Google Maps.

Posted by Olga Suvorova, Product Marketing Manager, Google Maps

The new Google Maps SDK for iOS includes bitcode support, new events and more

Maps Devel — Mon, 30 Nov 2015 23:40:00 +0000

Today we are launching the Google Maps SDK for iOS 1.11, which includes bitcode support, new events and some features previously available only in the Android SDK.

Bitcode is an intermediate representation of your app that is uploaded to the Apple Store. With this abstraction, Apple can optimize for specific target devices at provisioning time.

The Google Maps SDK for iOS 1.11 also introduces two new events: didLongPressInfoWindowOfMarker and didCloseInfoWindowOfMarker. The long press event takes advantage of iOS long-touch as another way for users to interact with Maps SDK for iOS enabled apps. The close event is particularly useful if you wish to programmatically zoom back out on the map after the user has looked at the detail associated with a particular marker.

We have also added start and finish rendering events to the GMSMapViewDelegate and GMSPanoramaViewDelegate protocols. The start rendering events are triggered when tiles have just been requested or labels have just started rendering. The finish events are triggered on rendering completion for tiles and StreetView panoramas, respectively.

Finish events can be used in conjunction with an activity indicator to accurately represent when a map has finished rendering. The sample code below shows how to include this functionality. (We’ve also included SVProgressHUD in the sample below to improve the user experience, but it is not required)

import UIKit
import GoogleMaps

class MapRenderingViewController: UIViewController {
  @IBOutlet var mapView: GMSMapView!

  override func viewDidLoad() {
    super.viewDidLoad()
    mapView.delegate = self
  }

  // MARK: - GMSMapViewDelegate

  func mapViewDidStartTileRendering(mapView: GMSMapView!) {
    SVProgressHUD.showWithStatus("Loading tiles")
  }

  func mapViewDidFinishTileRendering(mapView: GMSMapView!) {
    SVProgressHUD.dismiss()
  }
}

Lastly, the Google Maps SDK for iOS 1.11 offers new features & bugfixes we think you'll find useful, including:

Setting ground overlay opacity with an alpha value
Polygon hole support
Increased camera tilt range at high zoom
Additional Places autocomplete functionality

Take a look at our release notes and update to Google Maps SDK for iOS 1.11 today.

Posted by Megan Boundey, Product Manager, Google Maps Mobile APIs

Predicting the Future with Google Maps APIs

Maps Devel — Tue, 10 Nov 2015 23:35:00 +0000

Planning journeys ahead of time has always been difficult, since traffic conditions vary greatly over time. Developers have used live traffic data from the Google Maps APIs for years to help drivers with this problem, but up to now, this has been available only for journeys starting very close to now, and limited to Google Maps for Work customers only.

Today we’re extending traffic predictions in the Google Maps APIs indefinitely into the future - a feature we call predictive travel times. This will let developers plan journeys hours, days or even weeks in advance, using Google’s model of what the traffic conditions will be like on that day. We’re also making all traffic features in Directions API and Distance Matrix API available under our Standard Plan (2500 requests/day for free, with pay-as-you-go pricing for extra requests), and increasing the waypoint limit in Directions API for these developers from 8 to 23 waypoints. (Traffic features and higher waypoint limits in the JavaScript Maps API are available to Google Maps for Work customers for now.)

Using these new traffic features is super simple—just add the departure_time parameter to Directions API or Distance Matrix API queries, and the results will contain the travel time estimate given the predicted traffic conditions at that time. The route returned may also change depending on traffic conditions, which lets developers recommend the fastest route to their users. For example, the image below shows the fastest route from San Francisco International Airport to the Google campus in Mountain View late at night when there’s no traffic (blue), and during peak hour when an accident on Highway 101 has slowed traffic to a crawl (red).

Since traffic conditions far in the future could vary greatly, developers can set an optional traffic_model parameter to choose whether they’d prefer to get an optimistic, pessimistic or best_guess estimate of the travel time. For example, one of our customers, Redfin, plan to use the Google Maps APIs to predict how long it will take to drive between homes, so they will use the pessimistic traffic model to ensure there’s enough travel time taking traffic into account. On the other hand, a developer building thermostat app wants their user’s house to be warm by the time they get home from work, so they would use the optimistic travel time estimate to calculate when their user is likely to get home, and when their thermostat needs to turn on.

The default traffic model, best_guess, returns the most likely travel time given everything that’s known about the traffic conditions—both the historical model for the queried time and day of the week, and the actual live traffic conditions right now. This can be used in apps that give drivers an indication of what their travel time will most likely be.

To learn more about the traffic features in the Google Maps APIs, please take a look at our video, check out the documentation for the Directions API, the Distance Matrix API and the JavaScript Maps API Directions and Distance Matrix services, or download the updated client libraries for Java or Python.

Posted by Elena Kelareva, Product Manager, Google Maps APIs

The Google Maps APIs team hits the road with ‘Code the Road’ in Europe

Maps Devel — Wed, 04 Nov 2015 08:21:00 +0000

After an exciting road trip across the U.S. this summer, we decided to bring Code the Road to Europe to highlight what developers have made possible with the Google Maps APIs. We’ll be driving our customized 1979 Volkswagen T2 Bus with 50 Horsepower, 78Tkm on a four stop trip across Europe where along the way we’ll meet with developers, customer and partners.

Code the Road Europe kicks-off in Tel Aviv on November 10. From there we’ll be heading across Europe—stopping in Berlin, Hamburg and London.

We will also be hosting three developer meetups: Tel Aviv on November 10, Berlin on November 12 and London on November 25. The meetups will highlight how developers can use the Google Maps APIs in their apps and websites and include sessions with Google Engineers and customers. We’re expecting these meet-ups to fill-up quickly, so register today to reserve a seat at a location near you.

We’ll be hosting a 24-hour hackathon in Hamburg beginning the afternoon of November 18. Ubilabs and the Google Maps APIs team will be bringing developers, product managers and students together to develop innovative solutions to lend a hand in the Syrian Refugee Crisis.

We will be sharing on-the-road updates and photos on the site throughout the trip. We hope to see you on the road!

Posted by Tobias Espig, EMEA Marketing, Google Maps APIs

Map Tips: (What’s nearest; Who’s closest?) Creating a better customer experience with the Distance Matrix service

Maps Devel — Wed, 28 Oct 2015 14:42:00 +0000

Posted by Corey Bradford, Google Maps Solution Architect

Editor’s note: ‘Map Tips’ are designed to answer frequently asked questions about Google Maps APIs. For important tips on how to deploy Google’s mapping tools, read more from Corey Bradford, Google Maps Solution Architect at Google.

Many location-based sites and applications can accurately tell users how far they are from nearby points of interest. However, they often provide only straight-line distance (ie as the crow flies), which isn’t always a true representation of proximity. Alternatively, these applications can be improved by the Distance Matrix service available in the Google Maps Javascript API and the Distance Matrix Web Service, which provides accurate travel distances and times, and for premium customer can even factor in current traffic conditions.

Store locators and rideshare/taxi applications are common applications that can benefit from using the Distance Matrix service. In both use cases, a user is trying to determine their relative distance from either a store or taxi.

Store locators
Suppose a customer has provided their location, “1903 Toro Canyon Rd, Austin, TX 78746.” (Point C on the map) Using straight-line distances, your application found your three nearest stores, as shown on this map:

“As the crow flies,” store #1 (shown in the image below as "B") is clearly nearest to the customer location, “C.” However, there’s a river between these locations. Unless the customer intends to use watercraft for part of their travel, they’ll need to travel via the nearest bridge or tunnel. The Directions Service provides the suggested route, confirming the need to travel much farther than the straight-line distance:

Since we know that the straight-line distance doesn’t accurately reflect the proximity of the stores in this case, let’s make a call to the Distance Matrix Service to determine actual driving distances and times. Here are the results returned:

Store #	Straight-Line Distance (mi)	Driving Distance (mi)	Driving Time (min)	Driving Time with Current Traffic (min)
1	1.4	5.4	15	20
2	2.7	4.4	9	15
3	2.5	4.7	11	11

Now we have some useful information for the customer. First, we can see that, although store #2 is the farthest in a straight line, it’s actually the shortest driving distance. In addition, in normal traffic conditions, it’s also the shortest driving time. However, if we consider current traffic conditions, we see that store #2 will take longer to reach than store #3. The following maps, which use the Directions Service along with the traffic layer, illustrate these results:

In this case, the customer may choose to visit store #3 (shown in the image below as "B") if they are leaving now or store # 2 if they plan to travel later, after traffic clears.

Rideshare and taxis
Now let’s consider another example: users looking to hire a car service or dispatchers who need to direct the nearest taxi to a customer. As the following maps shows, the user can see the actual current drive times, provided by the Distance Matrix API, of each driver to their location, regardless of straight-line distance.

What's Under The Hood
Now that we’re taken a look at how driving distances, duration, and duration in traffic information can benefit your customers, you might be wondering “How can I implement this as a developer?” Below are code snippets from the store locator example that provide the technical details of how to build these features using the Distance Matrix service.

For simplicity, we’ve pre-defined the customer and store locations:

var customerLocation = '1903 Toro Canyon Rd, Austin, TX 78746';

var store1 = '3808 W. 35th, Austin, TX 78703';
var store2 = '4933 Plaza on the Lake, Austin, TX 78746';
var store3 = '6500 Bee Cave Rd, Austin, TX 78746';

Using this location information, we make a call to the Distance Matrix service:

function calculateDistances() {
  // Create a new Distance Matrix Service object
  var service = new google.maps.DistanceMatrixService();
  
  // Set the options such as the pre-defined origin
  // and destinations, as well as specifying to use
  // duration in traffic
  
  service.getDistanceMatrix({
      origins: [customerLocation],
      destinations: [store1, store2, store3],
      travelMode: google.maps.TravelMode.DRIVING,
      unitSystem: google.maps.UnitSystem.IMPERIAL,
      avoidHighways: false,
      avoidTolls: false,
      durationInTraffic: true
  }, callback);
} 
   
function callback(response, status) {
  if (status != google.maps.DistanceMatrixStatus.OK) {
    console.log('DistanceMatrix Error: ', status);
  } else {
    // Get the arrays of origins and destinations
    var origins = response.originAddresses;
    var destinations = response.destinationAddresses;
    
    for (var i = 0; i < origins.length; i++) {
      // For each of the origins, get the results of the 
      // distance and duration of the destinations
      var results = response.rows[i].elements;
      for (var j = 0; j < results.length; j++) {
    // Store the results for later sorting
   storeResults.push([destinations[j],
       results[j].duration_in_traffic.value,
                  results[j].distance.value]);
      }
    }
    // Sort the results by duration in traffic
     storeResults.sort(function(a, b) {
           return a[1] - b[1];
         }); 
  }
}

The call returns the following data, which includes the critical information of driving distances, duration, and duration in traffic:

destination_addresses" : [
      "3808 West 35th Street, Austin, TX 78703, USA",
      "4933 Plaza on the Lake, Austin, TX 78746, USA",
      "6500 Bee Cave Road, Austin, TX 78746, USA"
   ],
   "origin_addresses" : [ "1903 Toro Canyon Road, Austin, TX 78746, USA" ],
   "rows" : [
      {
         "elements" : [
            {
               "distance" : {
                  "text" : "5.4 mi",
                  "value" : 8631
               },
               "duration" : {
                  "text" : "15 mins",
                  "value" : 917
               },
               "duration_in_traffic" : {
                  "text" : "20 mins",
                  "value" : 1188
               },
               "status" : "OK"
            },
            {
               "distance" : {
                  "text" : "4.4 mi",
                  "value" : 7157
               },
               "duration" : {
                  "text" : "9 mins",
                  "value" : 569
               },
               "duration_in_traffic" : {
                  "text" : "15 mins",
                  "value" : 911
               },
               "status" : "OK"
            },
            {
               "distance" : {
                  "text" : "4.7 mi",
                  "value" : 7490
               },
               "duration" : {
                  "text" : "11 mins",
                  "value" : 635
               },
               "duration_in_traffic" : {
                  "text" : "11 mins",
                  "value" : 635
               },
               "status" : "OK"
            }
         ]
      }

With this data, customers can sort the store results according to their preferences and make better decisions about which store to visit.

We hope you’re able to take advantage of some of these features in your website or application. For more details on implementing the Google Maps Javascript API Distance Matrix service, visit our developer documentation and review our available code samples. You can also find out more about the Distance Matrix API, part of our Google Maps Web Services APIs.

Always-on Android Wear apps with the Google Maps API

Reto Meier — Thu, 24 Sep 2015 19:39:00 +0000

Originally posted on the Geo Developers Blog

Posted by Ankur Kotwal, Developer Advocate

Some Android Wear apps are most useful when they are always available to the user, even at a glance. Now, with Google Play Services 8.1, the Google Maps Android API supports ambient mode, the API that provides always-on capabilities. In ambient mode, the map adjusts its style to provide a simplified, low-color rendering of the map. All markers, objects, and UI controls disappear, keeping the map on the screen while letting the user know that it is not currently ready to accept user input. An important advantage is the camera position and zoom level are retained, thus keeping the user’s context within the map.

The screenshot below show how maps appear in interactive mode and in ambient mode.

To implement ambient mode in your maps, follow these steps:

Set your your targetSDKVersion to 22 or higher

Add the following dependencies to build.gradle for your app to add the wearable support library.

 dependencies {
    compile 'com.google.android.support:wearable:1.2.0'
    provided 'com.google.android.wearable:wearable:1.0.0'
 }

Add the wearable shared library entry into the wearable app manifest:
```
  
  ...
```
Add the WAKE_LOCK permission to the handheld and wearable app manifest:
Have your Activity extend WearableActivity. This will provide the overrides that notify your app when the wearable enters, exits and provides screen updates in ambient mode.
In the onCreate() method of your activity, call the setAmbientEnabled() method. This tells the framework that the app should enter ambient mode rather than returning to the watch face.
Set your map to support ambient mode. You can do this by setting the attribute map:ambientEnabled="true" in the activity's XML layout file, or programmatically by setting GoogleMapOptions.ambientEnabled(true). This informs the API to pre-load necessary map tiles for ambient mode.
When the activity switches to ambient mode, the system calls the onEnterAmbient() method in your wearable activity. Override onEnterAmbient() and call MapFragment.onEnterAmbient() or MapView.onEnterAmbient(). The map changes to a non-interactive, low-color rendering of the map.
When in ambient mode, your app can update the display every minute by overriding onUpdateAmbient(). If you need more frequent updates, check out this guide.
When the activity leaves ambient mode, the system calls the onExitAmbient() method in your wearable activity. Override onExitAmbient() and call MapFragment.onExitAmbient() or MapView.onExitAmbient(). The map returns to the normal rendering and is now ready to accept user input.

With always-on maps on Android Wear, you can now show maps at a glance. For more information on these APIs check out the documentation and the sample code.

Always-on Android Wear apps with the Google Maps API

Maps Devel — Thu, 24 Sep 2015 18:55:00 +0000

Posted by Ankur Kotwal, Developer Advocate at Google

Some Android Wear apps are most useful when they are always available to the user, even at a glance. Now, with Google Play Services 8.1, the Google Maps Android API supports ambient mode, the API that provides always-on capabilities. In ambient mode, the map adjusts its style to provide a simplified, low-color rendering of the map. All markers, objects, and UI controls disappear, keeping the map on the screen while letting the user know that it is not currently ready to accept user input. An important advantage is the camera position and zoom level are retained, thus keeping the user’s context within the map.

The screenshot below show how maps appear in interactive mode and in ambient mode:

To implement ambient mode in your maps, follow these steps:

Set your your targetSDKVersion to 22 or higher
Add the following dependencies to build.gradle for your app to add the wearable support library.

dependencies {
compile 'com.google.android.support:wearable:1.2.0'
provided 'com.google.android.wearable:wearable:1.0.0'
}

Add the wearable shared library entry into the wearable app manifest:

...

Add the WAKE_LOCK permission to the handheld and wearable app manifest:

Have your Activity extend WearableActivity. This will provide the overrides that notify your app when the wearable enters, exits and provides screen updates in ambient mode.
In the onCreate() method of your activity, call the setAmbientEnabled() method. This tells the framework that the app should enter ambient mode rather than returning to the watch face.
Set your map to support ambient mode. You can do this by setting the attribute map:ambientEnabled="true" in the activity's XML layout file, or programmatically by setting GoogleMapOptions.ambientEnabled(true). This informs the API to pre-load necessary map tiles for ambient mode.
When the activity switches to ambient mode, the system calls the onEnterAmbient() method in your wearable activity. Override onEnterAmbient() and call MapFragment.onEnterAmbient() or MapView.onEnterAmbient(). The map changes to a non-interactive, low-color rendering of the map.
When in ambient mode, your app can update the display every minute by overriding onUpdateAmbient(). If you need more frequent updates, check out this guide.
When the activity leaves ambient mode, the system calls the onExitAmbient() method in your wearable activity. Override onExitAmbient() and call MapFragment.onExitAmbient() or MapView.onExitAmbient(). The map returns to the normal rendering and is now ready to accept user input.

With always-on maps on Android Wear, you can now show maps at a glance. For more information on these APIs check out the documentation and the sample code.

Map Tips: Style maps like a wizard

Maps Devel — Thu, 24 Sep 2015 17:45:00 +0000

Posted by Ed Boiling, Google Maps Solution Architect

Editor’s note: ‘Map Tips’ are designed to answer frequently asked questions about Google Maps APIs. For important tips on how to deploy Google’s mapping tools, read more from Ed Boiling, Google Maps Solution Architect at Google.

At Google, we understand that not everyone dreams in the same beautiful shades of orange and yellows of our Google Maps road network or the calm blues of Google Maps waterways. The reality is that our customers might want to make the water purple or their roads green. Sometimes you need a muted map with no labels to overlay your own data, or maybe you want the colors to match the branding of your website.

That’s why we offer Styled Maps. You can create the styles by hand and test your code to see how they look, or use our time saving visual tool — the Google Maps Style Wizard. The Google Maps Style Wizard allows you to select features and their elements, apply operations to those features, and save the styles to JSON, which you can copy and paste into your application.

With this simple JSON file, you can tailor that map to your needs—the color scheme of your website, a greyscale map to show details or to highlight a big event.

1. Select a type of feature to style in the Selectors panel. For any element type (e.g. roads, water) you can choose to style the shapes (select “Geometry”) or the text (Select “Labels”), or both. You can show a map of anywhere you wish as a preview.

2. To change the visibility, lightness or color, choose the combination of Stylers that match your needs. For example, to switch off all the map labels, select Feature type “All”, Element type “Labels” and check the box for the “Visibility” styler. Choose “Off” as the option for Visibility. To make all the water purple, select Feature type “water”, Element type “geometry” and select the “fill” option. Fill changes the solid color and stroke changes the line color. In the Stylers section choose the shade you want using the sliders or the hexadecimal value. For purple, either slide R to 204, G to 0 and B to 255 or enter #CC00FF in the text box.

3. Once you are happy with the styling of the feature type, click the Add button in the Map Style panel to save the style and create a new style to work on. Repeat Steps 2 to 5 to build up the set of styles for your map. Styles are applied in the order they are listed in the Map Style panel. To copy the style into your own Maps API map, click the Show JSON button to display the JSON object to pass to the style property of your MapOptions object. To generate an example map with this style using the Static Maps API, click the Static Map button.

4. Select a type of feature to style in the Selectors panel. For any element type (e.g. roads, water) you can choose to style the shapes (select “Geometry”) or the text (Select “Labels”), or both. You can show a map of anywhere you wish as a preview.

5. To change the visibility, lightness or color, choose the combination of Stylers that match your needs. For example, to switch off all the map labels, select Feature type “All”, Element type “Labels” and check the box for the “Visibility” styler. Choose “Off” as the option for Visibility. To make all the water purple, select Feature type “water”, Element type “geometry” and select the “fill” option. Fill changes the solid color and stroke changes the line color. In the Stylers section choose the shade you want using the sliders or the hexadecimal value. For purple, either slide R to 204, G to 0 and B to 255 or enter #CC00FF in the text box.

6. Once you are happy with the styling of the feature type, click the Add button in the Map Style panel to save the style and create a new style to work on. Repeat Steps 2 to 5 to build up the set of styles for your map. Styles are applied in the order they are listed in the Map Style panel. To copy the style into your own Maps API map, click the Show JSON button to display the JSON object to pass to the style property of your MapOptions object. To generate an example map with this style using the Static Maps API, click the Static Map button.

Here’s a complete example for a map with no labels and purple water.

[
  {
    "featureType": "water",
    "elementType": "geometry.fill",
    "stylers": [
      { "color": "#cc00ff" }
    ]
  },{
    "elementType": "labels",
    "stylers": [
      { "visibility": "off" }
    ]
  }
]

This style creates a muted grey scale map with just basic outlines that’s ideal for overlaying a data visualization using one of the many Maps API methods available.

[
  {
    "stylers": [
      { "visibility": "off" }
    ]
  },{
    "featureType": "landscape",
    "stylers": [
      { "visibility": "on" },
      { "color": "#e5e3df" }
    ]
  },{
    "featureType": "water",
    "elementType": "geometry",
    "stylers": [
      { "visibility": "on" },
      { "color": "#d4d4d4" }
    ]
  }
]

We hope you’re able to incorporate the Styled Maps capabilities into your website or application. Start customizing your maps today with the Google Maps Style Wizard. If you need some inspiration, visit our friends at snazzymaps.com to see a gallery of styled maps - you can start from any one of the hundreds of user uploaded Google Maps styles.

Map Tips: Speeding up page load times with the Google Maps JavaScript API

Maps Devel — Mon, 21 Sep 2015 19:52:00 +0000

Posted by Mark McDonald, Google Developer Relations Team

Editor’s note: ‘Map Tips’ are designed to answer frequently asked questions about Google Maps APIs. Since web performance is so hot right now, we want to provide some useful information. For important tips on how to deploy Google’s mapping tools, read more from Mark McDonald, Google Developer Relations. Also, our friends over at Wikipedia have just done something similar!

Asynchronously loading JavaScript on your pages can give you huge performance wins. We have just updated all of our JavaScript Maps API samples and you can make these changes to your site, too. Read on to find out what we did and how it works, or skip straight to Unblocking scripts to see what you can start to update on your site today.

Loading JavaScript 101

There are plenty of great developer resources that describe browser rendering processes in detail, and you should read them all, but right now we’re interested in how

The async attribute instructs the browser to fetch the script asynchronously, then execute the script as soon as it is retrieved, removing both the block on DOM construction and the wait for CSSOM construction.

The defer attribute is an older, more supported attribute that instructs the browser to execute the script when the DOM is ready. We’ve included it because the async attribute is not supported in all browsers (specifically, older versions of Internet Explorer). In older browsers (as far back as Internet Explorer 5.5), defer still speeds up the page load, so it’s worth including even though it’s ignored in newer browsers when async is present.

The WHATWG spec explains the behavior:

There are three possible modes that can be selected using these attributes. If the async attribute is present, then the script will be executed as soon as it is available, but without blocking further parsing of the page. If the async attribute is not present but the defer attribute is present, then the script is executed when the page has finished parsing. If neither attribute is present, then the script is fetched and executed immediately, before the user agent continues parsing the page.

The second change we made to our samples was to move the map initialization code from the window’s onLoad event to use a callback. So this code:

...

Now looks like:

This change allows the Maps API code (which now executes as soon as it has been fetched) to run the map initialization code as soon as it can. We’ve also moved the When you enable sign-in with the Google Maps JavaScript API, your users will now see a map tailored to them, which means their saved locations will now show on the map. As you can see in the following picture, the user’s Google profile picture will also appear in the top-right of the map (when logged in with a Google account).

Next, you want to help your users remember the locations that matter most to them by allowing them to save places using the Attributed Save feature of the Google Maps Javascript API. With Attributed Save, saved places will appear on other Google Maps when a user views them on the web or mobile devices.

The easiest way to do this is by adding place and attribution properties to the MarkerOptions object when creating and adding a marker to your map.

var marker = new google.maps.Marker({
    map: map,
    // Define the place with a location, and a query string.
    place: {
      location: {lat: 40.739929, lng: -74.005792},
      query: Gansevoort Meatpacking NYC, New York, NY
    },
    // Attributions help users find your site again.
    attribution: {
      source: 'Altostrat Hotels',
      webUrl: 'https://developers.google.com/maps/'
    }
  });

By adding the place property with a location and query string, you are associating your marker with a specific point-of-interest in Google’s database of places. The attribution field allows your users link back to your site again in the future when viewing this saved place on other maps throughout the web. Note that attributed save requires the place to be known in Google’s database (either as a business name or an address). Here is a complete working code sample for reference.

Tips and Tricks

Here are some tips to help you make the most of signed-in maps using the Google Maps Javascript API:

When specifying the place to associate with a marker, use placeId rather than a query string to uniquely identify the place. Learn more about how to reference a place using a place Id.
Be sure to use include attribution for any markers added to the map, so your users can easily link back to your site when viewing favorite places on other maps throughout the web.
If you are showing only a single marker on a map, using the SaveWidget is a great way to highlight the location with a custom display

Resources

We hope you’re able to incorporate signed-in Maps into your website. To learn more about implementing signed-in Maps and Attributed Save, take a look at the following resources:

New life for old photos: Mapping OldNYC

Maps Devel — Mon, 20 Jul 2015 17:03:00 +0000

Posted by Selena Salazar, Product Marketing Manager, Google Maps APIs

When Dan Vanderkam, a developer and self-confessed history lover, moved to New York in 2011, he found himself wondering what the city used to look like. He figured other people probably shared his curiosity, so he built a website, oldnyc.org, that overlays the city’s streets with more than 80,000 images from its past.

“I've always enjoyed historic photos because they capture so many details that you'd never write about,” Vanderkam says, guessing it’s something his father, a historian, passed down to him. “They really are a window into the past.”

Vanderkam approached Matt Knutzen, a geospatial librarian at the New York Public Library, whom he met a couple of years earlier at an event at the Google New York office.

At the time, Vanderkam was developing a website that mapped old pictures of San Francisco.

“We immediately began talking about historical photos and the possibility of overlaying images in 3D space,” Knutzen recalls.

For the San Francisco project, Vanderkam scraped photos from the San Francisco Public Library’s online archive, and only asked for permission to use them once he’d completed the site.

“I realized later how risky it was to ask them that late,” he says. “So, when I went to New York and started oldnyc, I did things differently by approaching the library first.”

Starting Work on OldNYC

Knutzen, who studied geography and cartography in college, was immediately taken with the idea and knew exactly what resources to direct Vanderkam to. He introduced Vanderkam to the Milstein division of the library, which included a collection called Photographic Views of New York City, 1870s – 1970s.

The images, which are mounted on brown paper, include horse-drawn carts on barely developed dirt roads in the Bronx, skaters at Central Park in 1905, and a giant alligator balloon at Columbus Circle for Macy’s Thanksgiving Parade.

On oldnyc.org, clicking on a red dot marker will open a popup box containing photos of the location sorted from the earliest date to the most recent. Some of the images are undated. The site also shows the descriptions that Vanderkam says were written on the backs of some pictures.

Luckily for Vanderkam, Knutzen had already created a metadata spreadsheet containing unique identifiers for each photo corresponding to cross street locations.

“Plugging the data into Google Maps APIs was made easier because I didn’t have to scrape information or hunt for street names,” said Vanderkam.

To convert the addresses to latitudes and longitudes, Vanderkam used the Google Maps Geocoding API.

In order to customize his map, he used the Google Maps JavaScript API to create location markers, and adjust hue, lightness, saturation, gamma, invert lightness, and visibility. He also specified that his map only include roads and not other elements.

Vanderkam wanted other people to be able to engage with the pictures of the city, so he used a comments API from Facebook to allow site visitors to share their personal experiences.

Teaching Computers, Engaging Communities

Getting the photos on his site was also a challenge. Some of the photos were mounted individually, but others were mounted in pairs or more. To automate the task of matching an image with the coordinates in Knutzen’s spreadsheet and then uploading it to site, Vanderkam wrote code so that the computer could recognise the brown paper and isolate the photos. This was no simple task. To display them, Vanderkam used an expandable image grid library that enlarges a photo when it’s clicked on. The code is published on GitHub by danvk.

Vanderkam also created “rotate” and “improve this transcription” buttons to encourage site visitors to correct an image’s orientation or the transcription of the descriptive text on the backs of photos.

“Oldnyc is an incredibly valuable research tool. It’s now the best way into the photo collection,” says Knutzen. “Having the information of places aligned spatially combines information to give us new knowledge to make new discoveries.”

Vanderkam doesn’t have plans to work on maps for more cities, but hopes that someone else would be interested in picking up the baton. “The code for it is all open source, so if anyone is interested in building a version for their hometown, they should get in touch,” he says.

The Weather Channel brings real-time weather updates to users with Google Maps APIs

Maps Devel — Mon, 20 Jul 2015 14:02:00 +0000

Posted by Chris Huff, Vice President of Mobile Development, The Weather Channel

Editor’s note: Today’s guest blogger is Chris Huff, Vice President of Mobile Development at The Weather Channel. Read how The Weather Channel uses Google Maps APIs to power their popular Android app. The Weather Channel is just one of many customers who shared their story as part of our cross-country road trip, Code the Road.

We know from experience that the combination of weather, mapping and community input can result in ideas that keep people safe and informed. Our Android app goes far beyond basic weather forecasting, which is why we chose Google Maps. We use Google Maps Android API, Google Maps JavaScript API and ImageOverlays to place geodata, such as weather alerts, hurricanes, and storm tracks, and weather tiles, such as radar maps and clouds, on top of Google Maps.

Radar maps are one of the app’s main features, and we work hard to get them right. We get radar imagery from multiple sources and produce raster images from them. Then we take hundreds of the images and animate them in a frame-based animation sequence. The Google Maps Android API gives us overlays to place the animation on top of maps, and also lets us add additional objects such as pins and polygons to visualize lightning strikes or a storm’s direction. You can see an example below.

The more local weather reporting is, the more accurate it is; a thunderstorm may skip one neighborhood but hit another. So to improve accuracy and to build a community around our app, we’ve been working to make it more social. People send us information about weather near them, and we use the Google Maps Android API to add a pin to the map for each user-created report. Anyone can tap a pin to see the detailed report. Here’s an example of social weather reporting.

With more than 68 million downloads, the app has been a tremendous success. We get 2 billion requests for radar maps every year. There’s an old saying that everyone talks about the weather but no one does anything about it. We beg to disagree. With the Google Maps APIs we’re giving people detailed, useful, live information about the weather, and we believe that’s doing quite a bit.

As part of the Code the Road series we hosted the 24-hour hackathon event, “Storm the Road: Hack for Safety with The Weather Channel and Google Maps”, on June 23. The event gave developers an opportunity to come together to create a new app or feature for mobile or web that helps keep the public safe and informed.