Using App Services (RPC v5.1+)

id subscribedObserver = [self.sdlManager.systemCapabilityManager subscribeToCapabilityType:SDLSystemCapabilityTypeAppServices withUpdateHandler:^(SDLSystemCapability * _Nullable capability, BOOL subscribed, NSError * _Nullable error) {
    NSArray<SDLAppServiceCapability *> *appServices = capability.appServicesCapabilities.appServices;
    <#Use the app services records#>
}];

let subscribedObserver = sdlManager.systemCapabilityManager.subscribe(capabilityType: .appServices) { (capability, subscribed, error) in
    let appServices = capability?.appServicesCapabilities?.appServices
    <#Use the app services records#>
}

SDLAppServicesCapabilities *capabilities = systemCapabilityManager.appServicesCapabilities;

// This array contains all currently available app services on the system
NSArray<SDLAppServiceCapability *> *appServices = capabilities.appServices;
SDLAppServiceCapability *aCapability = appServices.firstObject;

// This will be nil since it's the first update
SDLServiceUpdateReason capabilityReason = aCapability.updateReason;

// The app service record will give you access to a service's generated id, which can be used to address the service directly (see below), it's manifest, used to see what data it supports, whether or not the service is published (it always will be here), and whether or not the service is the active service for its service type (only one service can be active for each type)
SDLAppServiceRecord *serviceRecord = aCapability.updatedAppServiceRecord;

// From OnSystemCapabilityUpdated
SDLOnSystemCapabilityUpdated *serviceNotification = <#From wherever you got it#>;
SDLAppServicesCapabilities *capabilities = serviceNotification.systemCapability.appServicesCapabilities;

// This array contains all recently updated services
NSArray<SDLAppServiceCapability *> *appServices = capabilities.appServices;
SDLAppServiceCapability *aCapability = appServices.firstObject;

// This won't be nil. It will tell you why a service is in the list of updates
SDLServiceUpdateReason capabilityReason = aCapability.updateReason;

// The app service record will give you access to a service's generated id, which can be used to address the service directly (see below), it's manifest, used to see what data it supports, whether or not the service is published (if it's not, it was just removed and should not be addressed), and whether or not the service is the active service for its service type (only one service can be active for each type)
SDLAppServiceRecord *serviceRecord = aCapability.updatedAppServiceRecord;

// This array contains all currently available app services on the system
guard let capabilities = systemCapabilityManager.appServicesCapabilities, let appServices = capabilities.appServices, let aCapability = appServices.first else {
    return
}

// This will be nil since it's the first update
let capabilityReason = aCapability.updateReason

// The app service record will give you access to a service's generated id, which can be used to address the service directly (see below), it's manifest, used to see what data it supports, whether or not the service is published (it always will be here), and whether or not the service is the active service for its service type (only one service can be active for each type)
let serviceRecord = aCapability.updatedAppServiceRecord

// From OnSystemCapabilityUpdated
let serviceNotification: SDLOnSystemCapabilityUpdated = <#From wherever you got it#>

// This array contains all recently updated services
guard let capabilities = serviceNotification.systemCapability.appServicesCapabilities, let appServices = capabilities.appServices, let aCapability = appServices.first  else {
    return
}

// This won't be nil. It will tell you why a service is in the list of updates
let capabilityReason = aCapability.updateReason

// The app service record will give you access to a service's generated id, which can be used to address the service directly (see below), it's manifest, used to see what data it supports, whether or not the service is published (if it's not, it was just removed and should not be addressed), and whether or not the service is the active service for its service type (only one service can be active for each type)
let serviceRecord = aCapability.updatedAppServiceRecord

// Get service data once
SDLGetAppServiceData *getServiceData = [[SDLGetAppServiceData alloc] initWithAppServiceType:SDLAppServiceTypeMedia];

// Subscribe to service data in perpetuity via `OnAppServiceData` notifications.
SDLGetAppServiceData *subscribeServiceData = [[SDLGetAppServiceData alloc] initAndSubscribeToAppServiceType:SDLAppServiceTypeMedia];

// Unsubscribe to service data previously subscribed
SDLGetAppServiceData *unsubscribeServiceData = [[SDLGetAppServiceData alloc] initWithAppServiceType:SDLAppServiceTypeMedia];
unsubscribeServiceData.subscribe = @NO;

// Get the service's data
[self.sdlManager sendRequest:getServiceData withResponseHandler:^(__kindof SDLRPCRequest * _Nullable request, __kindof SDLRPCResponse * _Nullable response, NSError * _Nullable error) {
    if (!response || !response.success.boolValue) {
        SDLLogE(@"Error sending get system capability: Req %@, Res %@, err %@", request, response, error);
        return;
    }

    SDLGetAppServiceDataResponse *serviceResponse = (SDLGetAppServiceDataResponse *)response;
    SDLMediaServiceData *mediaData = serviceResponse.serviceData.mediaServiceData;

    <#Use the mediaData#>
}];

// Subscribe to service data in perpetuity via `OnAppServiceData` notifications.
let subscribeServiceData = SDLGetAppServiceData(andSubscribeToAppServiceType: .media)

// Unsubscribe to service data previously subscribed
let unsubscribeServiceData = SDLGetAppServiceData(appServiceType: .media)
unsubscribeServiceData.subscribe = NSNumber(false)

// Get the service's data
let getServiceData = SDLGetAppServiceData(appServiceType: .media)
sdlManager.send(request: getServiceData) { (req, res, err) in
    guard let response = res as? SDLGetAppServiceDataResponse, response.success.boolValue == true, let mediaData = response.serviceData?.mediaServiceData else { return }

    <#Use the mediaData#>
}

SDLButtonPress *buttonPress = [[SDLButtonPress alloc] initWithButtonName:SDLButtonNameOk moduleType:SDLModuleTypeAudio moduleId:nil buttonPressMode:SDLButtonPressModeShort];
[self.sdlManager sendRequest:buttonPress withResponseHandler:^(__kindof SDLRPCRequest * _Nullable request, __kindof SDLRPCResponse * _Nullable response, NSError * _Nullable error) {
    if (!response || !response.success.boolValue) {
        SDLLogE(@"Error sending button press: Req %@, Res %@, err %@", request, response, error);
        return;
    }

    SDLButtonPressResponse *pressResponse = (SDLButtonPressResponse *)response;
    <#Use the response#>
}];

let buttonPress = SDLButtonPress(buttonName: .ok, moduleType: .audio, moduleId: nil, buttonPressMode: .short)
sdlManager.send(request: buttonPress) { (req, res, err) in
    guard let response = res as? SDLButtonPressResponse, response.success.boolValue == true else { return }

    <#Use the response#>
}

SDLPerformAppServiceInteraction *performAction = [[SDLPerformAppServiceInteraction alloc] initWithServiceUri:@"<#sdlexample://x-callback-url/showText?x-source=MyApp&text=My%20Custom%20String#>" serviceID:@"<#Previously Retrieved ServiceID#>" originApp:@"<#Your App Id#>" requestServiceActive:NO];
[self.sdlManager sendRequest:performAction withResponseHandler:^(__kindof SDLRPCRequest * _Nullable request, __kindof SDLRPCResponse * _Nullable response, NSError * _Nullable error) {
    if (!response || !response.success.boolValue) {
        SDLLogE(@"Error sending perform action: Req %@, Res %@, err %@", request, response, error);
        return;
    }

    SDLPerformAppServiceInteractionResponse *actionResponse = (SDLPerformAppServiceInteractionResponse *)response;
    <#Use the response#>
}];

let performAction = SDLPerformAppServiceInteraction(serviceUri: "<#sdlexample://x-callback-url/showText?x-source=MyApp&text=My%20Custom%20String#>", serviceID: "<#Previously Retrieved ServiceID#>", originApp: "<#Your App Id#>", requestServiceActive: false)
sdlManager.send(request: performAction) { (req, res, err) in
    guard let response = res as? SDLPerformAppServiceInteractionResponse else { return }
    <#Check the error and response#>
}

SDLAppServiceData *data = <#Get the App Service Data#>;
SDLWeatherServiceData *weatherData = data.weatherServiceData;
SDLImage *currentForecastImage = weatherData.currentForecast.weatherIcon;
NSString *currentForecastImageName = currentForecastImage.value;
SDLGetFile *getCurrentForecastImage = [[SDLGetFile alloc] initWithFileName:currentForecastImageName];

__block NSUInteger imageDataLength = 0;
__block NSUInteger imageDataLengthReceived = 0;
NSMutableData *imageData = [[NSMutableData alloc] init];
[self.sdlManager sendRequest:getCurrentForecastImage withResponseHandler:^(__kindof SDLRPCRequest * _Nullable request, __kindof SDLRPCResponse * _Nullable response, NSError * _Nullable error) {
    SDLGetFileResponse *getFileResponse = response;
    if (getFileResponse == nil || !response.success) {
        // Something went wrong, examine the resultCode and info
        return;
    }

    NSData *rpcImageData = response.bulkData;
    if (imageData == nil) {
        // There's no image data
        return;
    }

    [imageData appendData:rpcImageData];
    imageDataLengthReceived += rpcImageData.length;
    if (getFileResponse.offset == 0 && getFileResponse.length != nil) {
        imageDataLength = getFileResponse.length.unsignedIntegerValue;
    }

    if (imageDataLengthReceived < imageDataLength) {
        // Send additional GetFile requests to get the rest of the data using the offset parameter
    } else {
        // The file is complete, turn the file data into an image and use it.
    }
}];

let data: SDLAppServiceData = <#Get the App Service Data#>
let weatherData = data.weatherServiceData
guard let currentForecastImage = weatherData?.currentForecast?.weatherIcon else {
    // The image doesn't exist, exit early
    return
}
let currentForecastImageName = currentForecastImage.value
let getCurrentForecastImage = SDLGetFile(fileName: currentForecastImageName)

var imageDataLength = 0
var imageDataLengthReceived = 0
var imageData = Data()
sdlManager.send(request: getCurrentForecastImage) { (req, res, err) in
    guard let response = res as? SDLGetFileResponse, response.success.boolValue == true, let rpcImageData = response.bulkData else {
        // Something went wrong, examine the resultCode and info
        return;
    }

    imageData.append(rpcImageData)
    imageDataLengthReceived += rpcImageData.count
    if response.offset?.intValue == 0, let rpcImageLength = response.length?.intValue {
        imageDataLength = rpcImageLength
    }

    if imageDataLengthReceived < imageDataLength {
        // Send additional GetFile requests to get the rest of the data using the offset parameter
    }
}