Navigation Application Programming Interface

Abstract

The present disclosure relates to a navigation application programming interface. A navigation application programming interface is provided that can be used to obtain navigation information in a third-party software application. In one exemplary embodiment, the application programming interface (API) may include a first set of instructions associated with a navigator class. The navigator class may specify a plurality of functions for controlling a navigation service implemented by the software application. The navigation service may provide navigation information to a user of the software application. The API may include a second set of instructions associated with a navigator delegate protocol. The navigator delegate protocol may be a delegate of the navigator class. The navigator delegate protocol may implement one or more calls to update the navigation information provided as part of the navigation service.

Description

[0001] Division Explanation

[0002] This application is a divisional application of Chinese Patent Application No. 201711104980.X with an application date of November 10, 2017. Technical Field

[0003] The present disclosure generally relates to application programming interfaces for software applications implemented on iOS devices to obtain navigation information. Background Art

[0004] For various purposes, including commercial, social, health, and other purposes, applications have been developed that are implemented on computing devices such as mobile computing devices (e.g., smart phones, tablet computers, smart watches, etc.). These applications are capable of providing user interfaces (e.g., graphical user interfaces) for presenting information to users and allowing users to interact with the applications. Popular applications for mobile computing devices include map applications that enable users to obtain various geographical information (e.g., current location information presented on a map).

[0005] Application programming interfaces can allow applications implemented on computing devices to interact with various services to provide information and functionality to users. Application programming interfaces can provide developers with tools that facilitate embedding information, programming, services, frameworks, and structures into applications accessed by users. Summary of the Invention

[0006] Aspects and advantages of embodiments of the present disclosure will be set forth in part in the following description, or may be learned from the description, or may be learned through practice of the embodiments.

[0007] An exemplary aspect of the present disclosure is directed to a computer program product, including (such as a non-transitory computer-readable medium storing instructions, but also including a program that may optionally be downloaded over a communication network but not necessarily stored in a non-transitory form), which implements an application programming interface for obtaining navigation information for a software application to be executed on an iOS computing device implementing an iOS operating system. The computing device may have one or more processors and a display device. The application programming interface may include a first set of instructions associated with a navigator class. The navigator class may specify a plurality of functions for controlling a navigation service implemented by the software application. The navigation service may provide navigation information to a user of the software application. The API may include a second set of instructions associated with a navigator delegate protocol. The navigator delegate protocol may be a delegate of the navigator class. The navigator delegate protocol may implement one or more calls for updating navigation information provided as part of the navigation service.

[0008] A first manifestation of the present disclosure is a computer program product including instructions for implementing an application programming interface for obtaining navigation information for a software application to be executed on an iOS computing device implementing an iOS operating platform, the computing device having one or more processors and a display device, the application programming interface including:

[0009] A first set of instructions associated with a navigator class that specifies a plurality of functions for controlling a navigation service implemented by a software application, the navigation service providing navigation information to a user of the software application, the functions including one or more of displaying a route, starting navigation, stopping navigation, and changing a camera angle; and

[0010] A second set of instructions associated with a navigator delegate protocol that is a delegate of the navigator class and that implements one or more calls to update the navigation information provided as part of the navigation service.

[0011] A second manifestation of the present disclosure is a method for integrating a navigation service as part of a software application using a navigation application programming interface on an iOS computing device having one or more processors, the computing device implementing an iOS operating system, the method including:

[0012] Instantiating a map view class by one or more processors to provide a map for display;

[0013] The one or more processors creating one or more instances of a navigator class designated as part of the navigation application programming interface;

[0014] Binding an instance of the navigator class to the map by the one or more processors to combine the map with displaying a route and turn-by-turn route guidance; and

[0015] Implementing a navigation service by the one or more processors using the navigation application programming interface.

[0016] A third manifestation of the present disclosure is a computing device implementing an iOS operating system, including:

[0017] A display device;

[0018] One or more processors; and

[0019] One or more storage devices, wherein the one or more storage devices store computer-readable instructions for implementing an application programming interface that is called by a software application to obtain navigation information to provide a navigation service as part of the software application, the instructions including:

[0020] A first set of instructions associated with a navigator class, the navigator class specifying multiple functions that control a navigation service implemented by a software application, the navigation service providing navigation information to a user of the software application, the functions including one or more of displaying a route, navigation start, navigation stop, and camera angle change;

[0021] A second set of instructions associated with a navigator delegate protocol, the navigator delegate protocol being a delegate of the navigator class, the navigator delegate protocol implementing one or more calls to update the navigation information provided as part of the navigation service; and

[0022] A third set of instructions associated with a UI settings class, the UI settings class specifying one or more parameters that control a user interface associated with a navigation service presented by the software application;

[0023] Wherein, the navigator class is configured as a controller of an instance of a map view class to display a navigation route in combination with a map associated with the instance of the map view class.

[0024] Other exemplary aspects of the present disclosure are directed to systems, devices, computer program products (such as tangible, non-transitory computer-readable media), user interfaces, storage devices, and electronic devices associated with an application programming interface for providing navigation information.

[0025] With reference to the following description and the appended claims, these and other features, aspects, and advantages of the various embodiments will be better understood. The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments of the present disclosure and, together with the description, serve to explain the relevant principles. BRIEF DESCRIPTION OF THE DRAWINGS

[0026] A detailed discussion of embodiments for those of ordinary skill in the art is set forth in the specification with reference to the accompanying drawings, wherein:

[0027] Figure 1 Depicts an overview of an example system for using an application programming interface to implement a navigation service as part of a software application according to an exemplary embodiment of the present disclosure;

[0028] Figure 2 Depicts a block diagram of an example user device implementing a software application according to an exemplary embodiment of the present disclosure;

[0029] Figure 3 Depicts a flowchart of an exemplary method according to an exemplary embodiment of the present disclosure;

[0030] Figure 4 Depicts an exemplary navigation application programming interface according to an exemplary embodiment of the present disclosure;

[0031] Figure 5 Depict an exemplary first instruction set associated with a navigator class according to an exemplary embodiment of the present disclosure;

[0032] Figure 6 Depict an exemplary second instruction set associated with a navigator delegate protocol according to an exemplary embodiment of the present disclosure. Detailed Description

[0033] Reference will now be made in detail to the embodiments, one or more examples of which are illustrated in the accompanying drawings. Each example is provided by way of explanation of the embodiments, not limitation of the disclosure. In fact, it will be apparent to those skilled in the art that various modifications and variations can be made to the embodiments without departing from the scope or spirit of the disclosure. For example, features illustrated or described as part of one embodiment can be used with another embodiment to yield yet another embodiment. Accordingly, it is intended that aspects of the disclosure cover such modifications and variations.

[0034] Exemplary aspects of the present disclosure are directed to an application programming interface (“API”) for providing navigation information in a software application implemented on one or more computing devices implemented on an iOS operating platform (e.g., using the iOS operating system). The iOS operating platform is a mobile operating system created for use on mobile devices. As used herein, an “iOS computing device” refers to a computing device that implements the iOS operating system.

[0035] In some embodiments, the navigation API can allow an application developer to embed a navigation experience provided by a navigation data provider or other source in their software application. The API can allow the developer to easily customize and tailor the navigation experience to fit different platforms and end use cases.

[0036] More specifically, when called by a software application implemented on an iOS computing device, the API can be configured to request and receive route information from a data provider (e.g., a remote data provider or a data provider stored locally on the iOS computing device). The API can be configured to present navigation information (e.g., via a graphical user interface component or via audio and / or vibration cues) based on the route information to provide a navigation service embedded in the software application.

[0037] A navigation service can be an application (such as a software application) that provides navigation information that can be used to guide a user from a starting point to a destination. In some embodiments, the navigation service embedded in a software application can provide navigation information (such as turn-by-turn navigation information) to the user as the user travels along a navigation route or other path. More specifically, in some embodiments, the navigation service can receive a route that directs the user from a current location to a destination. As an example, a route can include a series of steps, each step describing a route segment (such as the name or number of a road, distance, travel time, speed limit) and a maneuver (such as a left turn, a right merge, going straight) to reach the next route segment. The navigation service can provide the route to the user through a graphical user interface and via one or more cues (such as audio or video cues) to guide the user from the starting point to the destination.

[0038] In some embodiments, the software application can interact with a route engine implemented by a navigation data provider or other source (such as a local navigation information source) via an API to obtain route information and other navigation information. The navigation data provider can be associated with an entity separate from the developer of the software application. For example, the navigation data provider can be associated with a web server that hosts a geographic information system. The navigation information can include a route to one or more waypoints. The navigation information can further include map data for presenting in combination with the route and other information. As the user traverses the navigation route, the navigation information can be continuously updated (such as through one or more event listener interfaces implemented as part of the API) to provide the user with a real-time or near real-time navigation experience.

[0039] When implemented by the software application, the API can visually present navigation information associated with the navigation service in a graphical user interface component that is displayed in conjunction with the software application. For example, the graphical user interface component can display a map. During the navigation mode, the graphical user interface component can display the route as a polyline on the map. As the user navigates the route, the user's position can be updated along the route. For example, the navigation service can provide a graphical user interface in which the user's position is continuously updated along the navigation route as the user's position changes. Individual waypoints can be identified by markers located on the map. Other information, such as the estimated time or distance to a waypoint (“ETD information”), a compass interface element, a navigation pointing element, etc., can be presented in the graphical user interface component. In some embodiments, audio guidance can be used to provide navigation information with or without a visual display of the navigation information in the graphical user interface component.

[0040] According to specific aspects of the present disclosure, the API can include a set of computer-readable instructions that, when executed by one or more processors, facilitate integrating a navigation experience into a developer's software application. When implemented by one or more processors, the set of instructions can manage the interaction of the software application with a navigation data provider via the API and the display and / or delivery of navigation information to a user as part of the software application.

[0041] More specifically, example instructions associated with an API for software application developers can include a set of instructions that specify one or more parameters that govern the display of the visual output of a navigation service. The API can further include a set of instructions that specify one or more parameters that control the implementation of the navigation service and a set of instructions that govern the interaction of the API with a route engine provided by a navigation data provider.

[0042] According to specific aspects of the present disclosure, a navigation API can include a developer-facing API that includes a plurality of main classes and protocols. These classes can include a navigation service class that can include utility functions for providing terms and conditions and / or license information associated with the API. These classes can include a navigator class. The navigator class can be a singleton that provides functions for programmatically controlling navigation. The functions can include, for example, one or more of route display, navigation start, navigation stop, and camera angle change. In some embodiments, the API can include a UI settings class that can be used by a developer to specify settings related to UI elements.

[0043] In some embodiments, the API can include a navigator delegate protocol. The navigator delegate protocol can be specified as a delegate of the navigator class. The navigator delegate protocol can specify navigation-related callbacks (e.g., location updates, remaining time, and / or remaining distance updates, etc.).

[0044] In some embodiments, the navigation API can further use or share functions with a map application programming interface. The map application programming interface can include a map view class that provides a camera follow function. In some embodiments, the camera follow function can be used with or without the navigator class being instantiated.

[0045] In some embodiments, the relationship between the navigator class and the map view class can be specified such that the navigation API can reuse or implement one or more aspects of the functionality of the map view class that is specified as part of a separate map API. In some embodiments, the navigator class can control an instance of an existing map view class to combine the map display with route and navigation user interface elements. In some embodiments, the map view class can be wrapped into the navigator class.

[0046] Aspects of the present disclosure can provide many technical effects and benefits. For example, the API can facilitate the integration of navigation services into the developer's software application. Using a delegation protocol for callbacks to obtain navigation information (e.g., location updates, remaining time, and / or remaining distance updates, etc.) can facilitate implementation in an iOS operating platform environment. The fact that the callback is performed by the API rather than the software application enhances the security and reliability of the system (e.g., the developer of the API can implement a communication security protocol, which is reliable and does not have to be disclosed to the developer of the software application). The relationship between the navigator class and the map view class can be that the navigation API shares functionality with an existing map API that provides functions such as drawing a map, displaying traffic information, setting a manual camera angle, adding markers, etc. The API can allow customization of the navigation service for various end-use requirements, such as ride-sharing applications, transportation / delivery applications, social applications, and other end-use applications.

[0047] Aspects of the present disclosure relate to class, function, property, and protocol names (e.g., navigator class, navigator delegate protocol, UI settings class, update location function, reach waypoint function, change route function, reach waypoint function, update remaining time function, set destination function, map view class, navigation waypoint class, navigation map class, etc.). A person of ordinary skill in the art, using the disclosure provided herein, will understand that the class names provided are for identification purposes only and are not intended to limit the scope of the present disclosure. For example, the navigator class can be any class that includes one or more aspects of the navigator class described herein, regardless of the name.

[0048] Figure 1 An overview of an example system 100 for implementing a navigation service as part of a software application using a navigation API in accordance with an example embodiment of the present disclosure is depicted. System 100 can include a user device 112 that can receive navigation data from a navigation data provider 114 via a communication network 116. For example, the user device 112 can be a smart phone, a tablet computer, a wearable device, a laptop computer, a desktop computer, a mobile device, a device that can be carried by a user during operation, a display with one or more processors, a vehicle system, or other user device 112.

[0049] A software application 120 can be implemented on the user device 112. For example, the software application can be a map application, a browser, a ride-sharing application, an application for assisting with delivery, a social media application, or other software applications that may need to provide navigation information to a user. The software application 120 can be stored locally on the user device 112, or can be a web application accessed, for example, via a browser implemented on the user device 112. In some embodiments, the software application 120 can be developed by a third-party entity that is independent of and / or not affiliated with the entity associated with the navigation data provider 114.

[0050] The software application 120 can invoke the navigation API 130 to access and provide navigation data from the navigation data provider 114 via the communication network 116, such that the navigation service can be embedded in the software application 120. For purposes of illustration and discussion, example aspects of the present disclosure discuss accessing data from a remote navigation data provider 114. One of ordinary skill in the art, using the disclosure provided herein, will understand that the API 130 can access data from other sources, other sources such as from a local source or an application located on the user device 112.

[0051] As the user or vehicle carrying the user device 112 travels along a route from a starting point to one or more destinations, the navigation service can present navigation information (e.g., turn-by-turn navigation information) to the user in real time or near real time. The navigation service can include a graphical user interface component for presenting navigation information to the user on one or more display devices. Additionally and / or the navigation service can provide the user with audio guidance or other notifications (e.g., vibration notifications) indicating the navigation information (e.g., turn-by-turn route directions).

[0052] Referring again Figure 1 , the API 130 can be configured to interface with a route engine 140 implemented by the navigation data provider 114. For example, the route engine 140 can be configured to compute routes to one or more waypoints, access map data, update navigation data based on individual navigation events, and respond to requests for navigation data from the API 130. In some embodiments, the navigation data provider 114 can include one or more servers, such as a web server. The one or more servers can include one or more processors and one or more memory devices. The one or more memory devices can store computer-readable instructions to implement, for example, the route engine 140. In some embodiments, the route engine 140 can access data associated with, for example, a geographic information system 115. The geographic information system 115 can include data indexed by the geographic coordinates of elements of the data. Data associated with the geographic information system 115 can include, for example, map data, route data, geographic images, data associated with individual waypoints (e.g., business listing names, addresses, geographic coordinates, etc.), and other data.

[0053] Application 120 can implement a navigation service by interacting with a navigation data provider 114 via an API 130 over a network 116. The network 116 can be any type of communication network, such as a local area network (e.g., an intranet), a wide area network (e.g., the Internet), a cellular network, or some combination thereof. The network 116 can also include a direct connection. Generally, various communication protocols (e.g., TCP / IP, HTTP, SMTP, FTP), encodings or formats (e.g., HTML, XML), and / or security schemes (e.g., VPN, secure HTTP, SSL) can be used to perform communication over the network 116 using any type of wired and / or wireless connection.

[0054] Figure 2 Depicted is an example user device 112 configured to implement a navigation API 130 in accordance with an example embodiment of the present disclosure. As shown, the user device 112 includes: an instruction memory 152, one or more processors 154 configured to execute instructions stored in the memory 152, a display device 156, a network interface 158 supporting network communication, and a storage memory 160. For clarity, the instruction memory 152 and the storage memory 160 are shown separately. However, it will be understood that components 152 and 160 can also be regions within the same memory module. More generally, the user device 112 can include one or several additional processors, memory devices, network interfaces, which can be provided separately or on the same chip or board. Additionally, components 152 and 160 can include persistent memory (e.g., flash memory), volatile memory (e.g., RAM), or both, or other suitable memory.

[0055] The instruction memory 152 can store an operating system (OS) 170, a navigation API 130, and an instruction set of a software application 120. The OS 170 can be a mobile OS developed specifically for mobile devices. Thus, the OS 170 can include functionality that allows software applications to access data such as wireless network parameters (e.g., identification of a wireless network, quality of service) and to invoke services such as telephony, location determination (e.g., via Global Positioning Service (GPS) or WLAN), initiation of a wireless network data call, etc. In some exemplary implementations, the OS includes or is based on the iOS mobile operating system or a similar operating system.

[0056] For example, the software application 120 can be a map application, a navigation application, a ride-sharing application, an application to assist with deliveries, a social media application, etc. Additionally, the software application 120 can be a web browser application that invokes the navigation API 130 to display navigation information within an assigned portion of the browser window. Generally, the navigation API 130 can be available to any suitable software application executing on the user device 120. Additionally, multiple different software applications can invoke the navigation API 130.

[0057] As described above, the software application 120 can invoke the navigation API 130 to embed a navigation service within the software application 120. For example, in one example, the software application 120 can provide one or more waypoints to the navigation API 130. The navigation API 130 can request navigation data from a navigation data provider (e.g., local or remote) to determine a navigation route based on the one or more waypoints. The navigation API 130 can include an instruction set that controls the presentation of navigation information to the user as part of the navigation service. In some embodiments, the navigation API 130 can use or share functionality through the map API 135. For example, the map view class provided as part of the map API 135 can be used in various ways in combination with the navigation API 130 to provide map functionality and navigation functionality to the user of the software application 120.

[0058] In some embodiments, the user device includes a positioning system. The positioning system can include one or more devices or circuits for determining the location of the device. For example, the positioning device can determine the actual or relative location by: using a satellite navigation positioning system (e.g., GPS system, Galileo positioning system, Global Navigation Satellite System (GLONASS), BeiDou satellite navigation and positioning system), an inertial navigation system, a dead reckoning system, based on an IP address, by using triangulation and / or proximity to cell towers or WiFi hotspots, beacons, etc., and / or other suitable techniques for determining location.

[0059] The navigation API 130 and / or the map API 135 can be implemented as one or more functions, data structures, etc. In addition, the navigation API 130 and / or the map API can include compiled code that is executed directly on the processor 154, or alternatively, instructions in any other form such as a scripting language that is interpreted by the application 120 at runtime. In some embodiments, the instructions can be implemented at least in part using a programming language such as Swift or Objective C. In an exemplary implementation, the navigation API 130 and / or the map API 135 include properly documented prototypes of several functions that a developer can include in the code of the software application 120, as well as instructions for implementing these functions. In some embodiments, the navigation API 130 and / or the map API 134 can be provided to the developer as a static library.

[0060] The navigation API 130 is shown as separate from Figure 2 the map API 135 in. However, in some embodiments, the navigation API 130 can be included as part of the functionality of the entire map API 135. In some embodiments, the map API 135 can be included as part of the functionality of the navigation API 130.

[0061] Figure 3 A flowchart depicting an exemplary method (300) performed by the processor 154 of the mobile device 112 to integrate a navigation service as part of a software application using the navigation API, in accordance with an exemplary embodiment of the present disclosure. Figure 3 The steps are depicted for purposes of example and discussion as being performed in a particular order. Those of ordinary skill in the art, using the disclosure provided herein, will understand that the various steps of any method provided herein can be adjusted, extended, omitted, performed concurrently, and / or modified in various ways without departing from the scope of the present disclosure.

[0062] At (302), the method can include providing an API key to a service class when the software application is launched. The service class can be a service class for the map API. The service class can include shared service functions that share an instance of the service class with the map API. The service class can include a provide API key function that can provide the API key to the providers of the map API and the navigation API. The service class can further include a license function configured to return license information. The service class can include a version function configured to return the release version of the map API.

[0063] At (304), the method can include instantiating a map view class in a view controller and adding it to the view hierarchy. This can result in the display of a map on which markers and polylines can be added.

[0064] At (306), a navigator instance of a navigator class associated with the navigation API can be created. Details about the navigation class will be provided below. Then, the navigator can be bound to the map (308) such that route finding and turn-by-turn route guidance are displayed.

[0065] Then, the navigation API can be used to implement the navigation service. For example, a navigation route can be obtained from a route engine such as (510). Once the route is obtained, the route can be displayed on the map. At (312), a navigation mode can be entered where camera changes and turn-by-turn route guidance are displayed as the user travels along the route. Navigation can continue until the destination is reached or the navigation mode is exited (314).

[0066] An exemplary implementation of the above method is provided as follows:

[0067] / *

[0068] MyAppDelegate.mm

[0069] * /

[0070] -(BOOL)application:(UIApplication*)application

[0071] didFinishLaunchingWithOptions:(NSDictionary*)launchOptions{

[0072] [GMSServices provideAPIKey:kAPIKey];

[0073] }

[0074] / *

[0075] MyAppNavigationViewController.mm

[0076] * /

[0077] @interface MyAppNavigationViewController()<

[0078] GMSNavigatorDelegate,

[0079] GMSUIControllerNavigationDelegate>

[0080] @end

[0081] @implementation MyNavigationViewController{

[0082] GMSMapView *_mapView;

[0083] GMSNavigator *_navigator;

[0084] }

[0085] -(void)loadView{

[0086] / / Build the map

[0087] _mapView = [GMSMapView mapWithFrame:CGRectZero];

[0088] _mapView.delegate = self;

[0089] self.view = _mapView;

[0090] / / Request the navigator via a callback. The terms and conditions will be shown.

[0091] __weak typeof(self) *weakSelf = self;

[0092] [GMSNavigationService showTermsAndConditionsDialog:^(BOOL result) {

[0093] typeof(self) *strongSelf = weakSelf;

[0094] if (result && strongSelf) {

[0095] [self fetchNavigator]

[0096] } else {

[0097] / / Rejected the terms. Exit the view.

[0098] }

[0099] }];

[0100] }

[0101] / *

[0102] Fetch the shared navigator instance and configure the navigation map and UI.

[0103] * /

[0104] -(void)fetchNavigator{

[0105] / / Request the navigator.

[0106] _navigator = [[Navigator alloc] init];

[0107] _navigator.delegate = strongSelf;

[0108] / / Configure UI settings.

[0109] GMSUISettings *settings = _mapView.settings;

[0110] settings.navigationHeader = NO;

[0111] settings.trafficIncidentCards = NO;

[0112] settings.delegate = self;

[0113] / / Control the map

[0114] _mapView.navigator = _navigator;

[0115] }

[0116] / *

[0117] When a new job is available, display the route to the destination.

[0118] * /

[0119] -(void)newJobIsAvailableToCoordinate:(CLLocationCoordinate2D)coordinate{

[0120] GMSNavigationWaypoint *destination =

[0121] [[GMSNavigationWaypoint alloc] initWithCoordinate:coordinate];

[0122] [_navigator setDestinationsWithWaypoints:@[destination]

[0123] options:[GMSRoutingOptions defaultOptions]

[0124] callback:^(RouteStatus routeStatus){

[0125] if(routeStatus == kRouteStatusOk){

[0126] _mapView.cameraMode = kGMSNavigationCameraModeRouteOverview;

[0127] }

[0128] }];

[0129] }

[0130] / *

[0131] Enter the navigation mode.

[0132] * /

[0133] -(void)acceptJobButtonWasPressed{

[0134] _navigator.guidanceEnabled = YES;

[0135] _mapView.cameraMode = kGMSNavigationCameraModeFollowing;

[0136] }

[0137] @end

[0138] Figure 4 Depict a block diagram of an exemplary instruction set associated with the navigation API 130 according to an exemplary embodiment of the present disclosure. As shown, the navigation API 130 can include a navigation service class 402, a UI settings class 404, a navigator class 410, and a navigator delegate 440. The API 130 can include other classes / protocols 406. Details regarding the navigation service class 402, the UI settings class 404, the navigator class 410, the navigator delegate 440, and other classes / protocols that can be used in the exemplary embodiments are provided below.

[0139] The navigation service class 402 can expose common methods for the navigation API 130. The navigation service class 402 can be a service class for the navigation API 130. The navigation service class 402 can include static public member functions, which include whether the user has accepted the terms and conditions, if the user has not accepted, and if it is necessary to display the terms and conditions, a terms and conditions acceptance function that returns to display the terms and conditions and a license information function that returns the software license information for the navigation API. Hereinafter, an exemplary embodiment of the navigation service class 402 is provided:

[0140] / **

[0141] * Called when the user accepts or rejects the terms and conditions

[0142] * /

[0143] typedef void(^GMSTermsResponseCallback)(BOOL result);

[0144] / **

[0145] * Provides utility methods for the navigation SDK.

[0146] * /

[0147] @interface GMSNavigationServices:NSObject

[0148] / **

[0149] * Prompts the user through a dialog box containing the terms and conditions for using the navigation SDK.

[0150] * /

[0151] +(void)

[0152] showTermsAndConditionsDialogOnViewController:(UIViewController*)controller callback:(GMSTermsResponseCallback)callback;

[0153] / **

[0154] * Checks whether the user has accepted the terms and conditions.

[0155] * /

[0156] +(BOOL)termsHaveBeenAccepted;

[0157] / **

[0158] * Return the open source software license information for the Google Maps SDK for iOS. This information must be made available in your app.

[0159] * /

[0160] +(NSString*)openSourceLicenseInfo;

[0161] / **

[0162] * Return the release version of the Google Navigation SDK for iOS

[0163] * /

[0164] +(NSString*)SDKVersion;

[0165] @end

[0166] The navigator class 410 can be a controller for navigation functions, allowing for the combination of map display of routes, start and stop of navigation, camera angle changes, etc. In some embodiments, the navigator class 410 can control an instance of a map view class that displays the route and turn-by-turn route guidance. In some embodiments, the navigator class 410 can be used to provide navigation updates (e.g., location, ETA) without any map being visible in the user interface. The navigator class 410 can be a singleton. In some embodiments, the navigator class 410 does not support subclasses. It can be required to call all methods from the main thread.

[0167] Figure 5 Depict an exemplary navigator class 410 according to an exemplary embodiment of the present disclosure. The navigator class 410 can include multiple functions. For example, the navigator class 410 can include a set destination callback function 412 that can set multiple destinations for navigation and can override any previously set destinations. This callback can be called with an ok status when a route to one or more destinations is found.

[0168] The Navigator class 410 can include a continuation of the next destination function 414 that pops the first destination from the current destination list. The Navigator class 410 can include a clear destinations function 416 that clears all previously set destinations and removes any calculated routes from the map. The Navigator class 410 can include a function 418 that returns the estimated time to a given waypoint, or the maximum value if the waypoint is not part of the current route. The Navigator class 410 can include a function 420 for the distance to a waypoint, which can return the estimated distance to a given waypoint, or the maximum value if the waypoint is not part of the current route. The Navigator class 410 can include a simulated position function 422 along an existing route, which can simulate traveling along the route currently set on the Navigator class 410. The Navigator class 410 can include a stop simulation function 424 that can end the simulation when the simulation is valid.

[0169] In some embodiments, the Navigator class 410 can include multiple properties. Some properties can be updated by the navigator delegate protocol. The properties can include a guidance active property 426 that provides whether turn-by-turn guidance is currently enabled, a time to next destination property 428 that provides the estimated time to the next destination, a distance to next destination property 430 that can provide the estimated distance to the next destination, a current route segment property 432 that can provide the current segment of the trip, a route segments property 434 that can provide an array of route segments where each segment corresponds to a set destination, a voice guidance property 436 that indicates whether voice guidance should be enabled for traffic and turn-by-turn alerts, and a vibration enabled property 438 that can determine whether the device should vibrate when a voice alert is played.

[0170] Below, an exemplary interface for the Navigator class 410 is provided:

[0171] / **

[0172] * GMSRouteStatus is a status code representing the result of a route request.

[0173] * /

[0174] typedef NS_ENUM(NSInteger, GMSRouteStatus) {

[0175] / ** The route to the destination was successfully calculated. * /

[0176] GMSRouteStatusOk = 1,

[0177] / ** The route to the destination could not be calculated. * /

[0178] GMSRouteStatusNoRouteFound = 2,

[0179] / **The route to the destination cannot be calculated due to a network error.* /

[0180] GMSRouteStatusNetworkError = 3,

[0181] / **The route to the destination cannot be calculated due to insufficient quota.* /

[0182] GMSRouteStatusQuotaCheckFailed = 4,

[0183] / **The route cannot be calculated because the provided API key has no permission to use the navigation SDK.* /

[0184] GMSRouteStatusAPIKeyNotAuthorized = 5,

[0185] / **The route cannot be calculated because the user has not accepted the terms and conditions of the navigation SDK.* /

[0186] GMSRouteStatusTermsAndConditionsNotAccepted = 6,

[0187] / **Route calculation is cancelled to support route updates.* /

[0188] GMSRouteStatusCancelled = 7,

[0189] / **The route cannot be calculated because the user has turned off the GPS location* /

[0190] GMSRouteStatusLocationDisabled = 8,

[0191] };

[0192] / **

[0193] *Called when a route from the user's location to the provided destination is found or not found due to the reasons indicated by RouteStatus* /

[0194] typedef void(^GMSRouteStatusCallback)(GMSRouteStatus routeStatus);

[0195] / **

[0196] * Allows to start, control, and monitor a navigation session by finding a route to the destination, entering navigation mode, and providing information such as remaining distance and ETA. The navigator can control the GMSMapView on the route and will display turn-by-turn route guidance.

[0197] *

[0198] * This class is a singleton and the [Navigator sharedNavigator] method should be used to obtain the shared instance.

[0199] * /

[0200] @interface GMSNavigator:NSObject

[0201] / **

[0202] * Provides the shared GMSNavigator instance and creates it if needed. Call this method only after:

[0203] - having used [GMSServices provideAPIKey: <key>, provide an API key;

[0204] - The terms and conditions of the Navigation SDK have been displayed and accepted.

[0205] *

[0206] * If any of these conditions are not met, the method will throw an exception

[0207] * /

[0208] +(instancetype)sharedNavigator;

[0209] +(instancetype)init;

[0210] / **

[0211] * Set a delegate that can receive callbacks from the navigator due to changes in the navigation state, such as location updates, changes in remaining time or distance, or changes in the planned route.

[0212] * /

[0213] @property(nonatomic,weak)

[0214] id <gmsnavigatordelegate>GMS_NULLABLE_PTR delegate;

[0215] / **

[0216] * Provide access to the GMSNavigationUISettings for this navigator that contains methods for the appearance of configuration UI elements such as navigation headers, footnotes, and compasses.

[0217] * /

[0218] @property(nonatomic,readonly) GMSNavigationUISettings *navigationUISettings;

[0219] / **

[0220] * Set the threshold for how much the remaining trip time must change before the didUpdateRemainingTimeOrDistance delegate method is called.

[0221] * /

[0222] @property(nonatomic) NSTimeInterval timeChangedThreshold;

[0223] / **

[0224] * Set the threshold for how much the remaining trip distance must change before the didUpdateRemainingTimeOrDistance delegate method is called.

[0225] * /

[0226] @property(nonatomic) CLLocationDistance distanceChangedThreshold;

[0227] / **

[0228] * Set the type of audio guidance (including vibration) to be enabled. By default, vibration, voice, and Bluetooth voice (if available) are enabled.

[0229] * /

[0230] @property(nonatomic) GMSAudioGuidance audioGuidance;

[0231] / **

[0232] *Returns the route travelled so far during the guidance session (since the last call to startGuidance). The recorded route includes road snap positions, which are provided to the GMSNavigatorDelegate, and is simplified to remove redundant points, such as turning consecutive collinear points into a single line segment.

[0233] * /

[0234] @property(nonatomic,readonly,copy) GMSPath * GMS_NULLABLE_PTR travelledRoute;

[0235] / **

[0236] *The current segment of the journey. The RouteSegment will have the starting position as the latest known (road snap) position of the device.

[0237] * /

[0238] @property(nonatomic,readonly,copy)

[0239] GMSRouteSegment * GMS_NULLABLE_PTR currentRouteSegment;

[0240] / **

[0241] *An array of route segments, each corresponding to a destination set by setDestinationsWithWaypoints:options:callback.

[0242] * /

[0243] @property(nonatomic,readonly,copy) GMS_NSArrayOf(GMSRouteSegment *) * GMS_NULLABLE_PTR routeSegments;

[0244] / **

[0245] *The estimated time and distance from the current position to the current destination.

[0246] * /

[0247] @property(nonatomic,readonly,copy) GMSTimeAndDistance * GMS_NULLABLE_PTR timeAndDistanceToNextDestination;

[0248] / **

[0249] * The array of time and distance corresponds to each destination in the current route, representing the estimated time and distance from the current location to each destination

[0250] * /

[0251] @property(nonatomic,readonly,copy)

[0252] GMS_NSArrayOf(GMSTimeAndDistance *) * GMS_NULLABLE_PTR

[0253] timesAndDistances;

[0254] / **

[0255] * Set the navigator to control the provided map and if there is a map, stop controlling the previous map. This causes the camera to immediately start following the user's location. When the navigator is in control, some map properties are overridden, for example, the map type will temporarily change to normal, except for the current value of the mapType property.

[0256] *

[0257] * If navigation is in progress, the current route and turn-by-turn route guidance will be immediately displayed.

[0258] * /

[0259] -(void)startControllingMap:(GMSMapView *)mapView;

[0260] / **

[0261] * If currently set, stop the GMSNavigator from controlling the current GMSMapView. Navigation is not stopped. Reminders will continue to be generated and route information such as remaining distance will continue to be calculated.

[0262] *

[0263] *This causes any map properties that were overridden during navigation to be reconsidered with the current property values. For example, if mapType is set to GMSTypeHybrid, the map will now return to display in hybrid mode.

[0264] * /

[0265] -(void)stopControllingMap;

[0266] / **

[0267] * Sets multiple destinations for navigation, superseding any previously set destinations.

[0268] *

[0269] * If a route is found from the user's location to the given destination, the provided callback is invoked with GMSRouteStatusOk. If a new destination is set before a route is found, the request is cancelled and the callback is invoked with GMSRouteStatusCancelled. If a route cannot be found for any other reason, the callback is invoked with the appropriate error status.

[0270] * /

[0271] -(void)

[0272] setDestinationsWithWaypoints:(GMS_NSArrayOf(GMSNavigationWaypoint*)*)waypoints options:(GMSRoutingOptions*)options

[0273] callback:(GMSRouteStatusCallback)callback;

[0274] / **

[0275] * Removes the current destination. After this call, the guidance will proceed to the next destination and information about the old destination will no longer be available.

[0276] *

[0277] * @return The waypoint that the guidance is heading towards, or null if no waypoints remain.

[0278] * /

[0279] -(GMSNavWaypointGMS_NULLABLE_PTR)continueToNextDestination;

[0280] / **

[0281] * Clear all previously set destinations and remove any calculated routes from the map. If navigation is running, it will be automatically stopped.

[0282] * /

[0283] -(void)clearDestinations;

[0284] / **

[0285] * If a destination is set and its route is calculated, start turn-by-turn navigation guidance for that route. If the route has not been calculated yet, turn-by-turn guidance will start as long as there is one.

[0286] * /

[0287] -(void)startGuidance;

[0288] / **

[0289] * Stop turn-by-turn navigation guidance.

[0290] * /

[0291] -(void)stopGuidance;

[0292] / **

[0293] * Set the camera to follow the user's location. Usually called when starting turn-by-turn guidance to enter the "tilt" driving view. Can be used to restart camera following after calling showRouteOverview, or the manual camera setter methods of GMSMapView.

[0294] * /

[0295] -

[0296] (void)followMyLocationWithPerspective:(GMSNavigationCameraPerspective)perspective;

[0297] / **

[0298] * Pan and zoom the map to show an overview of the remaining route. Will temporarily prevent the camera from following the user's location.

[0299] *

[0300] * Use followMyLocationWithPerspective to restart camera following.

[0301] * /

[0302] -(void)showRouteOverview;

[0303] @end

[0304] Reference Figure 6 , the navigator delegate protocol 440 can be the delegate of the navigator class 410. The navigator delegate 440 can include multiple functions. For example, the navigator delegate can include an update location function 442 that is called when the user's location is updated. The navigator delegate 440 can include a reach waypoint function 444 that can be called when the user reaches a navigation waypoint. The navigator delegate 440 can include a change route function 446 that is called when the current route is changed or cleared. The navigator delegate 440 can include an update remaining time function 448 that is called when the estimated time to the destination is updated. The navigator delegate 440 can include an update remaining distance function 450 that is called when the estimated distance to the destination is updated. The navigator delegate 440 can access or specify a navigator time update threshold parameter that specifies the minimum change in the estimated time to the next destination that will trigger the call to the update remaining time function 448. The navigator delegate 440 can access or specify a navigator distance update threshold parameter that specifies the minimum change in the estimated distance to the next destination that will trigger the call to the update remaining distance function 450.

[0305] An exemplary implementation of the navigator delegate 440 is as follows:

[0306] @protocol GMSNavigatorDelegate <nsobject>

[0307] / **

[0308] * Called when updating the driver's road snapshot position / direction.

[0309] * Provided as frequently as possible by the navigation engine.

[0310] * /

[0311] -(void)navigator:(GMSNavigator*)navigator

[0312] didUpdateLocation:(CLLocation*)location;

[0313] / **

[0314] * Called when the driver arrives at a GMSNavigationWaypoint.

[0315] * /

[0316] -(void)navigator:(GMSNavigator*)navigator

[0317] didArriveAtWaypoint:(GMSNavigationWaypoint*)waypoint;

[0318] / **

[0319] * Called when the route changes. The new route is available via the GMSNavigator route segment property.

[0320] * /

[0321] -(void)navigatorDidChangeRoute:(GMSNavigator*)navigator;

[0322] / **

[0323] * Called when the time or distance to the next destination changes by more than the thresholds specified by the GMSNavigator's timeChangedThresholdSeconds and distanceChangedThresholdMeters properties.

[0324] * /

[0325] -(void)navigator:(GMSNavigator*)navigator

[0326] didUpdateRemainingTimeOrDistance:(GMSTimeAndDistance*)timeAndDistance;

[0327] @end

[0328] Reference Figure 4 , the UI settings class 404 can be used to specify UI settings associated with the navigation API 130. The UI settings class 404 can include a setting all gestures enable function that sets a preference for whether all gestures should be enabled or disabled. The UI settings class can include the following properties: a scroll gesture property that controls whether the scroll gesture is enabled or disabled, a pinch gesture property that controls whether the pinch gesture is enabled or disabled, a tilt gesture property that controls whether the tilt gesture is enabled or disabled, a rotation gesture property that controls whether the rotation gesture is enabled or disabled, a view consumes gesture property that controls whether the map view class fully consumes the user's gesture when the gesture is enabled, a compass button property that enables or disables the compass, a location button property that enables or disables the location button, an indoor picker property that enables or disables the indoor floor picker, and a rotation or scale property that controls whether rotation and scale gestures can be performed centrifugally and scrollably, allowing a scroll gesture during the rotation or scale gesture.

[0329] In the following, exemplary embodiments of the UI settings class are provided:

[0330] / **

[0331] * A controller that allows setting different options for the navigation UI.

[0332] * /

[0333] @interface GMSNavigationUISettings:NSObject

[0334] / **

[0335] * Sets a delegate that can receive callbacks from a GMSNavigationUISettings instance for UI-related events.

[0336] * /

[0337] @property(nonatomic,weak)

[0338] id <gmsnavigationuisettingsdelegate>GMS_NULLABLE_PTR delegate;

[0339] / **

[0340] * Determine whether the turn-by-turn navigation header is visible during navigation.

[0341] * /

[0342] @property(nonatomic) BOOL header;

[0343] / **

[0344] * Determine whether the ETA card is visible during navigation.

[0345] * /

[0346] @property(nonatomic) BOOL etaCard;

[0347] / **

[0348] * Determine whether a traffic incident card should be shown when the user clicks on the traffic incident icon.

[0349] * /

[0350] @property(nonatomic) BOOL trafficIncidentCards;

[0351] / **

[0352] * Determine whether traffic prompts should be shown. Traffic prompts appear periodically to update the user on the traffic conditions during navigation.

[0353] * /

[0354] @property(nonatomic) BOOL trafficPrompts;

[0355] @end

[0356] In some embodiments, the navigation API 130 can include a UI settings delegate that includes a no-change night mode callback. An exemplary implementation of providing the UI settings delegate is as follows:

[0357] / **

[0358] * Represents different modes in which navigation UI elements can be, such as map appearance, header and footer, and buttons.

[0359] * /

[0360] typedef NS_ENUM(NSInteger, GMSNavigationUIMode) {

[0361] / ** The navigation UI is in the normal, daytime mode. * /

[0362] GMSNavigationUINormal = 1,

[0363] / ** The navigation UI is in night mode with a darker UI style * /

[0364] GMSNavigationUINight = 2,

[0365] };

[0366] / **

[0367] * Delegate for navigation UI events.

[0368] * /

[0369] @protocol GMSNavigationUISettingsDelegate <nsobject>

[0370] @optional

[0371] / **

[0372] * Called when the navigation UI enters or exits night mode.

[0373] * /

[0374] -(void)navigationUISettings:(GMSNavigationUISettings*)navigationUISettings

[0375] didChangeUIMode:(GMSNavigationUIMode)mode;

[0376] @end

[0377] Refer to, for example, Figure 4 , the navigation API 130 can include other classes and protocols 406. Certain classes (e.g., classes associated with the map API) can be controlled, called, or wrapped into various aspects of the navigation API 130 by the navigation API 130. The following is a list of classes and protocols used in accordance with an exemplary embodiment of the present disclosure in conjunction with an exemplary embodiment of an API having map and navigation capabilities.

[0378] Address class: The address class can be the result of a reverse geocoding request containing a human-readable address. The address class can be immutable and can be obtained via the geocoder class. The fields in the address class can be zero. The address class can include public member functions, including the addressLine1 function that returns the first line of the address and the addressLine2 function that returns the second line of the address. The address class can include the following properties: a coordinate property that provides the location, a thoroughfare property that provides the street number and name, a locality property that provides the locality or city, and a subLocality property that provides the subdivision, region, or park of the locality.

[0379] CALayer class: The CALayer class can be a superclass used by layers in the API. The CALayer class can be inherited by the map layer class and the panoramic layer class.

[0380] Camera Position Class: The camera position class can be an immutable class that aggregates all camera position parameters. The camera position class can be inherited from a mutable camera position class. The camera position class can include the following functions: including: an initialization with target function with scale, orientation, and view angle as a specified initializer; a camera with target function with scale as a convenience constructor for the camera position class for a specific target and scale level; a camera with latitude function with longitude and scale as a convenience constructor for the camera position class according to the input camera with target function with scale; a camera with targetfunction with scale, orientation, and view angle as a convenience constructor for the camera position class with all camera properties according to the input initialization with target function with scale, orientation, and view angle; a camera with latitude function with longitude, scale, orientation, and view angle as a convenience constructor for the camera position class with latitude, longitude, and all other camera properties according to the initialization with target function with scale, orientation, and view angle; and a zoom atcoordinate function with given meters and points to obtain the scale level of the distance in meters at a given coordinate on the earth and corresponding to a specified number of screen points. The camera position class can include the following properties: a target property that is the position on the earth where the camera is pointed, a scale property that is the scale level, an orientation property that provides the orientation of the camera in degrees clockwise from due north, and a view angle property that provides the angle of the camera in degrees from the lowest point (directly towards the earth).

[0381] Camera Update Classes: Camera update classes can represent updates that can be applied to the map view class. Camera update classes encapsulate some logic for modifying the current camera. Camera update classes can include static public member functions such as the zoom function of the camera update class that returns a camera update for zooming in on the map; the zoom out function of the camera update class that returns a camera update for zooming out on the map; the zoom by function of the camera update class that returns a camera update for changing the zoom by a specific amount; the zoom to function of the camera update class that returns a camera update for setting the zoom to a specified amount; the set target function of the camera update class that returns a camera update for setting the camera target to a specified coordinate; the set target zoom function of the camera update class that returns a camera update for setting the camera target and zooming to a specific value; the set camera function of the camera update class that returns a camera update for setting the camera to a specific camera position class; the fit bounds function of the camera update function that transforms the camera so that specific bounds are centered on the screen at the maximum possible zoom level; the fit bounds padding function that is similar to the fit bounds function but allows the API to specify padding so that the bounding box is inset from the edges of the view; the fit bounds edge inset function that is similar to the fit bounds function but allows specifying an edge inset so that the bounding box is inset from the edges of the view; the scroll X and Y functions of the camera update class that return a camera update for translating the center of the view a specific number of points in the x and y directions; and the zoomby point function of the camera update class that zooms with a fixed focus that stays on the screen.

[0382] Circle Class: The circle class can be a circle (spherical cap) on the Earth's surface. The circle class can be inherited from the overlay class. The circle class can include the circle position and radius function that has as a convenient constructor for the circle class the specific position and radius. The circle class can include the following properties: the position property that provides the position of the center of the circle on the Earth; the radius property that provides the radius of the circle in meters which must be positive; the stroke width property that provides the width of the outline of the circle in screen points; the stroke color property that provides the color of the outline of the circle; the fill color property that provides the color painted inside the circle; the title property that provides the title, a short description of the overlay; the map property that provides the map on which the overlay is; the clickable property that provides whether the overlay should cause click notifications; and the z-index property of the layering system where an overlay with a higher z-index value will be drawn above lower z-index tile layers and overlays.

[0383] Coordinate boundary class: The coordinate boundary class can represent a rectangular bounding box on the Earth's surface. The coordinate boundary class can be immutable. The coordinate boundary class can include functions, including: an initialization coordinate function that initializes the northeast and southwest boundaries corresponding to a rectangular area defined by two corners; an include coordinate function that returns the coordinate boundary class, representing the current boundary extended to include the incoming coordinates; an include boundary function that returns the coordinate boundary class, representing the current boundary extended to include all of the current boundaries defined by other boundaries; an contains coordinate function that returns YES if the incoming coordinates are within the coordinate boundary class; an intersects boundary class that returns YES if the incoming coordinate boundary class overlaps with the coordinate boundary class; an initialize region function initialized by the boundaries of the containing region; an initialize path function initialized by the boundaries of the containing path; and an include path function that returns the coordinate boundary class, representing the current boundary extended to include the path. The coordinate boundary class can include the following attributes: a northeast attribute that provides the northeast corner of the boundary; a southwest attribute that provides the southwest corner of the boundary; and a valid attribute that provides whether the boundary contains any points.

[0384] Geocoder class: The geocoder class can expose a service for reverse geocoding that maps Earth coordinates (latitude and longitude) to a set of addresses near that coordinate. The geocoder class can include functions, including: a reverse geocode coordinates completion handler function that reverse geocodes coordinates on the Earth's surface; and a geocoder function that serves as a convenience constructor for the geocoder class.

[0385] Ground Overlay Class: The ground overlay class can specify the available options for a ground overlay existing on the Earth's surface. The position of the ground overlay can be explicitly specified and it may not face the camera. The ground overlay can inherit from the overlay class (described below). The ground overlay class can include functions, including: a ground overlay bounds and icon function that serves as a convenient constructor for the ground overlay class with specific bounds and icons, and a ground overlay position and icon and zoom level function that constructs the specified icon at the rendering position as if the actual size of the image matches the camera pixels at the zoom level. The ground overlay class can include the following properties: a position property that provides the position of this ground overlay class, more specifically the physical position of its anchor; an anchor property that specifies the position relative to the bounds where the ground overlay class is anchored to the Earth; an icon property that provides the icon to be rendered within the bounds on the Earth; an opacity property that provides the opacity of the ground cover between 0 (fully transparent) and 1 (default); an orientation property that provides the orientation of the ground overlay in degrees; a bounds property that provides the two-dimensional bounds on the Earth where the icon is drawn; a title property that provides the title, a short description of the overlay; a map property that provides the map on which this overlay lies; a clickable property that provides whether the overlay should cause click notifications; and a z-index property that provides the z-index of the layering system where the overlay with a higher z-index value will be drawn above the lower z-index tile layers and overlays.

[0386] Indoor Building Class: The indoor building class can describe a building that contains floors. The indoor building class can include the following properties: a floors property that provides an array of indoor floors that describe the floors that make up the building; a default floor index property that provides the index of the default floor in the floors array; an underground property that provides whether the building is completely underground and supports being hidden.

[0387] Indoor Display Class: The indoor display class can provide the ability to observe or control the display of indoor floor data. The indoor display class can include the following properties: a delegate property that provides the indoor display class delegate; an active building property that provides the currently focused building and will be zero if there is no building with currently focused indoor data; an active level property that provides and controls the active level for the active building.

[0388] Indoor Display Delegate Class: The indoor display delegate class can be a delegate for events on the indoor display class. The indoor display delegate class can include functions such as a change active building function that is raised when the active building changes, and a change active floor function that is raised when the active floor changes.

[0389] Indoor Floor Class: The indoor floor class can describe a single floor in a building. In this case, multiple buildings can share floors, and even if the floor numbers and / or names are different, the floor instances will be compared as equal. The indoor floor class can include the following properties: a name property that provides a localized display name for the floor; a short name property that provides a localized short display name for the floor.

[0390] Map Layer Class: The map layer class can be a custom subclass of the CALayer class that is provided as a layer class on the map view class. The map layer class can inherit from the CALayer class.

[0391] Map View Class: The map view class can be considered the main class of the map API and can have entry points for all functions related to the map. The map view class is typically instantiated using convenience constructors but can also be created through the default function, where the camera will be set to the default position. The map view class can include functions, including: a start rendering function that tells the map to power on its renderer; a stop rendering function that tells the map to turn off its renderer; a clear function that clears all markers and ground overlays added to the map, including markers and polylines; a set minimum and maximum zoom function that sets the minimum and maximum zoom; a camera function for boundary insertion that constructs a camera position class presenting a boundary with a fill; a move camera function that changes the camera based on a camera update class by considering whether the specified camera position actually makes the camera render the same as the equivalent presented position class, taking into account precision and the transformations used internally; an animate camera position function that animates the map's camera to a camera position class, where the animate position class is similar to the animate camera position function but only changes the position of the camera; an animate zoom function that is similar to the animate camera position function but only changes the zoom level of the camera; an animate orientation function that is similar to the animate camera position function but only changes the orientation of the camera; an animate perspective function that is similar to the animate camera position function but only changes the perspective of the camera; an animate camera update function that applies a camera update class to the current camera and then uses the result as in the animation for the camera position function; and a map frame and camera function that constructs and returns a map view class from a frame and a camera target.The map view class can include the following properties: a delegate property that provides a map view class delegate; a camera property that controls the camera and defines how the map is oriented; a projection property that returns a projection class object capable of converting between screen coordinates and latitude / longitude coordinates; a location enable property that controls whether location points and accuracy circles are enabled; a location parameter that reveals whether the user location point is drawn if location is enabled; a selected marker property that provides the selected marker; a traffic enable property that controls whether the map is drawing available traffic data; a map type property that controls the type of map tiles that should be displayed; a map style property that controls the style of the map; a minimum zoom property that provides the farthest minimum zoom at which the camera can be zoomed out; a maximum zoom property that provides the closest maximum zoom at which the camera can be to the Earth; a buildings enable property that provides whether available 3D buildings are shown; an indoor enable property that provides whether available indoor maps are shown; an indoor display property that provides an indoor display class instance that allows aspects of the indoor data display to be observed or controlled; a settings property that provides a UI settings class object that controls the user interface settings for the map; a fill property that controls the visible area of the view; an accessibility element hidden property that provides whether accessibility elements are shown; a layer property that provides an accessor for a custom CALayer type to be used for the layer; a preferred frame rate property that controls the rendering frame rate; a navigation enable property that provides whether navigation functionality is enabled for the map; a navigator property that provides a navigator for the map view class, which allows routes to be requested and turn-by-turn guidance to be initiated; a camera mode property that changes the mode of the camera if navigation is enabled; and a follow perspective property that provides the camera perspective that will be used when following the user location.

[0392] Map View Delegate Class: The map view delegate class can be a delegate for events on the map view class. The map view delegate class can include functions, including: a map view will move function that can be called before the camera on the map changes due to a gesture or animation or by explicitly updating via the camera or a zero-length animation on a layer; a map view did change camera position function that is repeatedly called during any animation or gesture on the map or is called only once when the camera is explicitly set; a map view idle at camera position function that is called when the map becomes idle after any unfinished gesture or animation has completed or after the camera has been explicitly set; a map view did tap at coordinate function that can be called after a tap gesture at a specific coordinate if a marker was not tapped; a map view did long press at coordinate function that can be called after a long press gesture at a specific coordinate; a map view did tap marker function that can be called after a marker has been tapped; a map view did tap info window of marker function that can be called after an info window associated with a marker has been tapped; a map view did long press info window of marker function that can be called after a long press on the info window of a marker; a map view did tap overlay function that can be called after an overlay has been tapped; a map view did tap POI function that can be called after a point of interest has been tapped; a map view marker info window function that can be called when a marker is about to become selected to provide an optional custom info window for that marker if the function returns a UI view; a map view marker info content function that can be called when the map view marker info window function returns zero; a map view did close info window of marker function that can be called when the info window associated with a marker is closed; a map view did start manual marker function that can be called when a drag is started on a marker; a map view did end dragging marker function that can be called when the drag of a marker ends; a map view did drag marker function that can be called while a marker is being dragged; a map view did tap my location button function for the map view that can be called when the location button is tapped; a map view did start picture rendering function that can be called when a tile is requested and rendering starts; a map view did complete tile rendering function that can be called when all tiles have been loaded or have permanently failed and label rendering; and a map view snapshot ready function that is called when the map is stable, where all tiles have been loaded, and all labels have been rendered, and the camera is idle, and all overlay objects have been rendered.

[0393] Marker Class: The marker class can be an icon located at a specific point on the map surface. The icon of the marker class is drawn facing the screen of the viewing device rather than the map surface; that is, it does not have to change orientation due to map rotation, tilt, or zoom. The marker class can inherit from the overlay class. The marker class can include functions that include a marker and a position class that can be a convenience constructor for the default marker, and a marker image and color class that can create a colored version of the default marker image used as the icon. The marker class can include the following properties: a position property that provides the marker position; a snippet property that provides the snippet text shown below the title in the info window when selected; an icon view property that provides the icon view for the marker to be rendered; a track view change property that controls whether the icon for the marker should be redrawn every frame; a track info window change property that controls whether the info window for the marker should be redrawn every frame; a ground anchor property that specifies the point in the icon image that is anchored to the marker position on the Earth's surface; an info window anchor property that specifies the point in the icon image to anchor the info window that can be shown directly above the point; an appearance animation property that controls the animation used when the marker is placed on the map view class; a draggable property that controls whether the marker can be interactively dragged; a plane property that controls whether the marker should be flat relative to the Earth's surface or a billboard facing the camera; a rotation property that is the rotation of the marker clockwise in degrees about the marker's anchor point; an opacity property that provides the opacity of the marker between 0 (fully transparent) and the default 1 (inclusive); a user data property that provides the marker data; a layer property that provides the core animation layer for the marker class; a panoramic view property that provides the panoramic view where the panoramic view will attempt to show the marker; a title property that provides the title, a short description of the overlay; a map property that provides the map on which the overlay is; a clickable property that provides whether the overlay should cause a click notification; and a z-index property that provides the z-index of the layering system where the overlay with a higher z-index value will be drawn above the tile layer and overlay with a lower z-index value.

[0394] Marker Layer Class: The marker layer class can be a custom subclass of CALayer available on a per-marker basis, which allows animation of several properties of its associated marker class. The marker layer class can include the following properties: a latitude property that provides the latitude portion of the position on the marker class; a longitude property that provides the longitude portion of the position on the marker class; a rotation property that provides the rotation according to the marker class; an opacity parameter that provides the opacity according to the marker class.

[0395] Variable Camera Position Class: The variable camera class can be a variable version of the camera position class that inherits from the camera position class. The variable camera position class can include functions, including: an initialization target function with zoom, orientation, and field of view as a specified initializer; a camera target function with zoom as a convenience constructor for the variable camera position class for a specific target and zoom level; a camera latitude function with longitude and zoom as a convenience constructor for the variable camera position class according to the input of the camera target function with zoom; an initialization target function with zoom, orientation, and field of view, a camera target function with zoom, orientation, and field of view as a convenience constructor for the variable camera position class with all camera properties; a camera latitude function with longitude, zoom, orientation, and field of view as a convenience constructor for the variable camera position class with longitude, latitude, and all other camera properties according to the initialization target function with zoom, orientation, and field of view; and a zoom coordinate function with given meters and points to obtain the zoom level at a distance in meters at given coordinates on the earth and corresponding to a specified number of screen points. The variable camera position class can include the following properties: a target property that is the position on the ground towards the camera point; a zoom property that is the zoom level; an orientation property that provides the orientation of the camera in degrees clockwise from due north; and a field of view property that provides the angle of the camera in degrees from the lowest point (directly towards the earth).

[0396] Variable Path Class: The variable path class can be a dynamic array of position coordinates where all coordinates are usually valid. The variable path class can be the variable counterpart of the immutable path class (described below) that inherits from the path class. The variable path class can include public member functions, including an add coordinate function to add coordinates at the end of the path, an add latitude and longitude function to add a new position with given latitude and longitude, an insert coordinate at index function to insert coordinates at a specified index, a coordinate replace index coordinate function to replace the coordinate at a specified index with the specified coordinate, a remove index coordinate function to remove the entry at the index, a remove last coordinate function to remove the last coordinate of the path, a remove all coordinates function to remove all coordinates in the path, an initialize path function to initialize a newly allocated path with the contents of another path, a count function to obtain the size of the path, an index at coordinate function to return the position at a specified index if valid, a path offset by latitude and longitude function to return a new path obtained by adding the specified latitude and longitude to each coordinate of the current path, a length and type segment function to return the fraction of the segment of the path corresponding to a length interpreted according to the type, a type length function to return the length of the path according to the type, a path function as a convenience constructor for an empty path, and a path from encoded path function to initialize a newly allocated path from an encoded path.

[0397] Navigation Waypoint Class: The navigation waypoint class can be an immutable waypoint class used to specify a navigation destination. It can usually be initialized from a location or an identification number, so it has two specified initializers. The navigation waypoint class can include public member functions, including an initializer with location and title, and an initializer with location ID and title. The navigation waypoint class can also include a title property that provides the name of the waypoint.

[0398] Orientation Class: The orientation class can be a tuple of title and spacing used to control the viewing direction of the panoramic camera class. The orientation class can contain public properties such as title, horizontal angle in degrees, and spacing, and vertical angle in degrees.

[0399] Overlay Class: The overlay class can be an abstract class representing some overlays that can be attached to a specific map view class. The overlay class cannot be directly instantiated. Instead, instances of specific overlay types are usually directly created. The overlay class can support a copy protocol that can return a copy of the overlay type, but with a nil map. The overlay class can be inherited by the circle class, ground overlay class, marker class, polygon class, and polyline class. The overlay class can contain the following properties: a title property that provides a title, a short description of the overlay; a map property that provides the map on which the overlay is located; a clickable property that provides whether the overlay should cause click notifications; and a z-index property that provides a layering system where overlays with higher z-index values will be drawn above lower z-index tile layers and overlays.

[0400] Panorama Class: The panorama class can represent the metadata of a specific panorama on the earth. The panorama class can contain the following properties: a coordinates property that provides the exact location of the panorama; a panorama ID that provides the panorama ID; and a links property that provides an array of panorama link classes that describe neighboring panoramas.

[0401] Panoramic Camera Class: The panoramic camera class can be used to control the viewing direction of the panoramic view class. The panoramic camera class can include functions, including: an initialization function with orientation, zoom, and field of view, a camera function with orientation and zoom as a convenience constructor that specifies the look-at and spacing as part of the orientation plus zoom and default field of view, a camera function with look-at spacing and zoom as a convenience constructor that specifies the look-at and spacing and a zoom with default field of view, a camera function with orientation zoom and field of view as a convenience constructor of the panoramic camera class that specifies all camera properties with look-at and spacing as part of the orientation, and a camera function with look-at spacing zoom and field of view as a convenience constructor of the panoramic camera class that specifies all camera properties. The panoramic camera class can include the following properties: a FOV (field of view) property that provides the field of view in degrees enclosed by the larger dimension of the view at a zoom of 1; a property that provides the zoom characteristic to adjust the visible area of the screen; an orientation property that provides the camera orientation that combines the look-at and spacing.

[0402] Panoramic Camera Update Class: The panoramic camera update class can represent an update that can be applied to the panoramic view class that encapsulates some logic for modifying the current camera. The panoramic camera update class can include functions, including: a rotate by function that returns an update to increment the camera look-at; a set look-at function that returns an update to set the camera look-at to a specified value; an updated set spacing function that returns an update to set the camera spacing to a specified value; and an updated set zoom function that returns an update to set the camera zoom to a specified value.

[0403] Panoramic Layer Class: The panoramic layer class can provide a custom subclass of CALayer for the layer class on the panoramic view class. The panoramic layer class can inherit from the CALayer class. The panoramic layer class can include properties such as camera look-at, camera spacing, camera zoom, and camera FOV.

[0404] Panoramic Link Class: The panoramic link class can link from a panoramic class to an adjacent panoramic. The panoramic link class can include the following properties: a look-at property that provides the adjacent panoramic angle in degrees, usually clockwise from north; a panoramic ID property that provides the panoramic ID for the adjacent panoramic.

[0405] Panoramic Service Class: The panoramic service class can be used to request panoramic metadata even when the panoramic view is inactive. The panoramic service class can include public member functions, including a request panoramic near coordinates function that retrieves information about the panoramic near the specified coordinates; a request panoramic near coordinates and radius function that is similar to the request panoramic near coordinates function but allows a search radius around the specified coordinates, and a request panoramic by ID function that retrieves information about the panoramic by specifying the ID.

[0406] Panoramic View Class: The panoramic view class can be used to display street view images. The panoramic view class can include functions, including: a set all gestures enabled function that sets a preference for whether all gestures should be enabled or disabled; an animate camera function that animates the camera to a position over a duration; an update camera function that modifies the camera based on a camera update class over a specific duration; a move near coordinates function that requests a panorama near the coordinates; a move near coordinates by radius function that is similar to the move near coordinates function but allows specifying a search radius around the coordinates; an orientation point function that returns the screen point through which the current view orientation point passes; a point orientation function that returns the current camera orientation for a specified point through which the view passes the screen position; a convenient constructor for a panorama with a frame that searches for and displays a panorama near the coordinates; and a convenient constructor for a panorama with a frame and radius that is similar to the constructor for a panorama with a frame but allows specifying a search radius around the coordinates. The panoramic view class can include the following properties: a panorama property that provides the panoramic display, where the panorama property transform is set to a new panorama; a delegate property that provides a delegate for the panoramic view; an orientation gesture property that controls whether the orientation gesture is enabled or disabled; a pinch gesture property that controls whether the pinch gesture is enabled or disabled; a navigation gesture property that controls whether the navigation gesture is enabled or disabled; a navigation link hidden property that controls whether clickable navigation links are hidden or visible; a street name hidden property that controls whether the street name overlay is hidden or visible; a camera property that controls the panoramic camera; and a layer property that provides an accessor for a custom CALayer type for the layer.

[0407] Panoramic View Delegate Class: The panoramic view delegate class can be a delegate for events on the panoramic view class. The panoramic view delegate class can include functions, including: a will move to panorama ID function that is called when starting to move to another panorama; a did move to panorama function that is called each time the view.panorama property changes; a did move to panorama near coordinates function that is called when the panorama changes as a result of calling the move to panorama near coordinates function; a move near coordinates error function that is called when an error occurs in the move near coordinates function; a move to panorama ID error function that is called when an error occurs in the move to panorama ID function; a did move camera function that is repeatedly called during a change to the camera; a did click function that is called when the user clicks on the panoramic view but does not consume the click (e.g., the click is consumed by clicking on a navigation arrow); a did click marker function that is called after clicking on a marker; a did start rendering function that is called when the panoramic tile for the current view is just requested and starts loading; and a did finish rendering function that is called when the tile has been loaded and rendered on the screen or can never be loaded permanently.

[0408] Path Class: The path class can encapsulate an immutable array of two-dimensional coordinates and is thus an immutable path class. The path class can be inherited from a mutable path class. The path class can include functions, including: an initialization function that initializes a newly allocated path with the content of another path class; a counting function that obtains the size of the path; a coordinate-at-index function that returns the position at a specified index if valid; an encoded-path function that returns the encoded string of the path; an offset-by-latitude-and-longitude path function that obtains a new path by adding the specified latitude and longitude to each coordinate of the current path; a segment-for-length-and-type function that returns the fraction of the segments along the path corresponding to the length interpreted according to the type; a type-length function that returns the length of the path according to the type; a path function that serves as a convenience constructor for an empty path; and a path-from-encoded-path function that initializes a newly allocated path from an encoded path.

[0409] Polygon Class: The polygon class can define polygons that appear on a map. A polygon (such as a polyline) defines a series of connected coordinates in an ordered sequence; in addition, the polygon forms a closed loop and defines a filled area. The polygon class can inherit from the overlay class. The polygon class can include a polygon with a path static function that has a convenience constructor for a polygon class for a specific path. The polygon class can include the following properties: a path property that provides the path describing the polygon; a holes property that provides an array of path instances describing any holes in the polygon; a stroke-width property that provides the width of the polygon outline in screen points; a stroke-color property that provides the color of the polygon outline; a fill-color property that provides the fill color; a geodesic property that provides whether the polygon should be rendered with geodesic correction; a title property that provides the title, a short description of the overlay; a map property that provides the map on which the overlay lies; a clickable property that provides whether the overlay should result in click notifications; and a z-index property that provides whether the overlay with a higher z-index value will be drawn above the lower z-index tile layer and overlay in the layering system.

[0410] Polyline class: The polyline class can specify the available options for polylines existing on the Earth's surface, typically drawn as physical lines between points specified in the path property. The polyline class can inherit from the overlay class. The polyline class can include a polyline with a path function, which is a convenience constructor for the polyline class for a specific path. The polyline class can include the following properties: a path property that provides the path describing the polyline; a stroke width property that provides the width of the line in screen points; a stroke color property that provides the color of the line; a geodesic property that provides whether the polyline should be rendered with geodesic correction; a spans property that provides an array containing style span classes used to render the polyline; a title property that provides a title, a short description of the overlay; a map property that provides the map on which the overlay is located; a clickable property that provides whether the overlay should cause click notifications; and a z-index property for the layering system where the overlay with a higher z-index value will be drawn above the tile layer and overlay with a lower z-index value.

[0411] Projection class: The projection class can define the mapping between Earth coordinates and coordinates in the map view. The projection class can include functions, including: a coordinate point function that maps Earth coordinates to point coordinates in the map view; a point coordinate function that maps point coordinates in the map view to Earth coordinates; a point function that converts a distance to a point at the content size coordinates; an contains coordinate function that returns whether the specified coordinates are contained within the projection; and a visible region function that returns the region visible according to the projection.

[0412] Reverse Geocoding Response class: The Reverse Geocoding Response class can be a collection of results from a reverse geocoding request. The Reverse Geocoding Response class can include functions, including: a first result function that returns the first result or nil if no result is available, and a results function that returns an array of all results including the first result.

[0413] Service class: The Service class can include static public member functions, including a shared service function that provides a shared instance of the service class for the map API and creates it if needed; a provide API key function that provides a key to the map API; an open source license information function that returns open source software license information; and a version function that returns the version released by the map API.

[0414] Stroke Style class: The Stroke Style class can describe the drawing style of one-dimensional entities such as polylines. The Stroke Style class can include a solid color function that creates a solid color stroke style and a color gradient function that creates a gradient stroke style interpolating from one color to another.

[0415] Style Span Class: The style span class can describe the styles for some regions of a polyline. The style span class can include factory functions, including: a color span function that returns a solid color span of a certain length, a color segment span function that returns a solid color span with a given number of segments, a style span function that returns a span of a specified style with a certain length for one segment, and a style span segment function that returns a span with a specified style and lengths for multiple segments. The style span class can include the following properties: a style property that provides the style of the span; a segment property that provides the lengths of the spans in multiple segments.

[0416] Synchronized Patch Layer Class: The synchronized patch layer class can be an abstract subclass of the patch layer class that provides a synchronization interface to generate image patch data. The synchronized patch layer class can inherit from the patch layer class. The synchronized patch layer class can include functions, including: a request patch for xy scaling receiver function that uses the requested patch for the patch overlay layer's image, a patch for xy scaling function similar to the request xy scaling receiver function but providing a synchronization interface to return the patch, and a clear patch cache function that clears the cache so that all patches are requested again. The synchronized patch layer class can include the following properties: a map property that provides the map on which the overlay layer is located; a z-index property that provides a layering system where an overlay layer with a higher z-index value will be drawn above patch layers and overlay layers with lower z-index values; a patch size property that specifies the number of pixels for which the returned patch image should be preferentially displayed; an opacity property that specifies the opacity of the patch layer; a fade-in property that specifies whether the patch should fade in.

[0417] Patch Layer Class: The patch layer class can be an abstract class that allows custom image patches to be overlaid on a specified map view class. The patch layer class can be inherited by the synchronized patch layer class and the URL patch layer class. The patch layer class can include functions, including: a request patch for xy scaling receiver function that generates an image patch for the patch overlay layer, and a clear patch cache function that clears the cache so that all patches are requested again. The patch layer class can include the following properties: a map property that provides the map on which the overlay layer is located; a z-index property that provides a layering system where an overlay layer with a higher z-index value will be drawn above patch layers and overlay layers with lower z-index values; a patch size property that specifies the number of pixels for which the returned patch image should be preferentially displayed; an opacity property that specifies the opacity of the patch layer; a fade-in property that specifies whether the patch should fade in.

[0418] Patch Receiver Class: When a patch request is made, the patch receiver class can be provided to the patch layer class, allowing a callback function to be called later or immediately. The patch receiver class can include a receive patch with xy scaling image public member function similar to the patch layer class.

[0419] URL Tile Layer Class: The URL tile layer class can fetch tiles based on the URLs returned from the constructor. The URL tile layer class can inherit from the tile layer class. The URL tile layer class can include functions, including: a request tile function for generating image tiles for the tile overlay layer, a tile for xy scaling receiver function, a clear tile cache function for clearing the cache so that all tiles are requested again, and a convenience constructor for the tile layer with a URL. The URL tile layer class can include the following properties: a user agent property that provides the user agent for the application, a map property that provides the map on which the overlay is located, a z-index property that provides a hierarchical system where the overlay with a higher z-index value will be drawn above the tile layer and overlay with a lower z-index value, a tile size property that specifies the number of pixels for which the returned tile image will be preferentially displayed, an opacity property that specifies the opacity of the tile layer, and a fade-in property that specifies whether the tile should fade in.

[0420] Visible Region Class: The visible region class can contain the four points that define a polygon visible in the map camera. The polygon can be a trapezoid instead of a rectangle because the camera can be tilted. If the camera is directly centered, the shape is a rectangle, but if the camera is tilted, the shape will appear as a trapezoid with the smallest side closest to the viewing point. The visible region class can include common properties such as a near left property that can be the lower left corner of the camera, a near right property that can be the lower right corner of the camera, a far left property that can be the leftmost corner of the camera, and a far right property that can be the rightmost corner of the camera.

[0421] The techniques discussed herein relate to servers, databases, software applications, and other computer-based systems, as well as the actions taken and the information sent to and from such systems. Those of ordinary skill in the art will recognize that the inherent flexibility of computer-based systems allows for an extremely wide variety of possible configurations, combinations, and divisions of tasks and functions among components. For example, the server processes discussed herein can be implemented using a single server or multiple servers working in combination. The database and applications can be implemented on a single system or distributed across multiple systems. The distributed components can operate sequentially or in parallel.

[0422] Although the subject matter has been described in detail with respect to specific example embodiments of the subject matter, it will be understood that those skilled in the art can readily generate alterations, variations, and equivalents to such embodiments upon obtaining an understanding of the foregoing. Accordingly, the scope of the present disclosure is by way of example rather than limitation, and the present disclosure does not exclude including such modifications, variations, and / or additions to the subject matter that would be apparent to those of ordinary skill in the art.< / nsobject> < / gmsnavigationuisettingsdelegate> < / nsobject> < / gmsnavigatordelegate> < / key>

Claims

1. A non - volatile computer - readable medium storing instructions that implement an application programming interface, the application programming interface being for obtaining navigation information for a software application to be executed on an iOS computing device implementing an iOS operating platform, the iOS computing device having one or more processors and a display device, the application programming interface including: A first set of instructions associated with a map view class, wherein the map view class specifies a plurality of functions for displaying a map associated with a navigation service of the software application, wherein the navigation service is configured to provide navigation information associated with the software application, and wherein the plurality of functions for displaying the map includes controlling one or more instances of the map view class; and A second set of instructions associated with a navigator class, wherein the navigator class is associated with the application programming interface and specifies a plurality of functions for controlling the software application's implementation of the navigation service, and wherein the plurality of functions for controlling the implementation of the navigation service includes controlling one or more instances of the map view class.

2. The non - transitory computer - readable medium according to claim 1, further comprising: At startup of the software application, providing, by the one or more processors, an application programming interface key to a service class, wherein the service class is associated with a map application programming interface.

3. The non-transitory computer-readable medium according to claim 2, wherein, The service class includes shared service functions to share an instance of the service class with the map application programming interface.

4. The non-transitory computer-readable medium according to claim 1, wherein, One or more portions of the map view class are portions of the map application programming interface.

5. The non-transitory computer-readable medium according to claim 1, wherein, Instantiating, by one or more processors, a map view class for displaying a map includes: Using, by the one or more processors, a convenience constructor to instantiate the map view class.

6. The non-transitory computer-readable medium according to claim 1, wherein, Controlling the map includes controlling the display of route and navigation user interface elements in conjunction with the map.

7. The non-transitory computer-readable medium according to claim 1, wherein, The application programming interface includes a third set of instructions associated with a map view delegate class, wherein the map view delegate class is designated as a delegate for events of the map view class.

8. The non-transitory computer-readable medium according to claim 7, wherein, The map view delegate class includes functions for setting minimum and maximum zoom to set the minimum and maximum zoom of the map.

9. The non-transitory computer-readable medium according to claim 1, wherein, The application programming interface includes a fourth set of instructions associated with a navigator delegate protocol, wherein the navigator delegate protocol is designated as a delegate for the navigator class, and wherein the navigator delegate protocol is configured to implement one or more calls to update the navigation information associated with the navigation service.

10. The non-transitory computer-readable medium according to claim 1, wherein The application programming interface includes a fifth set of instructions associated with a camera update class, the camera update class being for modifying a camera for viewing the map.

11. The non-transitory computer-readable medium according to claim 10, wherein, The plurality of functions for displaying the map includes a move camera function for changing the position of the camera according to the camera update class.

12. The non-transitory computer-readable medium according to claim 11, wherein, The application programming interface includes a sixth set of instructions associated with a user interface (UI) settings class, and wherein the UI settings class specifies one or more parameters for controlling the user interface associated with the navigation service.

13. A method of integrating a navigation service as part of a software application using an application programming interface on an iOS computing device having one or more processors, the computing device implementing an iOS operating system, the method comprising: Instantiating, by one or more processors, a map view class, wherein the map view class specifies a plurality of functions for displaying a map associated with a navigation service of the software application, wherein the navigation service is configured to provide navigation information associated with the software application, and wherein the plurality of functions for displaying the map includes controlling one or more instances of the map view class; Creating, by the one or more processors, one or more instances of a navigator class associated with the application programming interface, wherein the navigator class specifies a plurality of functions for controlling the software application's implementation of the navigation service, and wherein the plurality of functions for controlling the implementation of the navigation service includes controlling one or more instances of the map view class; and Controlling the map by the one or more processors using the one or more instances of the navigator class.

14. The method of claim 13, further comprising: Providing, by the one or more processors at startup of the software application, an application programming interface key to a service class, wherein the service class is associated with a map application programming interface.

15. The method according to claim 14, wherein The service class includes shared service functions to share an instance of the service class with the map application programming interface.

16. The method according to claim 14, wherein, The map view class is provided as part of the map application programming interface.

17. The method according to claim 13, wherein, Instantiating, by one or more processors, a map view class for displaying a map includes: Instantiating, by the one or more processors, the map view class using a convenience constructor.

18. The method according to claim 13, wherein, Controlling the map includes controlling the display of route and navigation user interface elements in conjunction with the map.

19. A computing device implementing an iOS operating system, comprising: A display device; One or more processors; And One or more memory devices, wherein the one or more memory devices store computer-readable instructions that implement an application programming interface invoked by a software application to obtain navigation information to provide a navigation service as part of the software application, the instructions including: A first set of instructions associated with a map view class, wherein the map view class specifies a plurality of functions for displaying a map associated with a navigation service of the software application, wherein the navigation service is configured to provide navigation information associated with the software application, and wherein the plurality of functions for displaying the map includes controlling one or more instances of the map view class; and A second set of instructions associated with a navigator class, wherein the navigator class is associated with the application programming interface and specifies a plurality of functions for controlling the software application's implementation of the navigation service, and wherein the plurality of functions for controlling the implementation of the navigation service includes controlling one or more instances of the map view class.

20. The computing device according to claim 19, wherein, Controlling the map includes controlling the display of route and navigation user interface elements in conjunction with the map.

Images