ios Document current as of 03/21/ :20 AM. Guides Installation Install SDL SDK

Transcription

1 Guides ios Document current as of 03/21/ :20 AM. Installation In order to build your app on a SmartDeviceLink (SDL) Core, the SDL software development kit (SDK) must be installed in your app. The following steps will guide you through adding the SDL SDK to your workspace and configuring the environment. Install SDL SDK We have provided three different ways to install the SDL SDK in your project: CocoaPods, Carthage, or manually. COCOAPODS INSTALL ATION 1. Xcode should be closed for the following steps. 2. Open the terminal app on your Mac.

2 3. Make sure you have the latest version of CocoaPods installed. For more information on installing CocoaPods on your system please consult: sudo gem install cocoapods 1. Navigate to the root directory of your app. Make sure your current folder contains the.xcodeproj file 2. Create a new Podfile. pod init 1. In the Podfile, add the following text. This tells CocoaPods to install SDL SDK for ios. target <#Your Project Name#> do pod SmartDeviceLink-iOS, ~> <#SDL Version#> end

3 N O T E SDL Versions are available on Github. We suggest always using the latest release. 1. Install SDL SDK for ios: pod install 1. There will be a newly created.xcworkspace file in the directory in addition to the.xcodeproj file. Always use the.xcworkspace file from now on. 2. Open the.xcworkspace file. To open from the terminal, type: open <#Your Project Name#>.xcworkspace CARTHAGE INSTALL ATION SDL ios supports Carthage! Install using Carthage by following this guide. Carthage supports ios 8+.

4 MANUAL INSTALL ATION Tagged to our releases is a dynamic framework file that can be drag-anddropped into the application. Dynamic frameworks are supported on ios 8+. Please Note: You cannot submit your app to the app store with the framework as is. You MUST strip the simulator part of the framework first. Use a script such as Carthage's to accomplish this. SDK Configuration 1. Get a SDL Core If you do not have a SDL enabled head unit for testing, you should build the sdl_core project. The sdl_core project is an emulator that lets you simulate sending and receiving remote procedure calls between a smartphone app and a SDL Core. 2. Enable Background Capabilities Your application must be able to maintain a connection to the SDL Core even when it is in the background. This capability must be explicitly enabled for your application (available for ios 5+). To enable the feature, select your application's build target, go to Capabilities, Background Modes, and select External accessory communication mode. 3. Add SDL Protocol Strings Your application must support a set of SDL protocol strings in order to be connected to SDL enabled head units. Go to your application's.plist file and add the following code under the top level dictionary.

5 N O T E This is only required for USB and Bluetooth enabled head units. It is not necessary during development using SDL Core. <key>uisupportedexternalaccessoryprotocols</key> <array> <string>com.smartdevicelink.prot29</string> <string>com.smartdevicelink.prot28</string> <string>com.smartdevicelink.prot27</string> <string>com.smartdevicelink.prot26</string> <string>com.smartdevicelink.prot25</string> <string>com.smartdevicelink.prot24</string> <string>com.smartdevicelink.prot23</string> <string>com.smartdevicelink.prot22</string> <string>com.smartdevicelink.prot21</string> <string>com.smartdevicelink.prot20</string> <string>com.smartdevicelink.prot19</string> <string>com.smartdevicelink.prot18</string> <string>com.smartdevicelink.prot17</string> <string>com.smartdevicelink.prot16</string> <string>com.smartdevicelink.prot15</string> <string>com.smartdevicelink.prot14</string> <string>com.smartdevicelink.prot13</string> <string>com.smartdevicelink.prot12</string> <string>com.smartdevicelink.prot11</string> <string>com.smartdevicelink.prot10</string> <string>com.smartdevicelink.prot9</string> <string>com.smartdevicelink.prot8</string> <string>com.smartdevicelink.prot7</string> <string>com.smartdevicelink.prot6</string> <string>com.smartdevicelink.prot5</string> <string>com.smartdevicelink.prot4</string> <string>com.smartdevicelink.prot3</string> <string>com.smartdevicelink.prot2</string> <string>com.smartdevicelink.prot1</string> <string>com.smartdevicelink.prot0</string> <string>com.ford.sync.prot0</string> </array>

6 4. Access the Documentation You can find the latest reference documentation on CocoaDocs. D O W N L O A D T H E D O C U M E N TAT I O N Install this documentation to Dash or to Xcode by using Docs for Xcode. On the SDL Docs page, click the upload icon located in the upper right hand corner of the screen and add the documentation to Dash or Xcode. 5. Get an App Id An app id is required for production level apps. The app id gives your app special permissions to access vehicle data. If your app does not need to access vehicle data, a dummy app id (i.e. create a fake id like "1234") is sufficient during the development stage. However, you must get an app id before releasing the app to the public. To obtain an app id, sign up at smartdevicelink.com. Integration Basics How SDL Works SmartDeviceLink works by sending remote procedure calls (RPCs) back and forth between a smartphone application and the SDL Core. These RPCs allow you to build the user interface, detect button presses, play audio, and get

7 vehicle data, among other things. You will use the SDL library to build your app on the SDL Core. Set Up a Proxy Manager Class You will need a class that manages the RPCs sent back and forth between your app and SDL Core. Since there should be only one active connection to the SDL Core, you may wish to implement this proxy class using the singleton pattern. OBJECTIVE-C ProxyManager.h #import <Foundation/Foundation.h> SDLMananger : NSObject + NS_ASSUME_NONNULL_END ProxyManager.m

8 #import "ProxyManager.h" ProxyManager + (instancetype)sharedmanager { static ProxyManager* sharedmanager = nil; static dispatch_once_t oncetoken; dispatch_once(&oncetoken, ^{ sharedmanager = [[ProxyManager alloc] init]; ); return sharedmanager; - (instancetype)init { self = [super init]; if (!self) { return NS_ASSUME_NONNULL_END

9 SWIFT class ProxyManager: NSObject { // Singleton static let sharedmanager = ProxyManager() private override init() { super.init() Your app should always start passively watching for a connection with a SDL Core as soon as the app launches. The easy way to do this is by instantiating the ProxyManager class in the didfinishlaunchingwithoptions() method in your AppDelegate class. The connect method will be implemented later. To see a full example, navigate to the bottom of this page. AppDelegate - (BOOL)application:(UIApplication *)application didfinishlaunchingwithoptions:(nsdictionary *)launchoptions { // Initialize and start the proxy [[ProxyManager sharedmanager]

10 SWIFT class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didfinishlaunchingwithoptions launchoptions: [ UIApplicationLaunchOptionsKey: Any]?) -> Bool { // Initialize and start the proxy ProxyManager.shared.connect() return true Import the SDL Library At the top of the ProxyManager class, import the SDL for ios library. OBJECTIVE-C #import "SmartDeviceLink.h"

11 SWIFT import SmartDeviceLink_iOS Implement the SDL Manager The SDLManager is a helper class that will handle setting up the initial connection with the SDL Core. It will also help you upload images and send RPCs.

12 OBJECTIVE-C #import "ProxyManager.h" #import "SmartDeviceLink.h" ProxyManager (nonatomic, strong) ProxyManager + (instancetype)sharedmanager { static ProxyManager *sharedmanager = nil; static dispatch_once_t oncetoken; dispatch_once(&oncetoken, ^{ sharedmanager = [[ProxyManager alloc] init]; ); return sharedmanager; - (instancetype)init { self = [super init]; if (!self) { return NS_ASSUME_NONNULL_END

13 SWIFT class ProxyManager: NSObject { // Manager fileprivate let sdlmanager: SDLManager // Singleton static let sharedmanager = ProxyManager() private override init() { super.init() 1. Create a Lifecycle Configuration In order to instantiate the SDLManager class, you must first configure an SDLLifecycleConfiguration instance with the application name and application id. During the development stage, a dummy app id is usually sufficient. For more information about obtaining an application id, please consult the SDK Configuration section of this guide. You must also decide which network configuration to use to connect the app to the SDL Core. Optional, but recommended, configuration properties include short app name, app icon, and app type. NETWORK CONNECTION TYPE There are two different ways to connect your app to a SDL Core: with a TCP (Wifi) network connection or with an iap (USB) network connection. Use TCP for debugging and use iap for production level apps.

14 IAP OBJECTIVE-C SDLLifecycleConfiguration* lifecycleconfiguration = [ SDLLifecycleConfiguration Name#>" appid:@"<#app Id#>"]; SWIFT let lifecycleconfiguration = SDLLifecycleConfiguration. defaultconfiguration(withappname:"<#app Name#>", appid: "<#App Id#>")

15 TCP OBJECTIVE-C SDLLifecycleConfiguration* lifecycleconfiguration = [ SDLLifecycleConfiguration Name#>" appid:@"<#app Id#>" ipaddress:@"<#ip Address#>" port:<#port#>]; SWIFT let lifecycleconfiguration = SDLLifecycleConfiguration. debugconfiguration(withappname: "<#App Name#>", appid: "<#App Id#>", ipaddress: "<#IP Address#>", port: <#Port#>)) N O T E If you are using an emulator, the IP address is your computer or virtual machine s IP address, and the port number is usually If these values are not correct, or emulator is not running, your app with not run, as TCP connections occur on the main thread.

16 N O T E If you are using a head unit or TDK, and are using the relay app for debugging, the IP address and port number should be set to the same IP address and port number as the app. This information appears in the relay app once the server is turned on in the relay app. Also be sure that the device is on the same network as your app. 2. Short app name (optional) This is a shortened version of your app name that is substituted when the full app name will not be visible due to character count constraints OBJECTIVE-C lifecycleconfiguration.shortappname App Name#>";

17 SWIFT lifecycleconfiguration.shortappname = "<#Shortened App Name#>" 3. App Icon This is a custom icon for your application. Please refer to Uploading Files and Graphics for icon sizes. OBJECTIVE-C UIImage* appimage = [UIImage imagenamed:@"<#appicon Name#>" ]; if (appimage) { SDLArtwork* appicon = [SDLArtwork persistentartworkwithimage:appimage name:@"<#name to Upload As#>" asimageformat:sdlartworkimageformatjpg /* or SDLArtworkImageFormatPNG */]; lifecycleconfiguration.appicon = appicon;

18 SWIFT if let appimage = UIImage(named: "<#AppIcon Name#>") else { let appicon = SDLArtwork.persistentArtwork(with: appimage, name: "<#Name to Upload As#>", as:.jpg /* or.png */) lifecycleconfiguration.appicon = appicon N O T E We recommend using SDLArtwork when building an image. Persistent files are used when the image ought to remain on the remote system between ignition cycles. This is commonly used for menu artwork and app icons 4. App Type (optional) The app type is used by car manufacturers to decide how to categorize your app. Each car manufacturer has different categorization system. For example, if you set your app type as media, your app will also show up in the audio tab as well as the apps tab of Ford s SYNC3 head unit. The app type options are:

19 default, communication, media (i.e. music/podcasts/radio), messaging, navigation, information, and social. OBJECTIVE-C lifecycleconfiguration.apptype = SDLAppHMIType.MEDIA; SWIFT lifecycleconfiguration.apptype =.media() 2. Set the Configuration The SDLConfiguration class is used to set the lifecycle and lock screen configurations for the app. Use the lifecycle configuration settings above to instantiate a SDLConfiguration instance.

20 OBJECTIVE-C SDLConfiguration* configuration = [SDLConfiguration configurationwithlifecycle:lifecycleconfiguration lockscreen :[SDLLockScreenConfiguration enabledconfiguration]]; SWIFT let configuration = SDLConfiguration(lifecycle: lifecycleconfiguration, lockscreen:.enabled()) 3. Lock screen A lock screen is used to prevent the user from interacting with the app on the smartphone while they are driving. When the vehicle starts moving, the lock screen is activated. Similarly, when the vehicle stops moving, the lock screen is removed. You must implement the lock screen in your app for safety reasons. Any application without a lock screen will not get approval for release to the public. The SDL SDK takes care of the lock screen implementation for you, and even includes the resources for a default lock screen, as well as using the app icon you set, and a connected vehicle's logo. If you do not want to use the default lock screen, you can implement your own custom lock screen.

21 For more information, please refer to the Adding the Lock Screen section, for this guide we will be using SDLLockScreenConfiguration 's enabledconfiguration. OBJECTIVE-C [SDLLockScreenConfiguration enabledconfiguration] SWIFT SDLLockScreenConfiguration.enabled() 4. Create a SDLManager Now you can use the SDLConfiguration instance to instantiate the SDLManager.

22 OBJECTIVE-C self.sdlmanager = [[SDLManager alloc] initwithconfiguration: configuration delegate:self]; SWIFT** sdlmanager = SDLManager(configuration: configuration, delegate: self) 5. Start the SDLManager The manager should be started as soon as possible in your application's lifecycle. We suggest doing this in the didfinishlaunchingwithoptions() method in your AppDelegate class. Once the manager has been initialized, it will immediately start watching for a connection with the remote system. The manager will passively search for a connection with a SDL Core during the

23 entire lifespan of the app. If the manager detects a connection with a SDL Core, the startwithreadyhandler will be called. OBJECTIVE-C [self.sdlmanager startwithreadyhandler:^(bool success, NSError * _Nullable error) { if (success) { // Your app has successfully connected with the SDL Core. ]; SWIFT sdlmanager.start(readyhandler { (success, error) in if success { // Your app has successfully connected with the SDL Core. ) N O T E In production, your app will be watching for connections using iap, which will not use any additional battery power than normal.

24 If the connection is successful, you can start sending RPCs to the SDL Core. However, some RPCs can only be sent when the HMI is in the FULL or LIMITED state. If the SDL Core's HMI is not ready to accept these RPCs, your requests will be ignored. If you want to make sure that the SDL Core will not ignore your RPCs, use the SDLManagerDelegate methods in the next section. 6. Example Implementation of a Proxy Class The following code snippet has an example of setting up both a TCP and iap connection. OBJECTIVE-C ProxyManager.h #import <Foundation/Foundation.h> ProxyManager : NSObject + (instancetype)sharedmanager; - NS_ASSUME_NONNULL_END ProxyManager.m

25 #import "SmartDeviceLink.h" NS_ASSUME_NONNULL_BEGIN static NSString* const AppName Name#>"; static NSString* const AppId ProxyManager () (nonatomic, strong) ProxyManager + (instancetype)sharedmanager { static ProxyManager *sharedmanager = nil; static dispatch_once_t oncetoken; dispatch_once(&oncetoken, ^{ sharedmanager = [[ProxyManager alloc] init]; ); return sharedmanager; - (instancetype)init { self = [super init]; if (!self) { return nil; // Used for USB Connection SDLLifecycleConfiguration* lifecycleconfiguration = [ SDLLifecycleConfiguration defaultconfigurationwithappname: AppName appid:appid]; // Used for TCP/IP Connection // SDLLifecycleConfiguration* lifecycleconfiguration = [SDLLifecycleConfiguration debugconfigurationwithappname:appname appid:appid ipaddress:@"<#ip Address#>" port:<#port#>]; UIImage* appimage = [UIImage imagenamed:@"<#appicon Name#>"]; if (appimage) { SDLArtwork* appicon = [SDLArtwork persistentartworkwithimage:appimage name:@"<#name to Upload As#>" asimageformat:sdlartworkimageformatjpg /* or SDLArtworkImageFormatPNG */]; lifecycleconfiguration.appicon = appicon;

26 lifecycleconfiguration.shortappname App Name#>"; lifecycleconfiguration.apptype = [SDLAppHMIType MEDIA]; SDLConfiguration* configuration = [SDLConfiguration configurationwithlifecycle:lifecycleconfiguration lockscreen :[SDLLockScreenConfiguration enabledconfiguration]]; self.sdlmanager = [[SDLManager alloc] initwithconfiguration:configuration delegate:self]; return self; - (void)connect { [self.sdlmanager startwithreadyhandler:^(bool success, NSError * _Nullable error) { if (success) { // Your app has successfully connected with the SDL Core ]; #pragma mark SDLManagerDelegate - (void)managerdiddisconnect { NSLog(@"Manager disconnected!"); - (void)hmilevel:(sdlhmilevel *)oldlevel didchangetolevel:( SDLHMILevel *)newlevel { NSLog(@"Went from HMI level %@ to HMI Level %@", oldlevel, NS_ASSUME_NONNULL_END

27 SWIFT

28 import SmartDeviceLink_iOS class ProxyManager: NSObject { private let appname = "<#App Name#>" private let appid = "<#App Id#>" // Manager fileprivate let sdlmanager: SDLManager // Singleton static let sharedmanager = ProxyManager() private override init( ) { // Used for USB Connection let lifecycleconfiguration = SDLLifecycleConfiguration.defaultConfiguration(withAppName: appname, appid: appid) // Used for TCP/IP Connection // let lifecycleconfiguration = SDLLifecycleConfiguration.debugConfiguration(withAppName: appname, appid: appid, ipaddress: "<#IP Address#>", port: <#Port#>) // App icon image if let appimage = UIImage(named: "<#AppIcon Name#>") { let appicon = SDLArtwork.persistentArtwork(with: appimage, name: "<#Name to Upload As#>", as:.jpg /* or.png */) lifecycleconfiguration.appicon = appicon lifecycleconfiguration.shortappname = "<#Shortened App Name#>" lifecycleconfiguration.apptype =.media() let configuration = SDLConfiguration(lifecycle: lifecycleconfiguration, lockscreen:.enabled()) sdlmanager = SDLManager(configuration: configuration, delegate: nil) super.init() sdlmanager.delegate = self

29 func connect() { // Start watching for a connection with a SDL Core sdlmanager.start { (success, error) in if success { // Your app has successfully connected with the SDL Core //MARK: SDLManagerDelegate extension ProxyManager: SDLManagerDelegate { func managerdiddisconnect() { print("manager disconnected!") func hmilevel(_ oldlevel: SDLHMILevel, didchangeto newlevel: SDLHMILevel) { print("went from HMI level \(oldlevel) to HMI level \( newlevel)") Implement the SDL Manager Delegate The ProxyManager class should conform to the SDLManagerDelegate protocol. This means that the Proxy class must implement the following required functions: 1. managerdiddisconnect() This function is called only once, when the proxy disconnects from the SDL Core. Do any cleanup you need to do in this function. 2. hmilevel(oldlevel: SDLHMILevel!, didchangetolevel newlevel: SDLHMILevel!) This function is called when the HMI level changes for the app. The HMI level can be FULL, LIMITED, BACKGROUND, or NONE. It is important to note that most RPCs sent while the HMI is in BACKGROUND or NONE mode will be ignored by the SDL Core. The Different HMI Levels: Please refer to Knowing the In-Car UI Status for information about HMI levels.

30 Connecting to a SDL Core Connect with an Emulator To connect to a SDL Core emulator, make sure to implement a TCP connection. The emulator and app should be on the same network (i.e. remember to set the correct IP address and port number in the SDLLifecycleConfiguration ). The IP will most likely be the IP address of the operating system running the SDL Core emulator. The port will most likely be N O T E Known issues: When app is in the background mode, the app will be unable to communicate with SDL Core. This will work on IAP connections. Audio will not play on the SDL Core. Only IAP connections are currently able to play audio.

31 Connect with a Vehicle Head Unit or a Technical Development Kit (TDK) PRODUCTION To connect your ios device directly to a vehicle head unit or TDK, make sure to implement an iap ( default ) connection in the SDLLifecycleConfiguration. Then connect the ios device to the head unit or TDK using a USB cord. DEBUGGING If you are testing with a vehicle head unit or TDK and want to see debug logs in Xcode while the app is running, you must use another app called the relay app to help you connect to the device. When using the relay app, make sure to implement a TCP connection. Please see the guide for the relay app to learn how to setup the connection between the device, the relay app and your app. N O T E The same issues apply when connecting the Relay app with a TDK or head unit as do when connecting to SDL Core. Please see the issues above, under the Connect with an Emulator heading.

32 Designing a User Interface Designing for Different User Interfaces Each car manufacturer has different user interface style guidelines, so the number of lines of text, buttons, and images supported will vary between different types of head units. When the app first connects to the SDL Core, a RegisterAppInterface RPC will be sent by the SDL Core containing the displaycapability properties. You can use this information to determine how to layout the user interface. Register App Interface RPC The RegisterAppInterface response contains information about the display type, the type of images supported, the number of text fields supported, the HMI display language, and a lot of other useful properties. For a full list of displaycapability properties returned by the RegisterAppInterface response, please consult the SDLRegisterAppInterfaceResponse.h file. The table below has a list of all possible properties that can be returned by the RegisterAppInterface response. Each property is optional, so you may not get information for all the parameters in the table.

33 PA R A M E T E R S D E S C R I P T I O N N O T E S syncmsgversion Specifies the version number of the SDL V4 interface. This is used by both the application and SDL to declare what interface version each is using. Check SDLSyncMsgVersio n.h for more information language The currently active voice-recognition and text-to-speech language on Sync. Check SDLLanguage.h for more information hmidisplaylanguag e The currently active display language on Sync. Check SDLLanguage.h for more information displaycapabilities Information about the Sync display. This includes information about available templates, whether or not graphics are supported, and a list of all text fields and the max number of characters allowed in each text field. Check SDLRPCMessage.h for more information buttoncapabilities A list of available buttons and whether the buttons support long, short and updown presses. Check SDLButtonCapabiliti es.h for more information

34 PA R A M E T E R S D E S C R I P T I O N N O T E S softbuttoncapabiliti es A list of available soft buttons and whether the button support images. Also information about whether the button supports long, short and up-down presses. Check SDLSoftButtonCapa bilities.h for more information presetbankcapabili ties If returned, the platform supports custom on-screen presets. Check SDLPresetBankCap abilities.h for more information hmizonecapabilitie s Specifies HMI Zones in the vehicle. There may be a HMI available for back seat passengers as well as front seat passengers. Check SDLHMIZoneCapabi lities.h for more information speechcapabilities Contains information about TTS capabilities on the SDL platform. Platforms may support text, SAPI phonemes, LH PLUS phonemes, prerecorded speech, and silence. Check SDLSpeechCapabili ties.h for more information prerecordedspeech A list of pre-recorded sounds you can use in your app. Sounds may include a help, initial, listen, positive, or a negative jingle. Check SDLPrerecordedSpe ech.h for more information

35 PA R A M E T E R S D E S C R I P T I O N N O T E S vrcapabilities The voicerecognition capabilities of the connected SDL platform. The platform may be able to recognize spoken text in the current language. Check SDLVRCapabilities.h for more information audiopassthrucapa bilities Describes the sampling rate, bits per sample, and audio types available. Check SDLAudioPassThru Capabilities.h for more information vehicletype The make, model, year, and the trim of the vehicle. Check SDLVehicleType.h for more information supporteddiagmod es Specifies the whitelist of supported diagnostic modes (0x00-0xFF) capable for DiagnosticMessage requests. If a mode outside this list is requested, it will be rejected. Check SDLDiagnosticMess age.h for more information hmicapabilities Returns whether or not the app can support built-in navigation and phone calls. Check SDLHMICapabilities. h for more information sdlversion The SmartDeviceLink version String

36 PA R A M E T E R S D E S C R I P T I O N N O T E S systemsoftwarever sion The software version of the system that implements the SmartDeviceLink core String Templates Each car manufacturer supports a set of templates for the user interface. These templates determine the position and size of the text, images, and buttons on the screen. A list of supported templates is sent with RegisterAppInterface response. To change a template at any time, send a SDLSetDisplayLayout RPC to the SDL Core. If you want to ensure that the new template is used, wait for a response from the SDL Core before sending any more user interface RPCs. OBJECTIVE-C SDLSetDisplayLayout* display = [[SDLSetDisplayLayout alloc] initwithpredefinedlayout:sdlpredefinedlayout. GRAPHIC_WITH_TEXT]; [self.sdlmanager sendrequest:display withresponsehandler:^( SDLRPCRequest *request, SDLRPCResponse *response, NSError * error) { if ([response.resultcode isequaltoenum:sdlresult.success ]) { // The template has been set successfully ];

37 SWIFT let display = SDLSetDisplayLayout(predefinedLayout:. graphic_with_text())! sdlmanager.send(display) { (request, response, error) in if response?.resultcode ==.success() { // The template has been set successfully Available Templates There are fifteen standard templates to choose from, however some head units may only support a subset of these templates. Please check the RegisterAppInterface response for the supported templates. The following examples show how templates will appear on the generic head unit. 1. MEDIA - WITH AND WITHOUT PROGRESS BAR

38 F O R D H M I 2. NON-MEDIA - WITH AND WITHOUT SOFT BUTTONS

39 F O R D H M I 3. GRAPHIC_WITH_TEXT

40 F O R D H M I 4. TEXT_WITH_GRAPHIC F O R D H M I 5. TILES_ONLY

41 F O R D H M I 6. GRAPHIC_WITH_TILES F O R D H M I 7. TILES_WITH_GRAPHIC

42 F O R D H M I 8. GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS F O R D H M I 9. TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC

43 F O R D H M I 10. GRAPHIC_WITH_TEXTBUTTONS F O R D H M I 11. DOUBLE_GRAPHIC_SOFTBUTTONS

44 F O R D H M I 12. TEXTBUTTONS_WITH_GRAPHIC F O R D H M I 13. TEXTBUTTONS_ONLY

45 F O R D H M I 14. L ARGE_GRAPHIC_WITH_SOFTBUTTONS F O R D H M I 15. L ARGE_GRAPHIC_ONLY

46 F O R D H M I Text, Images, and Buttons All text, images, and buttons on the HMI screen must be sent as part of a SDLShow RPC. Subscribe buttons are sent as part of a SDLSubscribeButton RPC. Text A maximum of four lines of text can be set in SDLShow RPC, however, some templates may only support 1, 2, or 3 lines of text. If all four lines of text are

47 set in the SDLShow RPC, but the template only supports three lines of text, then the fourth line will simply be ignored. OBJECTIVE-C SDLShow* show = [[SDLShow alloc] initwithmainfield1:@"<line 1 of Text#>" mainfield2:@"<line 2 of Text#>" 3 of Text#>" mainfield4:@"<line 4 of Text#>" alignment:sdltextalignment.centered()]; self.sdlmanager sendrequest:show withresponsehandler:^( SDLRPCRequest *request, SDLRPCResponse *response, NSError * error) { if ([response.resultcode isequaltoenum:sdlresult.success ]) { // The text has been set successfully ]; SWIFT let show = SDLShow(mainField1: "<#Line 1 of Text#>", mainfield2: "<#Line 2 of Text#>", mainfield3: "<#Line 3 of Text#>", mainfield4: "<#Line 4 of Text#>", alignment:. centered()) sdlmanager.send(show) { (request, response, error) in guard let response = response else { return if response.resultcode.isequal(to: SDLResult.success()) { // The text has been set successfully

48 Images The position and size of images on the screen is determined by the currently set template. All images must first be uploaded to the remote system using the SDLManager s file manager before being used in a SDLShow RPC. Once the image has been successfully uploaded, the app will be notified in the upload method's completion handler. For information relating to how to upload images, go to the Uploading Files and Graphics section. N O T E Some head units you may be connected to may not support images at all. Please consult the graphicssupported property in the display capabilities property of the RegisterAppInterface response. SHOW THE IMAGE ON A HEAD UNIT Once the image has been uploaded to the head unit, you can show the image on the user interface. To send the image, create a SDLImage, and send it using the SDLShow RPC. The value property should be set to the same value used

49 in the name property of the uploaded SDLArtwork. Since you are uploading your own image, the imagetype property should be set to dynamic. OBJECTIVE-C SDLImage* image = [[SDLImage alloc] As Name#>" oftype:sdlimagetype.dynamic]; SDLShow* show = [[SDLShow alloc] init]; show.graphic = image; self.sdlmanager sendrequest:show withresponsehandler:^( SDLRPCRequest *request, SDLRPCResponse *response, NSError * error) { if ([response.resultcode isequaltoenum:sdlresult.success ]) { // The text has been set successfully ];

50 SWIFT let sdlimage = SDLImage(name: "<#Uploaded As Name", of:. dynamic()) let show = SDLShow() show.graphic = image sdlmanager.send(show) { (request, response, error) in guard let response = response else { return if response.resultcode.isequal(to: SDLResult.success()) { // Success Soft & Subscribe Buttons Buttons on the HMI screen are referred to as soft buttons to distinguish them from hard buttons, which are physical buttons on the head unit. Don t confuse soft buttons with subscribe buttons, which are buttons that can detect user selection on hard buttons (or built-in soft buttons). SOFT BUTTONS Soft buttons can be created with text, images or both text and images. The location, size, and number of soft buttons visible on the screen depends on the template. If the button has an image, remember to upload the image first to the head unit before setting the image in the SDLSoftButton instance.

51 N O T E If a button type is set to image or both but no image is stored on the head unit, the button might not show up on the HMI screen.

52 OBJECTIVE-C

53 SDLSoftButton* softbutton = [[SDLSoftButton alloc] init]; // Button Id softbutton.softbuttonid Button Id#>); // Button handler - This is called when user presses the button softbutton.handler = ^(SDLRPCNotification *notification) { if ([notification iskindofclass:[sdlonbuttonpress class ]]) { SDLOnButtonPress *onbuttonpress = (SDLOnButtonPress* )notification; if ([onbuttonpress.buttonpressmode isequaltoenum: SDLButtonPressMode.SHORT]) { // Short button press else if ([onbuttonpress.buttonpressmode isequaltoenum:sdlbuttonpressmode.long]) { // Long button press else if ([notification iskindofclass:[sdlonbuttonevent class]]) { SDLOnButtonEvent *onbuttonevent = (SDLOnButtonEvent* )notification; if ([onbuttonevent.buttoneventmode isequaltoenum: SDLButtonEventMode.BUTTONUP]) { // Button up else if ([onbuttonevent.buttoneventmode isequaltoenum:sdlbuttoneventmode.buttondown]) { // Button down ; // Button type can be text, image, or both text and image softbutton.type = SDLSoftButtonType.BOTH; // Button text softbutton.text Text#>"; // Button image softbutton.image = [[SDLImage alloc] initwithname:@"<#save As Name#>" oftype: SDLImageType.DYNAMIC]; SDLShow *show = [[SDLShow alloc] init]; // The buttons are set as part of an array show.softbuttons = [NSMutableArray arraywithobject: softbutton]

54 // Send the request [self.sdlmanager sendrequest:show withresponsehandler:^( SDLRPCRequest *request, SDLRPCResponse *response, NSError * error) { if ([response.resultcode isequaltoenum:sdlresult.success ]) { // The button was created successfully ];

55 SWIFT

56 let softbutton = SDLSoftButton()! // Button Id softbutton.softbuttonid = <#Unique Button Id#> // Button handler - This is called when user presses the button softbutton.handler = { (notification) in if let onbuttonpress = notification as? SDLOnButtonPress { if onbuttonpress.buttonpressmode.isequal(to: SDLButtonPressMode.short()) { // Short button press else if onbuttonpress.buttonpressmode.isequal(to: SDLButtonPressMode.long()) { // Long button press else if let onbuttonevent = notification as? SDLOnButtonEvent { if onbuttonevent.buttoneventmode.isequal(to: SDLButtonEventMode.buttonup()) { // Button up else if onbuttonevent.buttoneventmode.isequal(to: SDLButtonEventMode.buttondown()) { // Button down // Button type can be text, image, or both text and image softbutton.type =.both() // Button text softbutton.text = "<#Button Text#>" // Button image softbutton.image = SDLImage(name: "<#Save As Name#>", of:. dynamic()) let show = SDLShow()! // The buttons are set as part of an array show.softbuttons = [softbutton] // Send the request sdlmanager.send(show) { (request, response, error) in guard let response = response else { return if response.resultcode.isequal(to: SDLResult.success())

57 { // The button was created successfully SUBSCRIBE BUTTONS Subscribe buttons are used to detect changes to hard buttons. You can subscribe to the following hard buttons: B U T T O N T E M P L AT E B U T T O N T Y P E Ok (play/pause) media template only soft button and hard button Seek left media template only soft button and hard button Seek right media template only soft button and hard button Tune up media template only hard button Tune down media template only hard button Preset 0-9 any template hard button Search any template hard button Custom any template hard button

58 Audio buttons like the OK (i.e. the play/pause button), seek left, seek right, tune up, and tune down buttons can only be used with a media template. The OK, seek left, and seek right buttons will also show up on the screen in a predefined location dictated by the media template on touchscreens. The app will be notified when the user selects the subscribe button on the screen or when the user manipulates the corresponding hard button. N O T E You will automatically be assigned the media template if you set your configuration app type as MEDIA. Menus You have two different options when creating menus. One is to simply add items to the default menu available in every template. The other is to create a custom menu that pops up when needed. Default Menu

59 F O R D H M I Every template has a default menu button. The position of this button varies between templates, and can not be removed from the template. The default menu is initially empty except for an "Exit Your App Name" button. Items can be

60 added to the menu at the root level or to a submenu. It is important to note that a submenu can only be one level deep. Menu Structure ADD MENU ITEMS The SDLAddCommand RPC can be used to add items to the root menu or to a submenu. Each SDLAddCommand RPC must be sent with a unique id, a voicerecognition command, and a set of menu parameters. The menu parameters include the menu name, the position of the item in the menu, and the id of the menu item s parent. If the menu item is being added to the root menu, then the

61 parent id is 0. If it is being added to a submenu, then the parent id is the submenu s id. OBJECTIVE-C // Create the menu parameters // The parent id is 0 if adding to the root menu // If adding to a submenu, the parent id is the submenu's id SDLMenuParams* menuparameters = [[SDLMenuParams alloc] initwithmenuname:@"menu Item Name" parentid:0 position:0]; // For menu items, be sure to use unique ids. SDLAddCommand* menuitem = [[SDLAddCommand alloc] initwithid: <#Unique Id#> vrcommands:@[@"<#voice Recognition Command#>"] handler:^(sdlrpcnotification *notification) { if (![notification iskindofclass:sdloncommand.class]) { return; SDLOnCommand* oncommand = (SDLOnCommand*)notification; if ([oncommand.triggersource isequaltoenum: SDLTriggerSource.MENU]) { // Menu Item Was Selected ]; // Set the menu parameters menuitem.menuparams = menuparameters; [self.sdlmanager sendrequest:menuitem withresponsehandler:^( SDLRPCRequest *request, SDLRPCResponse *response, NSError * error) { if ([response.resultcode isequaltoenum:sdlresult.success ]) { // The menuitem was created successfully ];

62 SWIFT // Create the menu parameters // The parent id is 0 if adding to the root menu // If adding to a submenu, the parent id is the submenu's id let menuparameters = SDLMenuParams(menuName: "<#Menu Item Name#>", parentid: 0, position: 0)! // For menu items, be sure to use unique ids. let menuitem = SDLAddCommand(id: <#Unique Id#>, vrcommands: ["<#Voice Recognition Command#>"]) { (notification) in guard let oncommand = notification as? SDLOnCommand else { return if oncommand.triggersource ==.menu() { // Menu Item Was Selected! // Set the menu parameters menuitem.menuparams = menuparameters sdlmanager.send(menuitem) { (request, response, error) in if response?.resultcode ==.success() { // The menuitem was created successfully ADD A SUBMENU To create a submenu, first send a SDLAddSubMenu RPC. When a response is received from the SDL Core, check if the submenu was added successfully. If it was, send an SDLAddCommand RPC for each item in the submenu.

63 OBJECTIVE-C SDLAddSubMenu* submenu = [[SDLAddSubMenu alloc] initwithid:< #Unique Id#> menuname:@"<#submenu Item Name#>"]; [self.sdlmanager sendrequest:submenu withresponsehandler:^( SDLRPCRequest *request, SDLRPCResponse *response, NSError * error) { if ([response.resultcode isequaltoenum:sdlresult.success]) { // The submenu was created successfully, start adding the submenu items ]; SWIFT let submenu = SDLAddSubMenu(id: <#Unique Id#>, menuname: "<#SubMenu Item Name#>")! sdlmanager.send(submenu) { (request, response, error) in if response?.resultcode ==.success() { // The submenu was created successfully, start adding the submenu items )

64 DELETE MENU ITEMS Use the cmdid of the menu item to tell the SDL Core which item to delete using the SDLDeleteCommand RPC. OBJECTIVE-C SDLDeleteCommand* deletemenuitem = [[SDLDeleteCommand alloc] initwithid:<#id of Menu Item To Delete#>]; [self.sdlmanager sendrequest:deletemenuitem withresponsehandler:^(sdlrpcrequest *request, SDLRPCResponse *response, NSError *error) { if ([response.resultcode isequaltoenum:sdlresult.success]) { // The menu item was successfully deleted ];

65 SWIFT let deletemenuitem = SDLDeleteCommand(id: <#Id of Menu Item To Delete#>)! sdlmanager.send(deletemenuitem) { (request, response, error) in if response?.resultcode ==.success() { // The menu item was successfully deleted DELETE SUBMENUS Use the menuid to tell the SDLCore which item to delete using the SDLDeleteSubMenu RPC.

66 OBJECTIVE-C SDLDeleteSubMenu* deletesubmenu = [[SDLDeleteSubMenu alloc] initwithid:<#id of Sub Menu Item to Delete#>]; [self.sdlmanager sendrequest:deletesubmenu withresponsehandler:^(sdlrpcrequest *request, SDLRPCResponse *response, NSError *error) { if ([response.resultcode isequaltoenum:sdlresult.success]) { // The sub menu was successfully deleted ]; SWIFT let deletesubmenu = SDLDeleteSubMenu(id: <#Id of Sub Menu Item to Delete#>)! sdlmanager.send(deletesubmenu) { (request, response, error) in if response?.resultcode ==.success() { // The sub menu was successfully deleted

67 Custom Menus Custom menus, called perform interactions, are one level deep, however, you can create submenus by triggering another perform interaction when the user selects a row in a menu. Perform interactions can be set up to recognize speech, so a user can select an item in the menu by speaking their preference rather than physically selecting the item. Perform interactions are created by sending two different RPCs. First a SDLCreateInteractionChoiceSet RPC must be sent. This RPC sends a list of items that will show up in the menu. When the request has been registered successfully, then a SDLPerformInteraction RPC is sent. The

68 SDLPerformInteraction RPC sends the formatting requirements, the voicerecognition commands, and a timeout command. CREATE A SET OF CUSTOM MENU ITEMS Each menu item choice defined in SDLChoice should be assigned a unique id. The choice set in SDLCreateInteractionChoiceSet should also have its own unique id. OBJECTIVE-C SDLChoice* choice = [[SDLChoice alloc] initwithid:<#unique Id#> menuname:@"<#menu Title#>" vrcommands:@[@"<#menu Commands#>"]]; SDLCreateInteractionChoiceSet* createrequest = [[ SDLCreateInteractionChoiceSet alloc] initwithid:<#unique Id# > choiceset:@[choice]]; [self.sdlmanager sendrequest:createrequest withresponsehandler:^(sdlrpcrequest *request, SDLRPCResponse *response, NSError *error) { if ([response.resultcode isequaltoenum:sdlresult.success ]) { // The request was successful, now send the SDLPerformInteraction RPC ];

69 SWIFT let choice = SDLChoice(id: <#Unique Id#>, menuname: "<#Menu Title#>", vrcommands: ["<#Menu Command#>"])! let createrequest = SDLCreateInteractionChoiceSet(id: <# Unique Id#>, choiceset: [choice])! sdlmanager.send(createrequest) { (request, response, error) in if response?.resultcode ==.success() { // The request was successful, now send the SDLPerformInteraction RPC FORMAT THE SET OF CUSTOM MENU ITEMS Once the set of menu items has been sent to SDL Core, send a SDLPerformInteraction RPC to get the items to show up on the HMI screen.

70 OBJECTIVE-C SDLPerformInteraction* performinteraction = [[ SDLPerformInteraction alloc] initwithinitialprompt:nil initialtext:@"<#text Displayed When Shown#>" interactionchoicesetid:<#sdlcreateinteractionchoiceset id#> ]; SWIFT let performinteraction = SDLPerformInteraction(initialPrompt : nil, initialtext: "<#Text Displayed When Shown#>", interactionchoicesetid: <#SDLCreateInteractionChoiceSet id#> )! INTERACTION MODE The interaction mode specifies the way the user is prompted to make a section and the way in which the user s selection is recorded.

71 I N T E R A C T I O N M O D E D E S C R I P T I O N Manual only Interactions occur only through the display VR only Interactions occur only through text-to-speech and voice recognition Both Interactions can occur both manually or through VR OBJECTIVE-C performinteraction.interactionmode = SDLInteractionMode. MANUAL_ONLY; SWIFT performinteraction.interactionmode =.manual_only() VR INTERACTION MODE

72 F O R D H M I MANUAL INTERACTION MODE

73 F O R D H M I INTERACTION L AYOUT The items in the perform interaction can be shown as a grid of buttons (with optional images) or as a list of choices.

74 L AY O U T M O D E F O R M AT T I N G D E S C R I P T I O N Icon only A grid of buttons with images Icon with search A grid of buttons with images along with a search field in the HMI List only A vertical list of text List with search A vertical list of text with a search field in the HMI Keyboard A keyboard shows up immediately in the HMI N O T E Keyboard is currently only supported for the navigation app type. OBJECTIVE-C performinteraction.interactionlayout = SDLLayoutMode. LIST_ONLY;

75 SWIFT performinteraction.interactionlayout =.list_only() ICON ONLY INTERACTION L AYOUT F O R D H M I LIST ONLY INTERACTION L AYOUT

76 F O R D H M I LIST WITH SEARCH INTERACTION L AYOUT F O R D H M I

77 TEXT-TO -SPEECH (TTS) A text-to-speech chunk is a text phrase or prerecorded sound that will be spoken by the head unit. The text parameter specifies the text to be spoken or the name of the pre-recorded sound. Use the type parameter to define the type of information in the text parameter. The SDLPerformInteraction request can have a initial, timeout, and a help prompt. OBJECTIVE-C SDLTTSChunk* ttschunk = [[SDLTTSChunk alloc] to Speak#>" type:sdlspeechcapabilities.text]; performinteraction.initialprompt = [NSMutableArray arraywithobject:ttschunk]; // or - more easily performinteraction.initialprompt = [SDLTTSChunk textchunksfromstring:@"<#text to Speak#>"];

78 SWIFT let ttschunk = SDLTTSChunk(text: "<#Text to Speak#>", type:.text()) performinteraction.initialprompt = NSMutableArray(array: [ prompt!]) // or - more easily performinteraction.initialprompt = SDLTTSChunk.textChunks( from: "<#Text to Speak#>") TIMEOUT The timeout parameter defines the amount of time the menu will appear on the screen before the menu is dismissed automatically by the HMI. OBJECTIVE-C performinteraction.timeout // 30 seconds

79 SWIFT performinteraction.timeout = // 30 seconds SEND THE REQUEST OBJECTIVE-C [self.sdlmanager sendrequest:performinteraction withresponsehandler:^(sdlrpcrequest *request, SDLRPCResponse *response, NSError *error) { if (![response iskindofclass: SDLPerformInteractionResponse.class]) { return; SDLPerformInteractionResponse* performinteractionresponse = (SDLPerformInteractionResponse* )response; if ([performinteractionresponse.resultcode isequaltoenum :SDLResult.TIMED_OUT]) { // The custom menu timed out before the user could select an item else if ([performinteractionresponse.resultcode isequaltoenum:sdlresult.success]) { NSNumber* choiceid = performinteractionresponse. choiceid; // The user selected an item in the custom menu ];

80 SWIFT sdlmanager.send(performinteraction) { (request, response, error) in guard let performinteractionresponse = response as? SDLPerformInteractionResponse else { return; // Wait for user's selection or for timeout if performinteractionresponse.resultcode ==.timed_out() { // The custom menu timed out before the user could select an item else if performinteractionresponse.resultcode ==. success() { let choiceid = performinteractionresponse.choiceid // The user selected an item in the custom menu DELETE THE CUSTOM MENU If the information in the menu is dynamic, then the old interaction choice set needs to be deleted with a SDLDeleteInteractionChoiceSet RPC before the

81 new information can be added to the menu. Use the interaction choice set id to delete the menu. OBJECTIVE-C SDLDeleteInteractionChoiceSet* deleterequest = [[ SDLDeleteInteractionChoiceSet alloc] initwithid:<# SDLCreateInteractionChoiceSet id#>]; [self.sdlmanager sendrequest:deleterequest withresponsehandler:^(sdlrpcrequest *request, SDLRPCResponse *response, NSError *error) { if ([response.resultcode isequaltoenum:sdlresult.success ]) { // The custom menu was deleted successfully ]; SWIFT let deleterequest = SDLDeleteInteractionChoiceSet(id: <# SDLCreateInteractionChoiceSet id#>)! sdlmanager.send(deleterequest) { (request, response, error) in if response?.resultcode ==.success() { // The custom menu was deleted successfully

82 Alerts An alert is a pop-up window with some lines of text and optional soft buttons. When an alert is activated, it will abort any SDL operation that is in-progress, except the already-in-progress alert. If an alert is issued while another alert is still in progress, the newest alert will simply be ignored. Dismissing the Alert The alert will persist on the screen until the timeout has elapsed, or the user dismisses the alert by selecting a button. There is no way to dismiss the alert programmatically other than to set the timeout length. Alert UI Depending the platform, an alert can have up to three lines of text, a progress indicator (e.g. a spinning wheel or hourglass), and up to four soft buttons. ALERT WITHOUT SOFT BUTTONS

83 F O R D H M I ALERT WITH SOFT BUTTONS F O R D H M I Alert TTS The alert can also be formatted to speak a prompt when the alert appears on the screen. Do this by setting the ttschunks parameter. To play the alert tone before the text-to-speech is spoken, set playtone to true.

84 Example OBJECTIVE-C

85 SDLAlert *alert = [[SDLAlert alloc] 1#>" alerttext2:@"<#line 2#>" alerttext3:@"<#line 3#>"]; // Maximum time alert appears before being dismissed // Timeouts are must be between 3-10 seconds // Timeouts may not work when soft buttons are also used in the alert alert.duration // A progress indicator (e.g. spinning wheel or hourglass) // Not all head units support the progress indicator alert.progressindicator // Text-to-speech alert.ttschunks = [SDLTTSChunk to speak#>"]; // Special tone played before the tts is spoken alert.playtone // Soft buttons SDLSoftButton *okbutton = [[SDLSoftButton alloc] init]; okbutton.text okbutton.type = SDLSoftButtonType.TEXT; okbutton.softbuttonid Button Id#>; okbutton.handler = ^(SDLRPCNotification *notification) { if (![notification iskindofclass:sdlonbuttonpress.class ]) { return; SDLOnButtonPress *onbuttonpress = (SDLOnButtonPress*) notification; NSNumber *buttonid = onbuttonpress.custombuttonid; // create a custom action for the selected button ; alert.softbuttons = [NSMutableArray arraywithobject:okbutton ]; // Send the alert [self.sdlmanager sendrequest:alert withresponsehandler:^( SDLRPCRequest *request, SDLRPCResponse *response, NSError * error) { if ([response.resultcode isequaltoenum:sdlresult.success ]) { // alert was dismissed successfully ];

86 SWIFT let alert = SDLAlert(alertText1: "<#Line 1#>", alerttext2: "<#Line 2#>", alerttext3: "<#Line 3#>")! // Maximum time alert appears before being dismissed // Timeouts are must be between 3-10 seconds // Timeouts may not work when soft buttons are also used in the alert alert.duration = 5000 // A progress indicator (e.g. spinning wheel or hourglass) // Not all head units support the progress indicator alert.progressindicator = true // Text-to-speech alert.ttschunks = SDLTTSChunk.textChunks(from: "<#Text to speak#>") // Special tone played before the tts is spoken alert.playtone = true // Soft buttons let okbutton = SDLSoftButton()! okbutton.text = "OK" okbutton.type =.text() okbutton.softbuttonid = <#Soft Button Id#> okbutton.handler = { (notification) in guard let notification = notification as? SDLOnButtonPress else { return guard let id = notification.custombuttonid else { return // create a custom action for the selected button alert.softbuttons = [okbutton] // Send the alert sdlmanager.send(alert) { (request, response, error) in if response?.resultcode ==.success() { // alert was dismissed successfully

87 Uploading Files and Graphics Graphics allows for you to better customize what you would like to have your users see, and provide a better User Interface. To learn how to use these graphics once they are uploaded, please see Displaying Information > Text, Images, and Buttons. When developing an application using SmartDeviceLink, two things must always be remembered when using graphics: 1. You may be connected to a head unit that does not display graphics. 2. You must upload them from your mobile device to Core before using them. Detecting if Graphics are Supported Being able to know if graphics are supported is a very important feature of your application, as this avoids you uploading unneccessary images to the head unit. In order to see if graphics are supported, take a look at SDLManager 's registerresponse property once in the completion handler for startwithreadyhandler. N O T E If you need to know how to create and setup SDLManager, please see Getting Started > Integration Basics.

88 OBJECTIVE-C weak typeof (self) weakself = self; [self.sdlmanager startwithreadyhandler:^(bool success, NSError * _Nullable error) { if (!success) { NSLog(@"SDL errored starting up: %@", error); return; SDLDisplayCapabilities *displaycapabilities = weakself. sdlmanager.registerresponse.displaycapabilities; BOOL aregraphicssupported = NO; if (displaycapabilities!= nil) { aregraphicssupported = displaycapabilities. graphicsupported.boolvalue; ];

89 SWIFT sdlmanager.start { (success, error) in if success == false { print("sdl errored starting up: \(error)") return var aregraphicssupported = false if let displaycapabilities = self.sdlmanager. registerresponse?.displaycapabilities { aregraphicssupported = displaycapabilities. graphicsupported.boolvalue Uploading a File using SDLFileManager As of SDL 4.3, we have provided a class that makes managing files easier. SDLFileManager handles uploading files, like images, and keeping track of what already exists and what does not. To assist, there are two classes: SDLFile and SDLArtwork. SDLFile is the base class for file uploads and handles pulling data from local NSURL s and NSData. SDLArtwork is subclass

90 of this, and provides additional functionality such as creating a file from a UIImage. OBJECTIVE-C UIImage* image = [UIImage imagenamed:@"<#image Name#>"]; if (!image) { NSLog(@"Error reading from Assets"); return; SDLArtwork* file = [SDLArtwork artworkwithimage:image to Upload As#>" asimageformat: SDLArtworkImageFormatJPG /* or SDLArtworkImageFormatPNG */]; [self.sdlmanager.filemanager uploadfile:file completionhandler:^(bool success, NSUInteger bytesavailable, NSError * _Nullable error) { if (error) { if (error.code == SDLFileManagerErrorCannotOverwrite ) { // Attempting to replace a file, but failed due to settings in SDLArtwork. else { // Error uploading return; ]; // Successfully uploaded.

91 SWIFT guard let image = UIImage(named: "<#Image Name#>") else { print("error reading from Assets") return let file = SDLArtwork.artwork(with: image, name: "<#Name to Upload As#>", as:.jpg /* or.png */) sdlmanager.filemanager.uploadfile(file) { (success, bytesavailable, error) in if let error = error as? NSError { if error.code == SDLFileManagerError.cannotOverwrite.rawValue { // Attempting to replace a file, but failed due to settings in SDLArtwork. else { // Error uploading return; // Successfully uploaded File Naming The file name can only consist of letters (a-z) and numbers (0-9), otherwise the SDL Core may fail to find the uploaded file (even if it was uploaded successfully). File Persistance SDLFile, and it's subclass SDLArtwork, support uploading persistant images, i.e. images that do not become deleted when your application

92 disconnects. Persistance should be used for images relating to your UI, and not for dynamic aspects, such as Album Artwork. OBJECTIVE-C file.persistent = YES; SWIFT file.persistent = true N O T E Be aware that persistance will not work if space on the head unit is limited. SDLFileManager will always handle uploading images if they are non-existant.

93 Overwrite Stored Files If a file being uploaded has the same name as an already uploaded image, the new image will be ignored. To override this setting, set the SDLFile s overwrite property to true. OBJECTIVE-C file.overwrite = YES; SWIFT file.overwrite = true Check the Amount of File Storage To find the amount of file storage left on the head unit, use the SDLFileManager s bytesavailable property.

94 OBJECTIVE-C NSUInteger bytesavailable = self.sdlmanager.filemanager. bytesavailable; SWIFT let bytesavailable = sdlmanager.filemanager.bytesavailable Check if a File Has Already Been Uploaded Although the file manager will return with an error if you attempt to upload a file of the same name that already exists, you may still be able to find out the

95 currently uploaded images via SDLFileManager 's remotefilenames property. OBJECTIVE-C BOOL isfileonheadunit = [self.sdlmanager.filemanager. remotefilenames containsobject:@"<#name Uploaded As#>"]; SWIFT let isfileonheadunit = sdlmanager.filemanager. remotefilenames.contains("<#name Uploaded As#>") Delete Stored Files Use the file manager s delete request to delete a file associated with a file name.

96 OBJECTIVE-C [self.sdlmanager.filemanager As Name#>" completionhandler:^(bool success, NSUInteger bytesavailable, NSError *error) { if (success) { // Image was deleted successfully ]; SWIFT sdlmanager.filemanager.deleteremotefilewithname("<#save As Name#>") { (success, bytesavailable, error) in if success { // Image was deleted successfully

97 Image Specifics Image File Type Images may be formatted as PNG, JPEG, or BMP. Check the displaycapability properties to find out what image formats the head unit supports. Image Sizes If an image is uploaded that is larger than the supported size, that image will be scaled down to accomodate. All image sizes are available from the

98 SDLManager 's registerresponse property once in the completion handler for startwithreadyhandler.

99 IMAGE SPECIFICATIONS

100 I M A G E N A M E U S E D I N R P C D E TA I L S H E I G H T W I D T H T Y P E softbu ttonim age Show Will be shown on softbutt ons on the base screen 70px 70px png, jpg, bmp choice Image CreateI nteracti onchoic eset Will be shown in the manual part of an perform Interact ion either big (ICON_ ONLY) or small (LIST_O NLY) 70px 70px png, jpg, bmp choice Secon daryi mage CreateI nteracti onchoic eset Will be shown on the right side of an entry in (LIST_O NLY) perform Interact ion 35px 35px png, jpg, bmp vrhelp Item SetGlob alprope rties Will be shown during voice interact ion 35px 35px png, jpg, bmp

101 I M A G E N A M E U S E D I N R P C D E TA I L S H E I G H T W I D T H T Y P E menui con SetGlob alprope rties Will be shown on the More button 35px 35px png, jpg, bmp cmdic on AddCo mmand Will be shown for comma nds in the "More " menu 35px 35px png, jpg, bmp appic on SetAppI con Will be shown as Icon in the "Mobile Apps" menu 70px 70px png, jpg, bmp graphi c Show Will be shown on the basescr een as cover art 185px 185px png, jpg, bmp Knowing the In-Car UI Status Once your app is connected to Core, most of the interaction you will be doing requires knowledge of the current In-Car UI, or HMI, Status. For a refresher on how to get your app integrated with SDL, and to connect to Core, head to

102 Getting Started > Integration Basics. The HMI Status informs you of where the user is within the head unit in a general sense. Refer to the table below of all possible HMI States: H M I S TAT E W H AT D O E S T H I S M E A N? NONE The user has not been opened your app, or it has been Exited via the "Menu" button. BACKGROUND The user has opened your app, but is currently in another part of the Head Unit. If you have a Media app, this means that another Media app has been selected. LIMITED For Media apps, this means that a user has opened your app, but is in another part of the Head Unit. FULL Your app is currently in focus on the screen. Monitoring HMI Status Monitoring HMI Status is provided through a required delegate callback of SDLManagerDelegate. The function hmilevel:didchangetolevel: will give

103 you information relating the previous and new HMI levels your app is progressing through. OBJECTIVE-C - (void)hmilevel:(sdlhmilevel *)hmilevel didchangetonewlevel:(sdlhmilevel *)newlevel { SWIFT func hmilevel(_ oldlevel: SDLHMILevel, didchangeto newlevel: SDLHMILevel) { More Detailed HMI Information When an interaction occurs relating to your application, there is some additional pieces of information that can be observed that help figure out a more descriptive picture of what is going on with the Head Unit.

104 AUDIO STREAMING STATE From the documentation, Audio Streaming State informs your app whether any currently streaming audio is audible to user (AUDIBLE) or not (NOT_AUDIBLE). A value of NOT_AUDIBLE means that either the application's audio will not be audible to the user, or that the application's audio should not be audible to the user (i.e. some other application on the mobile device may be streaming audio and the application's audio would be blended with that other audio). You will see this come in for things such as Alert, PerformAudioPassThru, Speaks, etc. A U D I O S T R E A M I N G S TAT E W H AT D O E S T H I S M E A N? AUDIBLE Any audio you are streaming will be audible to the user. ATTENUATED Some kind of audio mixing is occuring between what you are streaming, if anything, and some system level sound. This can be visible is displaying an Alert with playtone set to true. NOT_AUDIBLE Your streaming audio is not audible. This could occur during a VRSESSSION System Context. SYSTEM CONTEXT System Context informs your app if there is potentially a blocking HMI component while your app is still visible. An example of this would be if your

105 application is open, and you display an Alert. Your app will receive a System Context of ALERT while it is presented on the screen, followed by MAIN when it is dismissed. S Y S T E M C O N T E X T S TAT E W H AT D O E S T H I S M E A N? MAIN No user interaction is in progress that could be blocking your app's visibility. VRSESSION Voice Recognition is currently in progress. MENU A menu interaction is currently in-progress. HMI_OBSCURED The app's display HMI is being blocked by either a system or other app's overlay (another app's Alert, for instance). ALERT An alert that you have sent is currently visible (Other apps will not receive this). Monitoring Audio Streaming State and System Context Monitoring these two properties is quite easy using the provided SDLDidChangeHMIStatusNotification notification. First, observe the notification:

106 OBJECTIVE-C [[NSNotificationCenter defaultcenter] addobserver:self name: SDLDidChangeHMIStatusNotification object:nil]; SWIFT NotificationCenter.default.addObserver(self, selector: # selector(hmistatuschanged(_:)), name:.sdldidchangehmistatus, object: nil) Next, handle the notification:

107 OBJECTIVE-C - (void)hmistatuschanged:(sdlrpcnotificationnotification *) notification { if (![notification.notification iskindofclass: SDLOnHMIStatus.class]) { return; SDLOnHMIStatus *onhmistatus = (SDLOnHMIStatus *) notification.notification; SDLAudioStreamingState *audiostreamingstate = onhmistatus.audiostreamingstate; SDLSystemContext *systemcontext = onhmistatus. systemcontext; SWIFT func hmistatuschanged(_ notification: SDLRPCNotificationNotification) { guard let onhmistatus = notification.notification as? SDLOnHMIStatus else { return let audiostreamingstate = onhmistatus. audiostreamingstate let systemcontext = onhmistatus.systemcontext

108 Adding the Lock Screen The lock screen is a vital part of SmartDeviceLink, as this does not allow the user to use your application while the vehicle is in motion. Prior to SDL 4.3, creating and maintaining the lock screen was up to the developer to do. Now, SDL takes care of the lock screen for you. It still allows you to use your own view controller if you prefer your own look, but still want the recommended logic that SDL provides for free. A benefit to using the provided Lock Screen, is that we also handle support for retrieving a lock screen icon for versions of Core that support it, so that you do not have to be concerned with what car manufacturer you are connected to. If you would not like to use any of the following code, you may use the SDLLockScreenConfiguration class function disabledconfiguration, and manage the entire lifecycle of the lock screen yourself. To see where the SDLLockScreenConfiguration is used, refer to the Getting Started > Integration Basics. Using the Provided Lock Screen Using the default lock screen is simple. Using the lock screen this way will automatically load an automaker's logo, if supported, to show alongside your logo. If it is not, the default lock screen will show your logo alone.

109 To do this, instantiate a new SDLLockScreenConfiguration : OBJECTIVE-C SDLLockScreenConfiguration *lockscreenconfiguration = [ SDLLockScreenConfiguration enabledconfiguration]; Swift let lockscreenconfiguration = SDLLockScreenConfiguration. enabled()

110 Customizing the Provided Lock Screen If you would like to use the provided lock screen, however would like to add your own appearance to it, we provide that as well. SDLLockScreenConfiguration allows you to customize the background color as well as your app's icon. If the app icon is not included, we will use the SDL logo. OBJECTIVE-C UIImage *appicon = <# Retreive App Icon #> UIColor *backgroundcolor = <# Desired Background Color #> SDLLockScreenConfiguration *lockscreenconfiguration = [ SDLLockScreenConfiguration enabledconfigurationwithappicon: appicon backgroundcolor:backgroundcolor];

111 SWIFT let appicon = <# Retrieve App Icon #> let backgroundcolor = <# Desired Background Color #> let lockscreenconfiguration = SDLLockScreenConfiguration. enabledconfiguration(withappicon: appicon, backgroundcolor: backgroundcolor) Using Your Own Lock Screen If you would like to use your own lock screen instead of the provided SDL one, but still use the logic we provide, you can use a new initializer within SDLLockScreenConfiguration : OBJECTIVE-C UIViewController *lockscreenviewcontroller = <# Initialize Your View Controller #>; SDLLockScreenConfiguration *lockscreenconfiguration = [ SDLLockScreenConfiguration enabledconfigurationwithviewcontroller: lockscreenviewcontroller];

112 SWIFT let lockscreenviewcontroller = <# Initialize Your View Controller #> let lockscreenconfiguration = SDLLockScreenConfiguration. enabledconfiguration(with: lockscreenviewcontroller) Retrieving Make and Model If you have decided to create your own lock screen, a best practice is to display the OEM you are connect to's logo, as this adds a more personal touch for the end user. OBJECTIVE-C weak typeof (self) weakself = self; [self.sdlmanager startwithreadyhandler:^(bool success, NSError * _Nullable error) { if (!success) { NSLog(@"SDL errored starting up: %@", error); return; SDLVehicleType *vehicletype = weakself.sdlmanager. registerresponse.vehicletype; NSString *make = vehicletype.make; NSString *model = vehicletype.model; ];

113 SWIFT sdlmanager.start { (success, error) in if success == false { print("sdl errored starting up: \(error)") return guard let vehicletype = self.sdlmanager.registerresponse?.vehicletype, let make = vehicletype.make, let model = vehicletype.model else { // No make/model found. return Retrieving Lock Screen URL A newer feature that some OEMs may adapt is the ability for the head unit to provide SDLManager a URL for a logo to display on the Lock Screen. If you are creating your own lock screen, it is a best practice to utilize this feature. This notifcation comes through after we have downloaded the icon for you, and sent it in the SDLDidReceiveLockScreenIcon notification. First, register for the SDLDidReceiveLockScreenIcon Notification:

114 OBJECTIVE-C [[NSNotificationCenter defaultcenter] addobserver:self name: SDLDidReceiveLockScreenIcon object:nil]; SWIFT NotificationCenter.default.addObserver(self, selector: # selector(lockscreeniconreceived(_:)), name: SDLDidReceiveLockScreenIcon, object: nil) Then, act on the notification:

115 OBJECTIVE-C - (void)lockscreeniconreceived:(nsnotification *) notification { if (![notification.userinfo[ SDLNotificationUserInfoObject] iskindofclass:[uiimage class ]]) { return; UIImage *icon = notification.userinfo[ SDLNotificationUserInfoObject]; SWIFT func lockscreeniconreceived(_ notification: NSNotification) { guard let image = notification.userinfo[ SDLNotificationUserInfoObject] as? UIImage else { return

116 Get Vehicle Data Use the SDLGetVehicleData RPC call to get vehicle data. The HMI level must be FULL, LIMITED, or BACKGROUND in order to get data. Each vehicle manufacturer decides which data it will expose. Please check the SDLRPCResponse RPC to find out which data you will have access to in your head unit. N O T E You may only ask for vehicle data that is available to your appname & appid combination. These will be specified by each OEM separately.

117 V E H I C L E D ATA PA R A M E T E R N A M E D E S C R I P T I O N GPS gps Longitude and latitude, current time in UTC, degree of precision, altitude, heading, speed, satellite data vs dead reckoning, and supported dimensions of the GPS Speed speed Speed in KPH RPM rpm The number of revolutions per minute of the engine Fuel level fuellevel The fuel level in the tank (percentage) Fuel level state fuellevel_state The fuel level state: unknown, normal, low, fault, alert, or not supported Instant fuel consumption instantfuelconsumpt ion The instantaneous fuel consumption in microlitres External temperature externaltemperature The external temperature in degrees celsius VIN vin The Vehicle Identification Number

118 V E H I C L E D ATA PA R A M E T E R N A M E D E S C R I P T I O N PRNDL prndl The selected gear the car is in: park, reverse, neutral, drive, sport, low gear, first, second, third, fourth, fifth, sixth, seventh or eighth gear, unknown, or fault Tire pressure tirepressure Tire status of each wheel in the vehicle: normal, low, fault, alert, or not supported. Warning light status for the tire pressure: off, on, flash, or not used Odometer odometer Odometer reading in km Belt status beltstatus The status of each of the seat belts: no, yes, not supported, fault, or no event Body information bodyinformation Door ajar status for each door. The Ignition status. The ignition stable status. The park brake active status.

119 V E H I C L E D ATA PA R A M E T E R N A M E D E S C R I P T I O N Device status devicestatus Contains information about the smartphone device. Is voice recognition on or off, has a bluetooth connection been established, is a call active, is the phone in roaming mode, is a text message available, the battery level, the status of the mono and stereo output channels, the signal level, the primary audio source, whether or not an emergency call is currently taking place Driver braking driverbraking The status of the brake pedal: yes, no, no event, fault, not supported Wiper status wiperstatus The status of the wipers: off, automatic off, off moving, manual interaction off, manual interaction on, manual low, manual high, manual flick, wash, automatic low, automatic high, courtesy wipe, automatic adjust, stalled, no data exists

120 V E H I C L E D ATA PA R A M E T E R N A M E D E S C R I P T I O N Head lamp status headlampstatus Status of the head lamps: whether or not the low and high beams are on or off. The ambient light sensor status: night, twilight 1, twilight 2, twilight 3, twilight 4, day, unknown, invalid Engine torque enginetorque Torque value for engine (in Nm) on non-diesel variants Acceleration pedal position accpedalposition Accelerator pedal position (percentage depressed) Steering wheel angle steeringwheelangle Current angle of the steering wheel (in degrees) E-Call infomation ecallinfo Information about the status of an emergency call Airbag status airbagstatus Status of each of the airbags in the vehicle: yes, no, no event, not supported, fault

121 V E H I C L E D ATA PA R A M E T E R N A M E D E S C R I P T I O N Emergency event emergencyevent The type of emergency: frontal, side, rear, rollover, no event, not supported, fault. Fuel cutoff status: normal operation, fuel is cut off, fault. The roll over status: yes, no, no event, not supported, fault. The maximum change in velocity. Whether or not multiple emergency events have occurred Cluster mode status clustermodestatus Whether or not the power mode is active. The power mode qualification status: power mode undefined, power mode evaluation in progress, not defined, power mode ok. The car mode status: normal, factory, transport, or crash. The power mode status: key out, key recently out, key approved, post accessory, accessory, post ignition, ignition on, running, crank My key mykey Information about whether or not the emergency 911 override has been activated

122 Single Time Vehicle Data Retrieval Using SDLGetVehicleData, we can ask for vehicle data a single time, if needed.

123 OBJECTIVE-C SDLGetVehicleData *getvehicledata = [[SDLGetVehicleData alloc] init]; getvehicledata.prndl [self.sdlmanager sendrequest:getvehicledata withresponsehandler:^( kindof SDLRPCRequest * _Nullable request, kindof SDLRPCResponse * _Nullable response, NSError * _Nullable error) { if (error) { NSLog(@"Encountered Error sending GetVehicleData: error); return; if (![response iskindofclass:sdlgetvehicledataresponse. class]) { return; SDLGetVehicleDataResponse* getvehicledataresponse = ( SDLGetVehicleDataResponse *)response; SDLResult *resultcode = getvehicledataresponse. resultcode; if (![resultcode isequaltoenum:sdlresult.success]) { if ([resultcode isequaltoenum:sdlresult.rejected]) { NSLog(@"GetVehicleData was rejected. Are you in an appropriate HMI?"); else if ([resultcode isequaltoenum:sdlresult. DISALLOWED]) { NSLog(@"Your app is not allowed to use GetVehicleData"); else { NSLog(@"Some unknown error has occured!"); return; ]; SDLPRNDL *prndl = getvehicledataresponse.prndl;

124 SWIFT let getvehicledata = SDLGetVehicleData()! getvehicledata.prndl = true sdlmanager.send(getvehicledata) { (request, response, error) in guard let response = response as? SDLGetVehicleDataResponse, let resultcode = response.resultcode else { return if let error = error { print("encountered Error sending GetVehicleData: \( error)") return if!resultcode.isequal(to: SDLResult.success()) { if resultcode.isequal(to: SDLResult.rejected()) { print("getvehicledata was rejected. Are you in an appropriate HMI?") else if resultcode.isequal(to: SDLResult. disallowed()) { print("your app is not allowed to use GetVehicleData") else { print("some unknown error has occured!") return let prndl = response.prndl

125 Subscribing to Vehicle Data Subscribing to vehicle data allows you to get notified whenever we have new data available. This data should not be relied upon being received in a consistent manner. New vehicle data is available roughly every second. First, Register to observe the SDLDidReceiveVehicleDataNotification notification: OBJECTIVE-C [[NSNotificationCenter defaultcenter] addobserver:self selector:@selector(vehicledataavailable:) name: SDLDidReceiveVehicleDataNotification object:nil]; SWIFT NotificationCenter.default.addObserver(self, selector: # selector(vehicledataavailable(_:)), name:. SDLDidReceiveVehicleData, object: nil) Then. Send the Subscribe Vehicle Data Request

126 OBJECTIVE-C

127 SDLSubscribeVehicleData *subscribevehicledata = [[ SDLSubscribeVehicleData alloc] init]; subscribevehicledata.prndl [self.sdlmanager sendrequest:subscribevehicledata withresponsehandler:^( kindof SDLRPCRequest * _Nullable request, kindof SDLRPCResponse * _Nullable response, NSError * _Nullable error) { if (![response iskindofclass:[ SDLSubscribeVehicleDataResponse class]]) { return; if (!response.success.boolvalue) { SDLSubscribeVehicleDataResponse * subscribevehicledataresponse = ( SDLSubscribeVehicleDataResponse*)response; SDLVehicleDataResult *prndldata = subscribevehicledataresponse.prndl; if ([response.resultcode isequaltoenum:sdlresult. DISALLOWED]) { // Not allowed to register for this vehicle data. else if ([response.resultcode isequaltoenum: SDLResult.USER_DISALLOWED]) { // User disabled the ability to give you this vehicle data else if ([response.resultcode isequaltoenum: SDLResult.IGNORED]) { if ([prndldata.resultcode isequaltoenum: SDLVehicleDataResultCode.DATA_ALREADY_SUBSCRIBED]) { // You have access to this data item, and you are already subscribed to this item so we are ignoring. else if ([prndldata.resultcode isequaltoenum: SDLVehicleDataResultCode.VEHICLE_DATA_NOT_AVAILABLE]) { // You have access to this data item, but the vehicle you are connected to does not provide it. else { NSLog(@"Unknown reason for being ignored: prndldata.resultcode.value); else if (error) { NSLog(@"Encountered Error sending SubscribeVehicleData: %@", error);

128 return; if (![response iskindofclass: SDLSubscribeVehicleDataResponse.class]) { return; ]; // Successfully subscribed

129 SWIFT

130 let subscribevehicledata = SDLGetVehicleData()! subscribevehicledata.prndl = true sdlmanager.send(subscribevehicledata) { (request, response, error) in guard let response = response as? SDLSubscribeVehicleDataResponse else { return guard response.success.boolvalue == true else { if response.resultcode.isequal(to: SDLResult. disallowed()) { // Not allowed to register for this vehicle data. else if response.resultcode.isequal(to: SDLResult. user_disallowed()) { // User disabled the ability to give you this vehicle data else if response.resultcode.isequal(to: SDLResult. ignored()) { if let prndldata = response.prndl { if prndldata.resultcode.isequal(to: SDLVehicleDataResultCode.data_ALREADY_SUBSCRIBED()) { // You have access to this data item, and you are already subscribed to this item so we are ignoring. else if prndldata.resultcode.isequal(to: SDLVehicleDataResultCode.vehicle_DATA_NOT_AVAILABLE()) { // You have access to this data item, but the vehicle you are connected to does not provide it. else { print("unknown reason for being ignored: \(prndldata.resultcode.value)") else { print("unknown reason for being ignored: \( response.info)") else if let error = error { print("encountered Error sending SubscribeVehicleData: \(error)") return // Successfully subscribed

131 Finally, react to notification when Vehicle Data is received: OBJECTIVE-C - (void)vehicledataavailable:(sdlrpcnotificationnotification *)notification { if (![notification.notification iskindofclass: SDLOnVehicleData.class]) { return; SDLOnVehicleData *onvehicledata = (SDLOnVehicleData *) notification.notification; SDLPRNDL *prndl = onvehicledata.prndl; SWIFT func vehicledataavailable(_ notification: SDLRPCNotificationNotification) { guard let onvehicledata = notification.notification as? SDLOnVehicleData else { return let prndl = onvehicledata.prndl

132 Unsubscribing from Vehicle Data Sometimes you may not always need all of the vehicle data you are listening to. We suggest that you only are subscribing when the vehicle data is needed.

133 To stop listening to specific vehicle data items, utilize SDLUnsubscribeVehicleData.

134 OBJECTIVE-C

135 SDLUnsubscribeVehicleData *unsubscribevehicledata = [[ SDLUnsubscribeVehicleData alloc] init]; unsubscribevehicledata.prndl [self.sdlmanager sendrequest:unsubscribevehicledata withresponsehandler:^( kindof SDLRPCRequest * _Nullable request, kindof SDLRPCResponse * _Nullable response, NSError * _Nullable error) { if (![response iskindofclass:[ SDLUnsubscribeVehicleDataResponse class]]) { return; if (!response.success.boolvalue) { SDLUnsubscribeVehicleDataResponse * unsubscribevehicledataresponse = ( SDLUnsubscribeVehicleDataResponse*)response; SDLVehicleDataResult *prndldata = unsubscribevehicledataresponse.prndl; if ([response.resultcode isequaltoenum:sdlresult. DISALLOWED]) { // Not allowed to register for this vehicle data, so unsubscribe also will not work. else if ([response.resultcode isequaltoenum: SDLResult.USER_DISALLOWED]) { // User disabled the ability to give you this vehicle data, so unsubscribe also will not work. else if ([response.resultcode isequaltoenum: SDLResult.IGNORED]) { if ([prndldata.resultcode isequaltoenum: SDLVehicleDataResultCode.DATA_NOT_SUBSCRIBED]) { // You have access to this data item, but it was never subscribed to so we ignored it. else { NSLog(@"Unknown reason for being ignored: prndldata.resultcode.value); else if (error) { NSLog(@"Encountered Error sending UnsubscribeVehicleData: %@", error); return; ]; // Successfully unsubscribed

136 SWIFT

137 let unsubscribevehicledata = SDLUnsubscribeVehicleData()! unsubscribevehicledata.prndl = true sdlmanager.send(unsubscribevehicledata) { (request, response, error) in guard let response = response as? SDLUnsubscribeVehicleDataResponse else { return guard response.success == true else { if response.resultcode.isequal(to: SDLResult. disallowed()) { else if response.resultcode.isequal(to: SDLResult. user_disallowed()) { else if response.resultcode.isequal(to: SDLResult. ignored()) { if let prndldata = response.prndl { if prndldata.resultcode.isequal(to: SDLVehicleDataResultCode.data_ALREADY_SUBSCRIBED()) { // You have access to this data item, and you are already unsubscribed to this item so we are ignoring. else if prndldata.resultcode.isequal(to: SDLVehicleDataResultCode.vehicle_DATA_NOT_AVAILABLE()) { // You have access to this data item, but the vehicle you are connected to does not provide it. else { print("unknown reason for being ignored: \(prndldata.resultcode.value)") else { print("unknown reason for being ignored: \( response.info)") else if let error = error { print("encountered Error sending UnsubscribeVehicleData: \(error)") return // Successfully unsubscribed

138 Getting In-Car Audio Capturing in-car audio allows developers to interact with users via raw audio data provided to them from the car's microphones. In order to gather the raw audio from the vehicle, we must leverage the SDLPerformAudioPassThru RPC. N O T E PerformAudioPassThru does not support automatic speech cancellation detection, so if this feature is desired, it is up to the developer to implement. Starting Audio Capture To initiate audio capture, we must construct an SDLPerformAudioPassThru object. The properties we will set in this object's constructor relate to how we wish to gather the audio data from the vehicle we are connected to.

139 OBJECTIVE-C SDLPerformAudioPassThru *audiopassthru = [[ SDLPerformAudioPassThru alloc] initwithinitialprompt:@"talk to me." audiopassthrudisplaytext1:@"ask me \"What's the weather?\"" audiopassthrudisplaytext2:@"or \"What is 1 + 2? \"" samplingrate:sdlsamplingrate._16khz bitspersample: SDLBitsPerSample._16_BIT audiotype:sdlaudiotype.pcm maxduration: muteaudio:yes]; [self.sdlmanager sendrequest:audiopassthru]; SWIFT let audiopassthru = SDLPerformAudioPassThru(initialPrompt: "Talk to me.", audiopassthrudisplaytext1: "Ask me \"What's the weather?\"", audiopassthrudisplaytext2: "or \"What is 1 + 2?\"", samplingrate:._16khz(), bitspersample:._8_bit(), audiotype:.pcm(), maxduration: , muteaudio: true)! sdlmanager.send(audiopassthru)

140 FORD HMI In order to know the currently supported audio capture capabilities of the connected head unit, please refer to the SDLRegisterAppInterfaceResponse, which contains a property audiopassthrucapabilities. N O T E Currently, Ford's SYNC 3 vehicles only support Sampling Rates of 16 khz and Bit Rates of 16 bit. Gathering Audio Data SDL provides audio data as fast as it can gather it, and sends it to the developer in chunks. In order to retrieve this audio data, the developer must: