Overview

The In-App Messaging module offers both one-way and two-way messaging capabilities for your app.

Classes

Protocols

Enumerations

InAppMessagingProvider   

InAppMessagingProvider is a class that provides a singleton instance of InAppMessaging. This class includes a static instance property that returns a single instance of InAppMessaging. 

Properties:

DefaultMessageStore

The DefaultMessageStore class provides a default implementation of the MessageStore protocol. This class manages the storage, retrieval, and deletion of InAppMessage and InAppThread instances.

Methods

init(password:)

This method initializes the DefaultMessageStore with given password.

Syntax: init(password: String)

Parameters

Sample Code

let messageStore = DefaultMessageStore(password: "DefaultMessageStore") 
InAppMessagingProvider.instance.messageStore = messageStore 

InAppMessagingProvider *inApp = [InAppMessagingProvider instance]; 
DefaultMessageStore *messageStore = [[DefaultMessageStore alloc] initWithPassword:@"DefaultMessageStore"]; 
[inApp setMessageStore:messageStore]; 

deleteAll()

This method deletes complete InAppThreads & InAppMessages.

Syntax: func deleteAll() -> Bool

Return Value: Returns true if deletion completes, false otherwise.

Sample Code

let hasDeleted = InAppMessagingProvider.instance.messageStore?.deleteAll()

BOOL hasDeleted = [[InAppMessagingProvider instance].messageStore deleteAll];

deleteMessage(withTransactionId:)

This method deletes single InAppMessage from local storage based on transactionId.

Syntax: func deleteMessage(withTransactionId transactionId: String) -> Bool

Return Value: Returns true if delete message completes, false otherwise.

Parameters

Sample Code

let hasDeleted = InAppMessagingProvider.instance.messageStore?.deleteMessage(withTransactionId: "transactionid")

BOOL hasDeleted = \[[InAppMessagingProvider instance].messageStore deleteMessageWithTransactionId:@"transactionid"];

deleteThread(withThreadId:)

This method allows us to delete single InAppThread from local storage based on threadId

Syntax: func deleteThread(withThreadId threadId: String) -> Bool

Return Value: Returns true if delete thread completes, false otherwise.

Parameters

Sample Code

let hasDeleted = InAppMessagingProvider.instance.messageStore?.deleteThread(withThreadId: "threadid")

BOOL hasDeleted = [[InAppMessagingProvider instance].messageStore deleteThreadWithThreadId:@"threadid"];

getMessageCount(forThreadId:)

This method provides a count of messages from local storage based on threadId.

Syntax: func getMessageCount(forThreadId threadId: String) -> Int

Return Value: Returns count of messages.

Parameters

Sample Code

let count = InAppMessagingProvider.instance.messageStore?.getMessageCount(forThreadId: "threadid")

int count = [[InAppMessagingProvider instance].messageStore getMessageCountForThreadId:@"threadid"];

getThreadCount()

This method provides the total number of threads count from local storage.

Syntax: func getThreadCount() -> Int

Return Value: Returns count of threads.

Sample Code

let count = InAppMessagingProvider.instance.messageStore?.getThreadCount()

int count = [[InAppMessagingProvider instance].messageStore getThreadCount];

getUnreadMessageCount(forThreadId:)

This method provides a count of unread messages from local storage based on threadId.

Syntax: func getUnreadMessageCount(forThreadId threadId: String) -> Int

Return Value: Returns count of unread messages.

Parameters

Sample Code

let count = InAppMessagingProvider.instance.messageStore?.getUnreadMessageCount(forThreadId: "threadid")

int count = [[InAppMessagingProvider instance].messageStore getUnreadMessageCountForThreadId:@"threadid"];

getUnreadThreadCount()

This method gives the total number of threads containing unread messages.

Syntax: func getUnreadThreadCount() -> Int

Return Value: The number of threads containing unread messages.

Sample Code

let count = InAppMessagingProvider.instance.messageStore.getUnreadThreadCount()

int count = [[InAppMessagingProvider instance].messageStore getUnreadThreadCount];

loadMessage(withTransactionId: )

This method loads single InAppMessage from local storage based on transactionId.

Syntax: func loadMessage(withTransactionId transactionId: String) -> InAppMessage?

Return Value: Returns InAppMessage instance if message exists with transactionId.

Parameter

Sample Code

let inApp = InAppMessagingProvider.instance
let message = inApp.messageStore?.loadMessage(withTransactionId: "transactionid") 

InAppMessage *message = [[InAppMessagingProvider instance].messageStore loadMessageWithTransactionId:@"transactionid"];

loadMessages(withThreadId: submittedBefore: limit:)

This method loads messages from local storage for a specific thread, based on the date submittedBefore, with the specified limit.

Syntax: func loadMessages(withThreadId threadId: String, submittedBefore: Date, limit: Int) -> [InAppMessage]

Return Value: Array of InAppMessage instance if messages exists with threadId.

Parameter

Sample Code

let inApp = InAppMessagingProvider.instance
let submittedBefore = Date() 
let limit = 10
let messages = inApp.messageStore?.loadMessages(withThreadId: "threadid", submittedBefore: submittedBefore, limit: limit)

NSDate *submittedBefore = [NSDate new]; 
int limit = 10;
NSArray *messages = [[InAppMessagingProvider instance].messageStore loadMessagesWithThreadId:@"threadid" submittedBefore:submittedBefore limit:limit];

loadMessages(withThreadId:  submittedBefore:  submittedAfter: limit:)

This method loads messages from local storage for a specific thread, based on optional date parameters submittedBefore and submittedAfter, with the specified limit.

Syntax: func loadMessages(withThreadId threadId: String, submittedBefore: Date?, submittedAfter: Date?, limit: Int) -> [InAppMessage]

Return Value: Array of InAppMessage instance if messages exists with threadId.

Parameters

Sample Code

let submittedBefore = Date() // Provide your submitted Before date 
let submittedAfter = Date() // Provide your submitted After date 
let limit = 10 // provide your limit 
let messages = inApp.messageStore?.loadMessages(withThreadId: "threadid", submittedBefore: submittedBefore, submittedAfter: submittedAfter, 
limit: limit)

NSDate *submittedBefore = [NSDate new]; // Provide your submitted Before date 
NSDate *submittedAfter = [NSDate new]; // Provide your submitted After date 
int limit = 10; // provide your limit 
NSArray *messages = [[InAppMessagingProvider instance].messageStore loadMessagesWithThreadId:@"threadid" submittedBefore:submittedBefore submittedAfter:submittedAfter 
limit:limit];

loadThread(withThreadId:)

This method loads a specific InAppThread from local storage based on the provided threadId.

Syntax: func loadThread(withThreadId threadId: String) -> InAppThread?

Return Value: Returns  InAppThread instance if thread exists with threadId.

Parameters

Sample Code

let inApp = InAppMessagingProvider.instance 
let thread = inApp.messageStore?.loadThread(withThreadId: "threadid")

InAppThread *thread = [[InAppMessagingProvider instance].messageStore loadThreadWithThreadId:"threadid"];

loadThreads(updatedBefore: limit:)

This method Loads InAppThreads from local storage based date updatedBefore with the specific limit.

Syntax: func loadThreads(updatedBefore: Date, limit: Int) -> [InAppThread]

 Return Value: Returns array of InAppThread instances, if threads exists before updated date with limit.

Parameters

Sample Code

let inApp = InAppMessagingProvider.instance
let updatedBefore = Date()  
let limit = 10
let threads = inApp.messageStore?.loadThreads(updatedBefore: updatedBefore, limit: limit)

NSDate *updatedBefore = [NSDate new]; // Provide your updated Before date 
int limit = 10; // provide your limit 
NSArray *threads = [[InAppMessagingProvider instance].messageStore loadThreadsWithUpdatedBefore:updatedBefore limit:limit];

loadThreads(updatedBefore:  updatedAfter:  limit:)

This method loads InAppThreads from local storage based on the dates updatedBefore and updatedAfter, with the specified limit.

Syntax: func loadThreads(updatedBefore: Date, updatedAfter: Date, limit: Int) -> [InAppThread]

Return Value: Returns array of InAppThread instances, if threads exists between before & after updated date with limit.

Parameters

Sample Code

let updatedBefore = Date() // Provide your updated Before date 
let updatedAfter = Date() // Provide your updated After date 
let limit = 10 // provide your limit 
let threads = inApp.messageStore?.loadThreads(updatedBefore: updatedBefore, updatedAfter: updatedAfter, limit: limit)

NSDate *updatedBefore = [NSDate new]; // Provide your updated Before date 
NSDate *updatedAfter = [NSDate new]; // Provide your updated After date 
int limit = 10; // provide your limit 
NSArray *threads = [[InAppMessagingProvider instance].messageStore loadThreadsWithUpdatedBefore:updatedBefore updatedAfter:updatedAfter limit:limit];

loadUnreadThreads(limit:)

This method loads some InAppThread instance containing at least one unread message from local storage with specific limit.

Syntax: func loadUnreadThreads(limit: Int) -> [InAppThread]

Return Value: An array of InAppThread instances with some unread messages.

Parameters

Sample Code

let limit = 10 // provide your limit 
let threads = inApp.messageStore?.loadUnreadThreads(limit: limit)

int limit = 10; // provide your limit 
NSArray *threads = [[InAppMessagingProvider instance].messageStore loadUnreadThreadsWithLimit:limit];

saveMessages()

This method saves multiple InAppMessages.

Syntax: func saveMessages(_ messages: [InAppMessage]) -> Bool

Return Value: Returns true if message storage completes, false otherwise.

Parameters

Sample Code

let messages: [InAppMessage] = [] // provide ur InAppMessages 
let hasSaved = inApp.messageStore?.saveMessages(messages)

NSArray *messages = @\[]; // Provide your messages 
BOOL hasSaved = [[InAppMessagingProvider instance].messageStore saveMessages:messages]; 
Remove this function from the documentation

saveThreads()

This method saves multiple InAppThreads.

Syntax: func saveThreads(_ threads: [InAppThread]) -> Bool

Return value: Return true if thread storage completes, false otherwise.

Parameters

Sample Code

let threads: [InAppThread] = [] // provide ur InAppThreads 
let hasSaved = inApp.messageStore?.saveThreads(threads)

NSArray \*threads = @\[]; // Provide your threads 
BOOL hasSaved = \[[InAppMessagingProvider instance].messageStore saveThreads:threads];

InAppAttachment

A class that represents an attachment in an in-app message, such as an image, video, audio, location or template. 

Properties

The InAppAttachment class is inherited by the following subclasses: 

InAppAudioAttachment 

A class that represents an audio attachment within an inapp message. 

Properties

The InAppAudioAttachment class is inherited from the following superclass:

Methods

init() 

Initializes a InAppAudioAttachment. 

Syntax init()

InAppButton 

This class represents a button in an in-app message.  This class exposes the data related to interactive button in quick replies and generic templates.

Properties

InAppFormField

A class that represents a form field within an in-app form. 

Properties

InAppFormTemplateAttachment 

A class that represents a template attachment specific to a form in an in-app message. 

Properties

  The InAppFormTemplateAttachment class is inherited from the following superclass:

InAppGenericTemplateAttachment 

A class that represents a specific type of template attachment for a generic template in an in-app message. 

Properties

The InAppGenericTemplateAttachment class is inherited by the following subclass: 

InAppGenericTemplateElement 

Represents an element of a generic template. 

Properties

The InAppGenericTemplateAttachment class is inherited from the following superclass:

InAppImageAttachment

A class that represents an image attachment within an in-app message.

Properties

The InAppImageAttachment class is inherited from the following superclass:

Methods

Syntax: init()
Initializes a InAppImageAttachment. 

InAppInteractiveData 

This class exposes the data related to the form response submitted by users.

Properties

Methods 

init() 

Initializes a InAppInteractiveData.

Syntax: init() 

InAppLocationAttachment 

Represents location data that may be attached to a message. Location data is comprised of latitude and longitude.

Properties

The InAppLocationAttachment class is inherited from the following superclass:

Methods 

init() 

Initializes a InAppLocationAttachment.

Syntax: init() 

InAppMediaAttachment 

Base class for message attachments which exposes data common to all types of the media files.

Properties

The InAppMediaAttachment class is inherited by the following subclass: 

Methods 

init() 

Initializes a InAppMediaAttachment.

Syntax: init()

InAppMessage 

Represents a message in the WebexConnect platform. 

Properties

Methods 

init() 

Initializes an empty instance of InAppMessage.

Syntax: init() 

InAppQuickReply

Represents quick reply data attached to an in-app message. 

Properties

InAppTemplateAttachment 

A class that represents an attachment specific to a template in an in-app message. 

Properties

The InAppTemplateAttachment class is inherited from the following superclass:

InAppThread

Represents a conversation or announcement thread.

Properties

Methods 

init() 

Initializes an empty instance of InAppThread.

Syntax: init()

InAppVideoAttachment

 A class that represents a video attachment within an in-app message. 

Properties

The InAppVideoAttachment class is inherited from the following superclass:

Methods 

init() 

Initializes an instance of  InAppVideoAttachment.

Syntax: init()

MessageSynchronizationPolicy 

Class representing the policy for message synchronization. This policy determines how messages are synchronized based on the mode, and limits the number of threads and messages per thread that are synchronized. 

Methods

init(mode: maxThreads: maxMessagesPerThread)

Instantiates a new Synchronization policy.

Syntax:init(mode: MessageSynchronizationMode, maxThreads: Int, maxMessagesPerThread: Int)

Properties: 

InAppMessaging 

A protocol that defines the requirements for in-app messaging functionalities.

Properties

Methods  

connect()

Once the In-App Message feature is enabled in the app asset created on Webex Connect and user registration is done, the App Developer can establish a connection between the app and Webex Connect platform by calling the connect method appropriately. This enables the messages sent from Webex Connect to be received on the app. When the application is running in the background, SDK is disconnected from Webex Connect. While in the disconnected state, incoming In-App Messages are not received, however when the application comes to foreground again, SDK will establish a connection with the Webex Connect platform and allow messages to be received.

The connect method is used to establish a connection to receive In-App Messages from the Webex Connect platform. When the connection is successful, the status events are notified through InAppMessagingDelegate didChangeConnectionStatus.

It throws an error as defined if the user is not currently registered to the Webex Connect or if In-App Messaging feature is not enabled in the policy.

Syntax func connect() throws 

 Throws An error if the connection cannot be established. 

Sample Code

func connect() throws {    
var inApp = InAppMessagingProvider.instance    
try inApp.connect(
} 

(void)connect:(NSError **)error {  
id<InAppMessaging> inApp = [InAppMessagingProvider instance];  
[inApp connect:error];  
} 

createPostbackMessage(with:button:)

Creates an instance of an InAppMessage based on InAppButton and Thread 

Syntax: func createPostbackMessage(with message: InAppMessage, button: InAppButton) -> InAppMessage 

Return Value An instance of InAppMessage 

Parameters  

 Sample Code

let inApp = InAppMessagingProvider.instance
let message = InAppMessage()
let button = InAppButton()
let postBackMessage = inApp.createPostbackMessage(with message: message, button: button)

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
InAppMessage *message = [[InAppMessage alloc] init]    
InAppButton *button = [[InAppButton alloc] init]    
InAppMessage *postBackMessage = [inApp createPostbackMessageWith message:message, button: button];  

createThread(_: completionHandler:) 

This method creates a new thread on the messaging service. 

Syntax func createThread(_ thread: InAppThread, completionHandler: @escaping (InAppThread?, Error?) -> Void) 
Parameters  

Sample Code 

let inApp = InAppMessagingProvider.instance
inApp.createThread(thread) { createdThread, error in
  //Handle Error
}

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
[inApp createThread:thread completion:^(InAppThread _createdThread, NSError *error) {    
if (error) {    
   NSLog(@"Error creating thread: %@", error.localizedDescription);    
} else {    
   NSLog(@"Successfully created thread: %@", createdThread);
}    
}]; 

deleteMessage(withTransactionId: completionHandler: ) 

This method is used to deletes a message with the specified transactionId from the messaging service.

Syntax:func deleteMessage(withTransactionId tid: String, completionHandler: @escaping (Error?) -> Void) 

Parameters  

 Sample Code 

let inApp = InAppMessagingProvider.instance  
inApp.deleteMessage(withTransactionId tid: "transaction_id") { error in
} 

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
[inApp deleteMessageWithTransactionId:"transactionid" completion:^(NSError *error) {    
   if (error) {    
       // Handle error    
       NSLog(@"Error deleting message: %@", error.localizedDescription);    
  } else {    
       // Handle success    
       NSLog(@"Message deleted successfully");    
   }    
}]; 

disconnect() 

This method is used to disconnect the connection between the app and the Webex Connect platform. If there is no active connection, then this method fails silently. When the disconnection is successful, the status events are notified through InAppMessagingDelegate didChangeConnectionStatus.

It throws an error as defined if the user is not currently registered with Webex Connect or if In-App Messaging feature is not enabled in the policy.

Syntax: func disconnect() throws 

Throws:  An error if the disconnection fails. 

Sample Code

func disconnect() throws {
  let inApp = InAppMessagingProvider.instance
  try inApp.disconnect()
}

-(void)disconnect:(NSError **error) {    
id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
 [inApp disconnect:error];    
}

fetchMessages(forThreadId: beforeDate: limit: completionHandler:) 

This method fetches messages for a specific thread that are submitted before a given date, with a specified limit, and executes a completion handler upon completion.

Syntax:  func fetchMessages(forThreadId threadId: String, beforeDate: Date, limit: Int, completionHandler: @escaping ([InAppMessage], Bool, Error?) -> Void) 

 Parameters  

Sample Code

let inApp = InAppMessagingProvider.instance
inApp.fetchMessages(forThreadId threadId: "thread_id", beforeDate: Date(), limit: 10) { messages, hasMore, error in
                                                                                      }

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
[inApp fetchMessagesForThreadId:@ "thread_id", beforeDate: beforeDate, limit:10 completion:^(NSArray *messages, BOOL hasMore, NSError *error) {
}]; 

fetchThread(forThreadId: completionHandler:)

This method fetches a specific thread based on the provided thread ID and executes a completion handler upon completion.

 Syntax func fetchThread(forThreadId threadID: String, completionHandler: @escaping (InAppThread?, Error?) -> Void)

 Parameters  

Sample Code

let inApp = InAppMessagingProvider.instance
inApp.fetchThread(forThreadId: "thread_id") { (thread, error) in
  //Handle response
}

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
[inApp fetchThreadForThreadId:@"thread_id" completionHandler:^(InAppThread *thread, NSError *error) {    
//Handle response 
}]; 

fetchThreads(beforeDate:  limit: category: completionHandler:) 

This method fetches a list of threads that were updated before a given date, with a specified limit, optionally filtered by category, and executes a completion handler upon completion.

Syntax func fetchThreads(beforeDate: Date, limit: Int, category: String?, completionHandler: @escaping ([InAppThread], Bool, Error?) -> Void) 

Parameters  

 Sample Code

let inApp = InAppMessagingProvider.instance
inApp.fetchThreads(beforeDate: Date(), limit: 10, category: nil) { threads, hasMore, error in
  //Handle Response
}

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
NSDate _beforeDate = [NSDate date];    
[inApp fetchThreadsBeforeDate:beforeDate limit:10 category:nil  completionHandler:^(NSArray *threads, BOOL hasMore, NSError *error) {    
//Handle response 
}]; 

fetchThreads(beforeDate: limit:  category: threadType: completionHandler:)

This method fetches a list of threads that were updated before a given date, with a specified limit, optionally filtered by category and thread type, and executes a completion handler upon completion.

Syntax: func fetchThreads(beforeDate: Date, limit: Int, category: String?, threadType: InAppThreadType, completionHandler: @escaping ([InAppThread], Bool, Error?) -> Void)

Parameters  

Sample Code

let inApp = InAppMessagingProvider.instance
inApp.fetchThreads(beforeDate: Date(), limit: 10, category: nil, threadType: .conversation) {
  threads, hasMore, error in
  //Handle response
}

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
NSDate _*beforeDate = [NSDate date];    
[inApp fetchThreadsBeforeDate:beforeDate limit:10 category:nil threadType:InAppThreadTypeConversation completion:^(NSArray *threads, BOOL hasMore, NSError *error) {  
//Handle response   
  }]; 

fetchUnreadThreadCount(completionHandler: )

This method fetches the count of unread threads from the messaging service.

Syntax func fetchUnreadThreadCount(completionHandler: @escaping (Int, Error?) -> Void) 

Parameters  

 Sample Code

let inApp = InAppMessagingProvider.instance
inApp.fetchUnreadThreadCount { count, error in
  //Handle response
}

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
[inApp fetchUnreadThreadCountWithCompletionHandler:^(NSInteger count, NSError _error) {    
//Handle response 
}]; 

publishMessage(_:  completionHandler:) 

This method publishes a message to the messaging service.

 Syntax:func publishMessage(_ message: InAppMessage, completionHandler: @escaping (Error?) -> Void) 

Parameters  

 Sample Code

let inApp = InAppMessagingProvider.instance
let message = InAppMessage()
inApp.publishMessage(message) { error in
  //Handle error
}

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
InAppMessage *message = [[InAppMessage alloc] init];    
  [inApp publishMessage:message  completionHandler:^(NSError *error) {    
     if (error) {    
         // Handle error    
         NSLog(@"Error publishing message: %@", error.localizedDescription);    
    } else {    
         // Handle success    
         NSLog(@"Message published successfully");    
     }    
  }]; 

publishTypingIndicator(on: typing: ) 

This method publishes a typing indicator information on a thread.

 Syntax func publishTypingIndicator(on thread: InAppThread, typing: Bool) 

 Parameters 

 Sample Code

let inApp = InAppMessagingProvider.instance  
let thread = InAppThread()
inApp.publishTypingIndicator(on: thread, typing: true) 

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
InAppThread _*thread = [[InAppThread alloc] init]    
[inApp publishTypingIndicatorOn: thread typing: YES]; 

sendMessageStatus(for:  status: button: completionHandler:) 

This method sends message status updates for multiple messages to the messaging service. 

Syntax:func sendMessageStatus(for transactionId: String, status: InAppMessageStatus, button: InAppButton?, completionHandler: @escaping (Error?) -> Void) 

 Parameters 

 Sample Code

let inApp = InAppMessagingProvider.instance  
let transactionId = "transId1"    
let inAppButton = InAppButton()    
inApp.sendMessageStatus(for: transactionId, status: .delivered, button: inAppButton) { error in
//Handle error 
} 

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
NSString *transactionId = @"transId1"; 
    InAppMessageStatus status = InAppMessageStatusDelivered; 
    [inApp sendMessageStatusFor:transactionId status:status button:nil completionHandler:^(NSError *error) { 
       if (error) { 
           NSLog(@"Error sending message status: %@", error.localizedDescription); 
       } else { 
           NSLog(@"Message status sent successfully"); 
       } 
    }]; 

sendMessageStatus(for:  status:  completionHandler: )

This methods sends message status updates for multiple messages to the messaging service.

Syntaxfunc sendMessageStatus(for transactionIds: [String], status: InAppMessageStatus, completionHandler: @escaping (Error?) -> Void) 

Parameters  

Sample Code

let inApp = InAppMessagingProvider.instance  
let transactionIds = ["transId1", "transId2"]    
inApp.sendMessageStatus(for: transactionIds, status: .delivered, button: nil) { error in  
//Handle error   
} 

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
NSArray *transactionIds = @[@"transId1", @"transId2"]; 
    InAppMessageStatus status = InAppMessageStatusDelivered; 
    [inApp sendMessageStatusFor:transactionIds status:status completionHandler:^(NSError *error) { 
       if (error) { 
           NSLog(@"Error sending message status: %@", error.localizedDescription); 
       } else { 
           NSLog(@"Message status sent successfully"); 
       } 
    }]; 

updateThread(_, completionHandler:) 

This method updates an existing thread on the messaging service. 

 Syntax func updateThread(_ thread: InAppThread, completionHandler: @escaping (InAppThread?, Error?) -> Void) 

 Parameter

 Sample Code

let inApp = InAppMessagingProvider.instance  
inApp.updateThread(thread) { updatedThread, error in    
//Handle Error 
} 

id<InAppMessaging> inApp = [InAppMessagingProvider instance]; 
[inApp updateThread:[[InAppThread alloc] init] completionHandler:^(InAppThread *updatedThread, NSError *error) { 
    if (error) { 
       NSLog(@"Error updated thread: %@", error.localizedDescription); 
    } else { 
       NSLog(@"Successfully updated thread: %@", updatedThread); 
    } 
    }]; 

InAppMessagingDelegate

This protocol allows the interception of incoming messages and In-App Messaging connection status changes.

Methods

DidReceiveInAppMessage()

This method will be Invoked whenever a new InApp message is received and after processing the message internally.

Syntax: func didReceiveInAppMessage(_ message: InAppMessage)

Parameter:

Sample Code

func didReceiveInAppMessage(_ message: InAppMessage) {
  print("Received Message: \(message.description)")
}

- (void)didReceiveInAppMessage:(InAppMessage *)message {
  NSLog(@"Received Message:%@", [message description]);
}

didChangeConnectionStatus()

This method will be Invoked whenever there is a change to the In-App Messaging connection status.

Syntax: func didChangeConnectionStatus(_ connectionStatus: ConnectionStatus)

Parameter:

Sample Code

func didChangeConnectionStatus(_ connectionStatus: ConnectionStatus) {
  let logMessage = "InApp didChangeConnectionStatus: \(connectionStatus.rawValue)"
  print(logMessage)
}

(void)didChangeConnectionStatus : (ConnectionStatus)connectionStatus {
  switch (connectionStatus) {
    case ConnectionStatusConnected:
      NSLog(@ "Connected");
      break;
    case ConnectionStatusConnecting:
      NSLog(@ "Connecting");
      break;
    case ConnectionStatusNone:
    case ConnectionStatusError:
    case ConnectionStatusClosed:
    case ConnectionStatusRefused:
    default:
      NSLog(@ "Not Connected");
      break;
  }
}

MediaFileManager

Methods:

upload(fileURL: , progressHandler: , completionHandler: )

Uploads a file from a URL.

Syntax:func upload(fileURL: URL, progressHandler: ((Double) -> Void)?, completionHandler: ((String?, Error?) -> Void)?)

Parameter:

Sample Code

let mediaFileManager = InAppMessagingProvider.instance.mediaFileManager
mediaFileManager.upload(
  fileURL: localFileURL,
  progressHandler: { progress in
    print("Upload progress: \(progress)")
  },
  completionHandler: { mediaId, error in
    if let error = error {
      print("Upload failed: \(error)")
    } else if let mediaId = mediaId {
      print("File uploaded successfully. Media ID: \(mediaId)")
    }
  })

MediaFileManager *mediaFileManager =
    [InAppMessagingProvider instance].mediaFileManager;
[mediaFileManager uploadFileURL:localFileURL
    progressHandler:^(double progress) {
      NSLog(@"Upload progress: %f", progress);
    }
    completionHandler:^(NSString *mediaId, NSError *error) {
      if (error) {
        NSLog(@"Upload failed: %@", error);
      } else {
        NSLog(@"File uploaded successfully. Media ID: %@", mediaId);
      }
    }];

isFileUploading(from :)

Checks if the manager is currently uploading a file from a local URL.

Syntax: func isFileUploading(from location: URL) -> Bool

Returns: true if the file is currently being uploaded.

Parameter:

Sample Code

let mediaFileManager = InAppMessagingProvider.instance.mediaFileManager
let localFileURL = // Provide ur local file url
let isUploading = mediaFileManager.isFileUploading(from: localFileURL)

MediaFileManager *mediaFileManager = [InAppMessagingProvider instance].mediaFileManager;
NSURL *localFileURL =  // Provide your local file url
BOOL isUploading = [mediaFileManager isFileUploadingFromLocation:localFileURL];

downloadFile(at : progressHandler: completionHandler:)

This method downloads a file from a URL.

Syntax: func downloadFile(at url: URL, progressHandler: ((Double) -> Void)?, completionHandler: @escaping ((URL?, Error?) -> Void))

Parameter:

Sample Code

let mediaFileManager = InAppMessagingProvider.instance.mediaFileManager
let remoteFileURL =  // Provide ur remote file url
  mediaFileManager.downloadFile(
    at: remoteFileURL,
    progressHandler: { progress in
      print("Download progress: \(progress)")
    },
    completionHandler: { localFileURL, error in
      if let error = error {
        print("Download failed: \(error)")
      } else if let localFileURL = localFileURL {
        print("File downloaded to: \(localFileURL)")
      }
    })

MediaFileManager *mediaFileManager =
    [InAppMessagingProvider instance].mediaFileManager;
NSURL *remoteFileURL =  // Provide your remotefile url
    [mediaFileManager downloadFileAtURL:remoteFileURL
        progressHandler:^(double progress) {
          NSLog(@"Download progress: %f", progress);
        }
        completionHandler:^(NSURL *localFileURL, NSError *error) {
          if (error) {
            NSLog(@"Download failed: %@", error);
          } else {
            NSLog(@"File downloaded to: %@", localFileURL);
          }
        }];

isFileDownloading(from :)

Checks if the manager is currently downloading a file at a URL.

Syntax: func isFileDownloading(from location: URL) -> Bool

Returns: true if the file is currently being downloaded.

Parameter:

Sample Code

let mediaFileManager = InAppMessagingProvider.instance.mediaFileManager
let remoteFileURL = // Provide ur remote file url
let isDownloading = mediaFileManager.isFileDownloading(from: remoteFileURL)

MediaFileManager *mediaFileManager =
    [InAppMessagingProvider instance].mediaFileManager;
NSURL *remoteFileURL =  // Provide your local file url
    BOOL isDownloading =
        [mediaFileManager isFileDownloadingFromLocation:remoteFileURL];

getCachedFileUrl(for :)

Retrieves the filePath where the content of the file at the passed URL is stored.

Syntax: func getCachedFileUrl(for url: URL) -> URL?

Returns: The filePath where the content is locally located.

Parameter:

Sample Code

let mediaFileManager = InAppMessagingProvider.instance.mediaFileManager
let remoteFileURL = //Provide ur remote file url
let isDownloading = mediaFileManager.isFileDownloading(from: remoteFileURL)

MediaFileManager *mediaFileManager = [InAppMessagingProvider instance].mediaFileManager;
NSURL *remoteFileURL =  // Provide your local file url
BOOL isDownloading = [mediaFileManager isFileDownloadingFromLocation:remoteFileURL];

regenerateMediaURL(_ url: completionHandler:)

Regenerates new media URL for given URL upon checking expiry.

Syntax: func regenerateMediaURL(_ url: URL, completionHandler: @escaping (URL?, Error?) -> Void)

Parameter:

Sample Code

let mediaFileManager = InAppMessagingProvider.instance.mediaFileManager
let remoteFileURL =  // Provide ur remote file url
  mediaFileManager.regenerateMediaURL(remoteFileURL) { newURL, error in
    if let error = error {
      print("Failed to regenerate media URL: \(error)")
    } else if let newURL = newURL {
      print("New media URL: \(newURL)")
    }
  }

MediaFileManager *mediaFileManager = [InAppMessagingProvider instance].mediaFileManager;
NSURL *remoteFileURL =  // Provide your local file url
    [mediaFileManager regenerateMediaURL:remoteFileURL
                       completionHandler:^(NSURL *newURL, NSError *error) {
                         if (error) {
                           NSLog(@"Failed to regenerate media URL: %@", error);
                         } else {
                           NSLog(@"New media URL: %@", newURL);
                         }
                       }];

Enumerations

ConnectionStatus

This enumeration describes different connection status between the SDK and the In-App Messaging server.

InAppFormFieldType

This enumeration describes the supported Form Fields.

InAppInteractiveDataType

This enumeration describes the Interactive data type for message.

InAppMessageStatus

This enumeration describes different status of a message.

InAppMessageType

This enumeration describes the InApp message types.

InAppTemplateType

This enumeration describes the supported InApp Template Types.

InAppThreadStatus

This enumeration describes the different status of a InApp thread.

InAppThreadType

This enumeration describes the type of a thread.

MessageSynchronizationMode

This enumeration describes the synchronization mode for messages.