SDK Reference

class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        let config = OptimoveConfigBuilder(
          optimoveCredentials: "<YOUR_OPTIMOVE_CREDENTIALS>", 
          optimobileCredentials: "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>")
            .build()

        Optimove.initialize(with: config)
    }
}

public class YourApplication extends Application {

  @Override
  public void onCreate() {
    super.onCreate();

    Optimove.initialize(this, new OptimoveConfig.Builder(
        "<YOUR_OPTIMOVE_CREDENTIALS>", 
        "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>"
    ).build());
  }
}


/********************** Environments **********************
If you are using staging and prod environments, you will receive 2 different sets of credentials. 
Consider using your BuildConfig file to declare them: */

buildTypes {
        release {
            ...
            buildConfigField "String", "OPTIMOVE_CREDENTIALS", '"<YOUR_OPTIMOVE_CREDENTIALS>"'
            buildConfigField "String", "OPTIMOVE_MOBILE_CREDENTIALS", '"<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>"'
        }
        stg {
            ...
            buildConfigField "String", "OPTIMOVE_CREDENTIALS", '"<YOUR_OPTIMOVE_STAGING_CREDENTIALS>"'
            buildConfigField "String", "OPTIMOVE_MOBILE_CREDENTIALS", '"<YOUR_OPTIMOVE_MOBILE_STAGING_CREDENTIALS>"'
        }
    }
    

// Then initialize Optimove using:

 Optimove.initialize(this, new OptimoveConfig.Builder(
        BuildConfig.OPTIMOVE_CREDENTIALS,
        BuildConfig.OPTIMOVE_MOBILE_CREDENTIALS
    ).build());

/********************** Android **********************

Add the initialization code to your Application extending class onCreate method (usually 
located in android/app/src/main/java/.../MainApplication.java): */

import com.optimove.android.OptimoveConfig;
import com.optimove.reactnative.OptimoveReactNativeConfig;
import com.optimove.reactnative.OptimoveReactNativeInitializer;


OptimoveReactNativeInitializer.initializeOptimove(
    OptimoveReactNativeConfig.newInstance()
                                .optimoveCredentials("<YOUR OPTIMOVE CREDENTIALS>")
                                .optimobileCredentials("<YOUR OPTIMOBILE CREDENTIALS>")
                                .deeplinkEnabled(boolean)
                                // OptimoveConfig.InAppConsentStrategy.EXPLICIT_BY_USER | OptimoveConfig.InAppConsentStrategy.AUTO_ENROLL
                                .enableInAppWithConsentStrategy(OptimoveConfig.InAppConsentStrategy)
                                // Optionally change the notification small icon - .setPushSmallIconId(getApplicationInfo().icon)
                                .build(), getApplicationContext());


/************************ iOS ************************

In your ios/AppDelegate application:didFinishLaunchingWithOptions method */

// For Objective-C: 

#import <OptimoveReactNative/OptimovReactNative-Bridging.h>
...
[OptimoveInitializer initialize:@"<YOUR OPTIMOVE CREDENTIALS>" optimobileCredentials:@"<YOUR OPTIMOBILE CREDENTIALS>" inAppConsentStrategy:@"auto-enroll|in-app-disabled|explicit-by-user" enableDeferredDeepLinking:BOOL];


// For Swift:

import OptimoveReactNative
...
OptimoveInitializer.initialize("<YOUR OPTIMOVE CREDENTIALS>", optimobileCredentials: "<YOUR OPTIMOBILE CREDENTIALS>", inAppConsentStrategy: "auto-enroll|in-app-disabled|explicit-by-user", enableDeferredDeepLinking: Bool)

// 1. Create an optimove.json file in your project's root directory with the following:
{
  "optimoveCredentials": "YOUR_OPTIMOVE_CREDENTIALS",
  "optimobileCredentials": "YOUR_OPTIMOVE_MOBILE_CREDENTIALS",
  "inAppConsentStrategy": "in-app-disabled|auto-enroll|explicit-by-user",
  "enableDeferredDeepLinking": false
}

// 2. Declare the asset in your pubspec.yaml:
assets:
  - optimove.json

// 3. In your Dart code, you can now import and use Optimove features:
import 'package:optimove_sdk_flutter/optimove.dart';

// 1. Create an optimove.json file in your project's root directory with the following content:
{
  "optimoveCredentials": "YOUR_OPTIMOVE_CREDENTIALS",
  "optimoveMobileCredentials": "YOUR_OPTIMOVE_MOBILE_CREDENTIALS",
  "inAppConsentStrategy": "in-app-disabled|auto-enroll|explicit-by-user",
  "enableDeferredDeepLinking": false
}

// 2. After you modify optimove.json, don't forget to run:
cordova prepare <platform>

// 3. Finally, if you are using TypeScript, please add the following to your tsconfig.json:
"files": ["./node_modules/@optimove-inc/cordova-sdk/index.d.ts"] 

/********************** Android **********************

Optimove Cordova SDK requires compileSdkVersion 31. Apps created with Cordova 11 by default 
depend on cordova-android@10.*, which sets the default compileSdkVersion to 30. If you are 
getting related errors, you can: */

// 1. Override compileSdkVersion in config.xml:

<platform name="android">
  <preference name="android-targetSdkVersion" value="31" />
</platform>

// 2. Upgrade the dependency:

cordova platform update [email protected]

/*  Please note that the default Android toolchains have moved to JDK11 now. 
You must use JDK11, at least if you change any of the Android API target versions to >=31.

### Other

(Optional) Optimove SDK includes Firebase Bill of Materials. You may override BoM 
version by adding build-extras.gradle to platforms/android/app with the following content: */

ext {
    // Optimove supports [19.0.0, 22.99.99] Firebase Messaging version range,
    // which corresponds to [20.0.0, 28.99.99] Bill of Materials version range.
    OptimoveFirebaseBoMVersion = "28.2.0"
}

/************************ iOS ************************

After you have added the plugin, run the following commands: */

   cd app/platforms/ios
   pod install
   cordova prepare ios

/* 
After first adding the iOS platform, you may need to open the project in 
Xcode and fix any errors if present.

************** Typescript / Javascript **************

In either case, you don't need to import anything from the plugin module. Types are 
available as ambient declarations. For example, in your www/js/index.js, you can 
use the global Optimove object like this: */

document.addEventListener('deviceready', function () {
    if (typeof Optimove === 'undefined') {
      console.info('Optimove plugin not found');
      return;
    }

    Optimove.setPushReceivedHandler(() => {});
}, false);

// Create Assets/OptimoveConfigFiles/optimove.json file with the following content:

  {
    "optimoveCredentials": "YOUR_OPTIMOVE_CREDENTIALS",
    "optimobileCredentials": "YOUR_OPTIMOVE_MOBILE_CREDENTIALS"
  }

/********************** Android **********************

In Player Settings verify the following (it should be set automatically):
- Custom gradle main template set to Plugins/Android/mainTemplate.gradle
- Custom gradle launcher template set to Plugins/Android/launcherTemplate.gradle
- Custom gradle base template set to Plugins/Android/baseProjectTemplate.gradle
- Custom main manifest set to Plugins/Android/AndroidManifest.xml
- For 2020.3+ make sure the custom gradle properties template is set to Plugins/Android/gradleTemplate.properties

************************ iOS ************************

1. Move Artifacts/OptimoveNativeAssets~ from the Artifacts folder to the Assets/ folder. 
The xcframeworks will be automatically added when the project is built.
2. Build the project. Verify that the New Build System in Xcode is enabled.

*********************** Usage ***********************

In your Unity code, you can now import and use Optimove features: */

using OptimoveSdk;

let config = OptimoveConfigBuilder(region: .US, features: [.optimove, .optimobile]).build()
Optimove.initialize(with: config)

// time passes...

Optimove.setCredentials(optimoveCredentials: "OPTIMOVE_TOKEN", optimobileCredentials: "OPTIMOBILE_TOKEN")

public class YourApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        OptimoveConfig.FeatureSet desiredFeatures = new OptimoveConfig.FeatureSet()
                .withOptimobile()
                .withOptimove();  

        Optimove.initialize(this, new OptimoveConfig.Builder(OptimoveConfig.Region.EU, desiredFeatures).build());
    }
}

// time passes...

Optimove.setCredentials( "<YOUR_OPTIMOVE_CREDENTIALS>", "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>");

// After credentials are set, all caches are flushed and the SDK starts behaving identical to 
the Standard Initialisation.

Feature isn't available in this SDK - contact your CSM.

Feature isn't available in this SDK - contact your CSM.

/* include the delayedInitialization block in your optimove.json file, 
setting "enable": true and specifying both the region and the featureSet.
In featureSet, you can control which services are initialized by setting 
enableOptimove and enableOptimobile to true or false as required. */


// Example configuration:
{
  "delayedInitialization": {
    "enable": true,
    "region": "DEV",
    "featureSet": {
      "enableOptimove": true,
      "enableOptimobile": false
    }
  }
}

Feature isn't available in this SDK - contact your CSM.

Optimove.shared.reportScreenVisit(
  screenTitle: "Account creation", // Represent the current scene
  screenCategory: "Accounts" // (Optional) Adds the scene category it belongs to
)

Optimove.getInstance()
    .reportScreenVisit(
    "Account creation", // Represent the current scene
    "Accounts" // (Optional) Adds the scene category it belongs to
    );

Optimove.reportScreenVisit(
  screenName: "Account creation", // Represent the current scene
  screenCategory: "Accounts" // (Optional) Adds the scene category it belongs to
);

Optimove.reportScreenVisit(
  screenName: "Account creation", // Represent the current scene
  screenCategory: "Accounts" // (Optional) Adds the scene category it belongs to
);

Optimove.reportScreenVisit(
  "Account creation", // Represent the current scene
  "Accounts" // (Optional) Adds the scene category it belongs to
);

Optimove.Shared.ReportScreenVisit(
  "Account creation", // Represent the current scene
  "Accounts" // (Optional) Adds the scene category it belongs to
);

Optimove.shared.setUserId("<MY_SDK_ID>")

Optimove.getInstance().setUserId("<YOUR_CUSTOMERS_SDK_ID>");

Optimove.setUserId("YOUR_CUSTOMERS_USER_ID");

Optimove.setUserId("YOUR_CUSTOMERS_USER_ID");

Optimove.setUserId("YOUR_CUSTOMERS_USER_ID");

Optimove.Shared.SetUserId("YOUR_CUSTOMERS_USER_ID");

Optimove.shared.registerUser(sdkId: "<MY_SDK_ID>", email: "<MY_EMAIL>")

Optimove.getInstance().registerUser("<YOUR_CUSTOMERS_SDK_ID>", "<YOUR_CUSTOMERS_EMAIL_ADDRESS>");

Optimove.registerUser("YOUR_CUSTOMERS_USER_ID", "YOUR_CUSTOMERS_EMAIL");

Optimove.registerUser("YOUR_CUSTOMERS_USER_ID", "YOUR_CUSTOMERS_EMAIL");

Optimove.registerUser("YOUR_CUSTOMERS_USER_ID", "YOUR_CUSTOMERS_EMAIL");

Optimove.Shared.RegisterUser("YOUR_CUSTOMERS_USER_ID", "YOUR_CUSTOMERS_EMAIL");

Optimove.shared.setUserEmail(email: "<MY_EMAIL>")

Optimove.getInstance().setUserEmail("<MY_EMAIL>");

Optimove.setUserEmail("YOUR_CUSTOMERS_EMAIL");

Optimove.setUserEmail("YOUR_CUSTOMERS_EMAIL");

Optimove.setUserEmail("YOUR_CUSTOMERS_EMAIL");

Optimove.Shared.SetUserEmail("YOUR_CUSTOMERS_EMAIL");

Optimove.shared.signOutUser()

Optimove.getInstance().signOutUser();

Optimove.signOutUser();

Optimove.signOutUser();

Optimove.signOutUser();

Optimove.Shared.SignOutUser();

Optimove.shared.reportEvent(
    name: "signup", // the exact event name configured by the Product Integration Team (PIT)
    parameters: [   // (optional)  dictionary of parameter names and values, also configured by PIT
        "first_name": "John",
        "last_name": "Doe",
        "email": "[email protected]",
        "age": 42,
        "opt_in": false
    ]
)

Map<String, Object> params = new HashMap<>();
params.put("first_name", "John");
params.put("last_name", "Doe");
params.put("email", "[email protected]");
params.put("age", 42);
params.put("opt_in", false);

Optimove.getInstance().reportEvent(
  "signup", // the exact event name configured by the Product Integration Team (PIT)
  params // (optional) dictionary of parameter names and values, also configured by PIT
);

const params : Record<string, any> = {
  "first_name": 'John',
  "last_name": 'Doe',
  "email": '[email protected]',
  "age": '42',
  "opt_in": 'false',
}
    
Optimove.reportEvent(
  'signup', // the exact event name configured by the Product Integration Team (PIT)
  params // (optional) dictionary of parameter names and values, also configured by PIT
);

const params : Record<string, any> = {
  "first_name": 'John',
  "last_name": 'Doe',
  "email": '[email protected]',
  "age": '42',
  "opt_in": 'false',
}
    
Optimove.reportEvent(
  'signup', // the exact event name configured by the Product Integration Team (PIT)
  params // (optional) dictionary of parameter names and values, also configured by PIT
);

const params : Record<string, any> = {
  "first_name": 'John',
  "last_name": 'Doe',
  "email": '[email protected]',
  "age": '42',
  "opt_in": 'false',
}
    
Optimove.reportEvent(
  'signup', // the exact event name configured by the Product Integration Team (PIT)
  params // (optional) dictionary of parameter names and values, also configured by PIT
);

Dictionary<string, object> parameters = new Dictionary<string, object>()
{
    {"key", "value"},
};
Optimove.Shared.ReportEvent("eventName", parameters);

/*
 The Optimove SDK defines a protocol called OptimoveEvent with two properties:

 name: String – Declares the custom event's name
 parameters: [String: Any] – Specifies the custom event's parameters.

 Use this protocol to conform your complex event objects to the Optimove format 
 and pass it to the SDK via the Optimove.shared.reportEvent(_ event: OptimoveEvent) method:
*/

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        Optimove.shared.reportEvent(PlacedOrderEvent(self.cartItems))
    }
}

class PlacedOrderEvent: OptimoveEvent {

    private let cartItems: [CartItem]

    init(_ items: [CartItem]) {
        self.cartItems = items
    }

    var name: String {
        return "placed_order"
    }

    var parameters: [String : Any] {
        var params: [String: Any] = [:]
        var totalPrice = 0.0
        for i in 0..<self.cartItems.count {
            let item = self.cartItems[i]
            params["item_name_\(i)"] = item.name
            params["item_price_\(i)"] = item.price
            params["item_image_\(i)"] = item.image
            totalPrice += item.price
        }
        params["total_price"] = totalPrice
        return params
    }
}

/*
 * The Optimove SDK defines an interface called OptimoveEvent in two methods:
 *
 * String getName() – Declares the custom event's name
 * Map<String, Object> getParameters() – Specifies the custom event's parameters
 *
 * Use this interface to conform your complex event objects to the Optimove format
 * and pass it to the SDK via the Optimove.getInstance().reportEvent(OptimoveEvent optimoveEvent) method:
 */

public class MainActivity extends AppCompatActivity {

  public void reportPlacedOrderEvent(List<CartItem> cartItems) {
    Optimove.getInstance().reportEvent(new PlacedOrderEvent(cartItems));
  }
}

class PlacedOrderEvent implements OptimoveEvent {

  private List<CartItem> cartItems;

  public PlacedOrderEvent(List<CartItem> cartItems) {
    this.cartItems = cartItems;
  }

  @Override
  public String getName() {
    return "placed_order";
  }

  @Override
  public Map<String, Object> getParameters() {
    Map<String, Object> params = new HashMap<>();
    int totalPrice = 0;
    for (int i = 1; i < this.cartItems.size(); i++) {
      CartItem item = this.cartItems.get(i);
      params.put("item_name_" + i, item.name);
      params.put("item_price_" + i, item.price);
      params.put("item_image_" + i, item.image);
      totalPrice += item.price;
    }
    params.put("total_price", totalPrice);
    return params;
  }
}

Optimove.shared.sendLocationUpdate(location: location);

Optimove.getInstance().sendLocationUpdate(location);

Feature isn't available in this SDK - contact your CSM.

import 'package:optimove_flutter/optimove_flutter.dart' as optimove;

// in the following example, location data was obtained using a location package https://pub.dev/packages/location
LocationData locationData = await location.getLocation();

Optimove.sendLocationUpdate(optimove.Location(longitude: locationData.longitude!, latitude: locationData.latitude!, time: locationData.time!));

Feature isn't available in this SDK - contact your CSM.

Feature isn't available in this SDK - contact your CSM.

import UIKit
import CoreData
import OptimoveSDK
import CoreLocation

@main
class AppDelegate: UIResponder, UIApplicationDelegate, CLLocationManagerDelegate {
   
    private var lm: CLLocationManager? = nil
    public func startLocationTracking() {
        let lm = CLLocationManager();
        lm.pausesLocationUpdatesAutomatically = false;
        lm.delegate = self
        self.lm = lm
        
        let status: CLAuthorizationStatus = lm.authorizationStatus
        if (CLAuthorizationStatus.authorizedAlways == status || CLAuthorizationStatus.authorizedWhenInUse == status) {
            self.startLocationMonitoring()
        }
        else{
            lm.requestAlwaysAuthorization()
        }
        
    }

    private func startLocationMonitoring(){
        self.lm!.startUpdatingLocation()
    }
    
    @available(iOS, deprecated: 14.0)
    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
        if (status == CLAuthorizationStatus.authorizedAlways) {
            self.startLocationMonitoring();
        }
    }
    
    @available(iOS 14.0, *)
    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager){
        if (manager.authorizationStatus == CLAuthorizationStatus.authorizedAlways) {
            self.startLocationMonitoring();
        }
    }
    
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        for loc in locations {
            Optimove.shared.sendLocationUpdate(location: loc);
        }
    }
}

/*
 *  Set up location tracking initialiser
 */

import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationServices;
import com.google.android.gms.tasks.Task;

public class LocationTrackingInitializer {
    public void startLocationTracking(Context context){
        this.mFusedLocationClient = LocationServices.getFusedLocationProviderClient(context);
        this.mLocationRequest = this.createLocationRequest();

        this.requestLocationUpdates(context);
    }

    private LocationRequest createLocationRequest() {
        LocationRequest request = new LocationRequest();

        request.setInterval(UPDATE_INTERVAL);
        request.setFastestInterval(FASTEST_UPDATE_INTERVAL);
        request.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
        request.setMaxWaitTime(MAX_WAIT_TIME);
        request.setSmallestDisplacement(SMALLEST_DISPLACEMENT_FOR_LOCATION_UPDATE);

        return request;
    }

    private void requestLocationUpdates(Context context) {
        try {
            this.mFusedLocationClient.requestLocationUpdates(this.mLocationRequest, this.getPendingIntent(context));
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }

    private PendingIntent getPendingIntent(Context context) {
        Intent intent = new Intent(context, LocationBroadcastReceiver.class);
        intent.setAction(LocationBroadcastReceiver.ACTION_PROCESS_LOCATION_UPDATE);

        int flags = PendingIntent.FLAG_UPDATE_CURRENT;
        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            flags |= PendingIntent.FLAG_IMMUTABLE;
        }

        return PendingIntent.getBroadcast(context, 0, intent, flags);
    }
}


/*
 * Receive location updates and send them to Optimove
 */

import android.location.Location;
import com.google.android.gms.location.LocationResult;

public class LocationBroadcastReceiver extends BroadcastReceiver {

    static final String ACTION_PROCESS_LOCATION_UPDATE = "com.kumulos.companion.LOCATION_UPDATE";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (null == intent) {
            return;
        }

        final String action = intent.getAction();
        if (!ACTION_PROCESS_LOCATION_UPDATE.equals(action)) {
            return;
        }

        LocationResult result = LocationResult.extractResult(intent);
        if (null == result) {
            return;
        }

        List<Location> locations = result.getLocations();
        Optimove instance = Optimove.getInstance();
        for (Location location : locations) {
            instance.sendLocationUpdate(location);
        }
    }
}

/* Note: Eddystone beacon detection on iOS has limitations. For example, many of Core Bluetooth 
tasks are disabled when your app is in the background or in a suspended state. */
Optimove.shared.trackEddystoneBeaconProximity(hexNamespace: hexNamespace, hexInstance: hexInstance, distanceMeters: distanceMeters);

/* 
 * Note: Beacon monitoring on Android typically requires a device with BLE, and API level 18+. 
 * You can read more about detecting beacons in the Android Nearby reference:
 * https://developers.google.com/nearby/
 */
Optimove.getInstance().trackEddystoneBeaconProximity(hexNamespace, hexInstance, distanceMeters);

Feature isn't available in this SDK - contact your CSM.

/*
 * Android Note: Beacon monitoring on Android typically requires a device with BLE, and API level 18+. 
 * You can read more about detecting beacons in the Android Nearby reference: 
 * https://developers.google.com/nearby/
 * 
 * iOS Note: Eddystone beacon detection on iOS has limitations. For example, many of Core Bluetooth 
 * tasks are disabled when your app is in the background or in a suspended state.
 */
Optimove.trackEddystoneBeaconProximity(EddystoneBeaconProximity(hexNamespace: hexNamespace, hexInstance: hexInstance, distanceMetres: distanceMetres));

Feature isn't available in this SDK - contact your CSM.

Feature isn't available in this SDK - contact your CSM.

Optimove.shared.trackIBeaconProximity(beacon: CLBeacon);

Optimove.getInstance().trackIBeaconProximity(iBeaconUuid, iBeaconMajorId, iBeaconMinorId, iBeaconProximity);

Feature isn't available in this SDK - contact your CSM.

Feature isn't available in this SDK - contact your CSM.

Feature isn't available in this SDK - contact your CSM.

Feature isn't available in this SDK - contact your CSM.

Optimove.initialize(
    with: OptimoveConfigBuilder(
        optimoveCredentials: "",
        optimobileCredentials: ""
    )
    .enablePreferenceCenter(credentials: "")
    .build()
)

Optimove.initialize(this, new OptimoveConfig.Builder("optimoveCredentials", "optimobileCredentials")
            .enablePreferenceCenter("preferenceCenterCredentials")
            .build());

let config = OptimoveConfigBuilder(region: .US, features: [.optimove, .optimobile, .preferenceCenter]).build()
Optimove.initialize(with: config)

// time passes...

Optimove.setCredentials(
  optimoveCredentials: yourOptimoveCredentials,
  optimobileCredentials: yourOptimobileCredentials,
  preferenceCenterCredentials: yourPreferenceCenterCredentials
)

OptimoveConfig.FeatureSet featureSet = new OptimoveConfig.FeatureSet().withOptimove().withPreferenceCenter();
Optimove.initialize(this, new OptimoveConfig.Builder(OptimoveConfig.Region.DEV, featureSet).build());

// time passes...

Optimove.setCredentials(
  optimoveCredentials: yourOptimoveCredentials,
  optimobileCredentials: yourOptimobileCredentials,
  preferenceCenterCredentials: yourPreferenceCenterCredentials
)

try OptimovePreferenceCenter.getInstance().getPreferencesAsync { result, preferences in
  switch result {
    case .success: ...
    case .errorUserNotSet: ...
    case .errorCredentialsNotSet: ...
    case .error: ...
  }
}

OptimovePreferenceCenter.getInstance().getPreferencesAsync((OptimovePreferenceCenter.ResultType result, Preferences preferences) -> {
            switch (result) {
                case ERROR_USER_NOT_SET:
                case ERROR_CREDNTIALS_NOT_SET:
                case ERROR:
                    ...
                    break;
                case SUCCESS: {
                    ...
                    break;
                }
            }
        });

preferences.configuredChannels // e.g. [.sms, .mobilePush]

preferences.getConfiguredChannels() // List<Channel> e.g. MOBILE_PUSH, SMS

preferences.customerPreferences // array of preferences, organised by topic
preferences.customerPreferences[0].id // topic id
preferences.customerPreferences[0].name // topic name
preferences.customerPreferences[0].description // topic description
preferences.customerPreferences[0].subscribedChannels // channels the customer is subscribed to, e.g. [.sms, .push]

List<Topic> customerPreferences = preferences.getCustomerPreferences()
customerPreferences[0].getId() // topic id
customerPreferences[0].getName() // topic name
customerPreferences[0].getDescription() // topic description
customerPreferences[0].getSubscribedChannels() // List<Channel> channels the customer is subscribed to, e.g. MOBILE_PUSH, SMS

try OptimovePreferenceCenter.getInstance().setCustomerPreferencesAsync(completion: { result in
  switch result {
    case .success: ...
    case .errorUserNotSet: ...
    case .errorCredentialsNotSet: ...
    case .error: ...
  }
}, updates: [OptimovePC.PreferenceUpdate])

OptimovePreferenceCenter
    .getInstance()
    .setCustomerPreferencesAsync((OptimovePreferenceCenter.ResultType setResult) -> {
       ...
    }, updates);

func fetchAndSetPreferences() {
    var preferences: OptimovePC.Preferences?

    // Fetch preferences asynchronously
    do {
        try OptimovePreferenceCenter.getInstance().getPreferencesAsync { result, fetchedPreferences in
            switch result {
            case .success:
                preferences = fetchedPreferences
                
                // Now that we have preferences, we can proceed with setting them
                if let preferences = preferences {
                    for topic in preferences.customerPreferences {
                        print("Topic ID: \(topic.id)")
                        print("Name: \(topic.name)")
                        print("Description: \(topic.description)")
                        print("Subscribed Channels: \(topic.subscribedChannels)")
                    }

                    // Prepare updates to customer preferences
                    let updates = [
                        OptimovePC.PreferenceUpdate(
                            topicId: preferences.customerPreferences[0].id,
                            // Note: You can only subscribe to channels that are configured
                            subscribedChannels: [.sms, .mail]
                        ),
                        OptimovePC.PreferenceUpdate(
                            topicId: preferences.customerPreferences[1].id,
                            subscribedChannels: []
                        )
                    ]

                    // Update preferences asynchronously
                    try? OptimovePreferenceCenter.getInstance().setCustomerPreferencesAsync(completion: { setResult in
                        switch setResult {
                        case .success:
                            print("Success: Preferences have been updated successfully.")
                        case .errorUserNotSet:
                            print("Error: Unable to update preferences. Preference Center requires an associated user. Please set a customer id.")
                        case .errorCredentialsNotSet:
                            print("Error: Unable to update preferences due to missing credentials. Please ensure your credentials are configured correctly.")
                        case .error:
                            print("Error: An issue occurred while updating preferences.")
                        }
                    }, updates: updates)
                }

            case .errorUserNotSet:
                print("Error: No user is associated. The Preference Center requires an associated user. Please set a customer id.")
            case .errorCredentialsNotSet:
                print("Error: Credentials are not set. Please check your credentials configuration.")
            case .error:
                print("Error: An issue occurred while fetching preferences.")
            }
        }
    } catch {
        print("Exception: \(error.localizedDescription). Please check the stack trace for more details.")
    }
}

AtomicReference<Preferences> preferences = new AtomicReference<>();

OptimovePreferenceCenter.getInstance().getPreferencesAsync((OptimovePreferenceCenter.ResultType result, Preferences fetchPreferences) -> {
    switch (result) {
        case ERROR_USER_NOT_SET:
        case ERROR:
        case ERROR_CREDENTIALS_NOT_SET:
        // Handle errors
            break;
        case SUCCESS: {
            preferences.set(fetchPreferences);
            break;
        }
        default:
            // ...
        }
    });

if (preferences.get() == null) {
    return;
}

List<Channel> configuredChannels = preferences.get().getConfiguredChannels();
List<Topic> topics = preferences.get().getCustomerPreferences();

List<PreferenceUpdate> updates = new ArrayList<>();
for (int i = 0; i < topics.size(); i++) {
    // Note, you can only subscribe to channels that are configured
    updates.add(new PreferenceUpdate(topics.get(i).getId(), configuredChannels.subList(0, 1)));
}

OptimovePreferenceCenter.getInstance().setCustomerPreferencesAsync((OptimovePreferenceCenter.ResultType setResult) -> {
    // Handle result;
}, updates);

Optimove.shared.pushRequestDeviceToken()  

Optimove.getInstance().pushRequestDeviceToken(); // Starting from Android 13, this method will open the notification permission request prompt 

Optimove.pushRequestDeviceToken();

Optimove.pushRequestDeviceToken();

Optimove.pushRequestDeviceToken();

Optimove.Shared.PushRegister();

Optimove.setPushReceivedHandler((notification) {
    // Called when a push is received with your app in the foreground
});

Optimove.setPushOpenedHandler((notification) => {
    // Called when a user taps on a push notification or its action buttons
});

Optimove.setPushOpenedAndDeeplinkHandlers((push) {
    // Called when a user taps on a push notification or its action buttons
}, (outcome) {
    // Called when the app is opened with a deeplink
});

Optimove.setPushReceivedHandler((push) {
    // Called when a push is received with your app in the foreground
});

Optimove.setPushOpenedHandler((push) {
    // Called when a user taps on a push notification or its action buttons
});

Optimove.setPushReceivedHandler((push: PushNotification) => {
    // Called when a push is received with your app in the foreground
});

Optimove.setPushOpenedHandler((push: PushNotification) => {
    // Called when a user taps on a push notification or its action buttons
});

Optimove.Shared.SetPushReceivedHandler((PushMessage push) => {
    // Called when a push is received with your app in the foreground
});

Optimove.Shared.SetPushOpenedHandler((PushMessage push) => {
    // Called when a user taps on a push notification or its action buttons
});

Optimove.shared.pushUnregister()

Optimove.getInstance().pushUnregister();

Optimove.pushUnregister();

Optimove.pushUnregister();

Optimove.pushUnregister();

Optimove.Shared.PushUnregister();

# The Optimove SDK supports iOS version 10 and higher
platform :ios, '10.0'

target 'My Application' do # Your app target
  use_frameworks!
  pod 'OptimoveSDK', '~> 5.0' # We've added this dependency in a previous step
end

target 'My Notification Extension' do # Your new extension target
  use_frameworks!
  pod 'OptimoveNotificationServiceExtension', '~> 5.0'
end

import UserNotifications
import OptimoveNotificationServiceExtension

class NotificationService: UNNotificationServiceExtension {
    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        OptimoveNotificationService.didReceive(request, withContentHandler: contentHandler)
    }
}

let cfg = OptimoveConfigBuilder(optimoveCredentials: "<YOUR_OPTIMOVE_CREDENTIALS>", optimobileCredentials: "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>")
    .setPushOpenedHandler(pushOpenedHandlerBlock: { (notification : PushNotification) -> Void in
        //- Inspect notification data and do work.
        if let action = notification.actionIdentifier {
            print("User pressed an action button.")
            print(action)
            print(notification.data)
        } else {
            print("Just an open event.")
        }
    })
    .build()

Optimove.initialize(config: cfg)

// iOS9 handler for push notifications
// iOS9+10 handler for background data pushes (content-available)
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        // userInfo["aps"]["content-available"] will be set to 1
        // userInfo["custom"]["a"] will contain any additional data sent with the push

        completionHandler(UIBackgroundFetchResult.noData)
    }

package com.example;

import com.optimove.android.optimobile.PushBroadcastReceiver;

public class MyPushReceiver extends PushBroadcastReceiver {

}

<receiver android:name="com.example.MyPushReceiver" android:exported="false">
    <intent-filter>
        <action android:name="com.optimove.push.RECEIVED" />
        <action android:name="com.optimove.push.OPENED" />
        <action android:name="com.optimove.push.DISMISSED" />
        <action android:name="com.optimove.push.BUTTON_CLICKED" />
    </intent-filter>
</receiver>

package com.example;

import android.content.Context;
import android.content.Intent;

import com.optimove.android.optimobile.PushBroadcastReceiver;
import com.optimove.android.optimobile.PushMessage;

public class MyPushReceiver extends PushBroadcastReceiver {

    @Override
    protected Intent getPushOpenActivityIntent(Context context, PushMessage pushMessage) {
        // TODO implement your own logic here
        return super.getPushOpenActivityIntent(context, pushMessage);
    }
}

Intent launchIntent = new Intent(context, MyActivity.class);
launchIntent.putExtra(PushMessage.EXTRAS_KEY, pushMessage);

package com.example;

import android.app.Notification;
import android.content.Context;

import com.optimove.android.optimobile.PushBroadcastReceiver;
import com.optimove.android.optimobile.PushMessage;

public class MyPushReceiver extends PushBroadcastReceiver {
    @Override
    protected @Nullable Notification.Builder getNotificationBuilder(Context context, PushMessage pushMessage) {
        // get builder with Optimove intents set up
        Notification.Builder builder = super.getNotificationBuilder(context, pushMessage);
        // TODO customize the notification
        builder.setContentTitle("custom: " + pushMessage.getTitle());

        return builder;
    }
}

Optimove.getInstance().pushTrackOpen(pushMessage.getId());
Optimove.getInstance().pushTrackDismissed(pushMessage.getId());
//call in the scope of MyPushReceiver
addDeepLinkExtras(pushMessage, launchIntent);

package com.example;

import android.content.Context;
import android.content.Intent;

import com.optimove.android.optimobile.PushBroadcastReceiver;
import com.optimove.android.optimobile.PushMessage;

public class MyPushReceiver extends PushBroadcastReceiver {

    @Override
    protected void onBackgroundPush(Context context, PushMessage pushMessage) {
        WorkManager workManager = WorkManager.getInstance(context);
        workManager.enqueue(new OneTimeWorkRequest.Builder(MyWorker.class).build());
    }

}

public class MyAppFirebaseMessagingService extends com.google.firebase.messaging.FirebaseMessagingService {

    @Override
    public void onNewToken(String token) {
        // Handle token for your purposes
        // ...
        // Also pass token to Optimove for registration
        Optimove.pushTokenStore(token);
    }

    @Override
    public void onMessageReceived(RemoteMessage remoteMessage) {
        // Handle message as you wish or forward this message to Optimove
        boolean wasHandledByOptimove = com.optimove.android.optimobile.FirebaseMessageHandler.onMessageReceived(this, remoteMessage);
        // Handle the message in case false is returned
    }
}

Optimove.getInstance().setPushActionHandler(new MyPushActionHandler());

public class MyPushActionHandler implements PushActionHandlerInterface {
    public void handle(Context context, PushMessage pushMessage, String actionId){
       //- actionId is the button id you set when creating the notification
       //- Note, that when action button is clicked your app's activity is not launched -- you have to do it yourself in this handler.
    }
}

OptimoveConfig config = new OptimoveConfig.Builder(
    "<YOUR_OPTIMOVE_CREDENTIALS>","<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>"
    ).setPushSmallIconId(R.id.my_push_small_icon)
    .build()

Optimove.initialize(this, config);

let cfg = OptimoveConfigBuilder(optimoveCredentials: "<YOUR_OPTIMOVE_CREDENTIALS>", optimobileCredentials: "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>")
    .enableInAppMessaging(inAppConsentStrategy: .autoEnroll)
    .build()
Optimove.initialize(config: cfg)

OptimoveConfig config = new OptimoveConfig.Builder(
    "<YOUR_OPTIMOVE_CREDENTIALS>","<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>"
    ).enableInAppMessaging(OptimoveConfig.InAppConsentStrategy.AUTO_ENROLL)
    .build()

Optimove.initialize(this, config);

OptimoveReactNativeInitializer.initializeOptimove(
  OptimoveReactNativeConfig.newInstance()
    .optimoveCredentials("<YOUR OPTIMOVE CREDENTIALS>")
    .optimobileCredentials("<YOUR OPTIMOBILE CREDENTIALS>")
    .enableInAppWithConsentStrategy(OptimoveConfig.InAppConsentStrategy.AUTO_ENROLL)
    .build(), getApplicationContext());

// Add inAppConsentStrategy to your optimove.json along previously added credentials:
{
  "optimoveCredentials": "YOUR_OPTIMOVE_CREDENTIALS",
  "optimobileCredentials": "YOUR_OPTIMOVE_MOBILE_CREDENTIALS",
  "inAppConsentStrategy": "auto-enroll", //in-app-disabled|auto-enroll|explicit-by-user
  "enableDeferredDeepLinking": false
}

// Add inAppConsentStrategy to your optimove.json along previously added credentials:
{
  "optimoveCredentials": "YOUR_OPTIMOVE_CREDENTIALS",
  "optimobileCredentials": "YOUR_OPTIMOVE_MOBILE_CREDENTIALS",
  "inAppConsentStrategy": "auto-enroll", //in-app-disabled|auto-enroll|explicit-by-user
  "enableDeferredDeepLinking": false
}

// Add inAppConsentStrategy to your optimove.json along previously added credentials:
{
  ...
  "inAppConsentStrategy": "auto-enroll", //in-app-disabled|auto-enroll|explicit-by-user
}

let cfg = OptimoveConfigBuilder(optimoveCredentials: "<YOUR_OPTIMOVE_CREDENTIALS>", optimobileCredentials: "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>")
    .enableInAppMessaging(inAppConsentStrategy: InAppConsentStrategy.explicitByUser)
    .build()
Optimove.initialize(config: cfg)

// Call this method to update consent based on user preferences / settings screen etc.
OptimoveInApp.getInstance().updateConsentForUser(true);

// Set the strategy to require explicit user consent
OptimoveConfig config = new OptimoveConfig.Builder(
    "<YOUR_OPTIMOVE_CREDENTIALS>","<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>"
    ).enableInAppMessaging(OptimoveConfig.InAppConsentStrategy.EXPLICIT_BY_USER)
    .build()

Optimove.initialize(this, config);

// Call this method to update consent based on user preferences / settings screen etc.
OptimoveInApp.getInstance().updateConsentForUser(true);

OptimoveReactNativeInitializer.initializeOptimove(
  OptimoveReactNativeConfig.newInstance()
    .optimoveCredentials("<YOUR OPTIMOVE CREDENTIALS>")
    .optimobileCredentials("<YOUR OPTIMOBILE CREDENTIALS>")
    .enableInAppWithConsentStrategy(OptimoveConfig.InAppConsentStrategy.EXPLICIT_BY_USER)
    .build(), getApplicationContext());

// You can control the consent by calling the following method:
Optimove.inAppUpdateConsent(boolean)

// optimove.json
{
  "optimoveCredentials": "YOUR_OPTIMOVE_CREDENTIALS",
  "optimobileCredentials": "YOUR_OPTIMOVE_MOBILE_CREDENTIALS",
  "inAppConsentStrategy": "explicit-by-user",
  "enableDeferredDeepLinking": false
}

// You can control the consent by calling the following method:
Optimove.inAppUpdateConsent(boolean)

// optimove.json
{
  "optimoveCredentials": "YOUR_OPTIMOVE_CREDENTIALS",
  "optimobileCredentials": "YOUR_OPTIMOVE_MOBILE_CREDENTIALS",
  "inAppConsentStrategy": "explicit-by-user",
  "enableDeferredDeepLinking": false
}

// You can control the consent by calling the following method:
Optimove.inAppUpdateConsent(boolean)

// Add `inAppConsentStrategy` to your `optimove.json` along previously added credentials:
{
  ...
  "inAppConsentStrategy": "explicit-by-user",
}

// You can control the consent by calling the following method:
Optimove.Shared.InAppUpdateConsent(true);

/* If you want to handle deep-links with custom data payloads as part of an In-App message you 
can add a handler block to your configuration options during SDK initialization. */

let cfg = OptimoveConfigBuilder(optimoveCredentials: "<YOUR_OPTIMOVE_CREDENTIALS>", optimobileCredentials: "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>")
    .enableInAppMessaging(inAppConsentStrategy: InAppConsentStrategy.autoEnroll)
    .setInAppDeepLinkHandler(inAppDeepLinkHandlerBlock: { buttonPress in
        let deepLink = buttonPress.deepLinkData
        let messageData = buttonPress.messageData

        // TODO: Inspect the deep link & message data to perform relevant action
    })
    .build()

Optimove.initialize(config: cfg)

/* If you want to handle deep-links with custom data payloads as part of an In-App message
you can create a class that implements the InAppDeepLinkHandlerInterface and add it to your
configuration options during SDK initialization: */

OptimoveInApp.getInstance().setDeepLinkHandler((context, buttonPress) -> {
    JSONObject deepLink = buttonPress.getDeepLinkData();
    JSONObject messageData = buttonPress.getMessageData();

    // TODO: Inspect the deep link & message data to perform relevant action
});

// The following sample code shows how to use Optimove to control the in-app buttons:
Optimove.setInAppDeeplinkHandler((inAppButtonPress) {
    // Called when a user taps on an in-app button
}

// The following sample code shows how to use Optimove to control the in-app buttons:
Optimove.setInAppDeeplinkHandler(inAppButtonPress) {
    // Called when a user taps on an in-app button
}

// The following sample code shows how to use Optimove to control the in-app buttons:
Optimove.setInAppDeeplinkHandler((inAppButtonPress: InAppButtonPress) => {
    // Called when a user taps on an in-app button
});

// The following sample code shows how to use Optimove to control the in-app buttons:
Optimove.Shared.SetInAppDeeplinkHandler((InAppButtonPress buttonPress) => {
    // Called when a user taps on an in-app button
});

let inboxItems = OptimoveInApp.getInboxItems()
if(inboxItems.count > 0)
{
    let result = OptimoveInApp.presentInboxMessage(item: inboxItems[0])    
}

List<InAppInboxItem> items = OptimoveInApp.getInstance().getInboxItems();
if (items.size() != 0) {
    OptimoveInApp.InboxMessagePresentationResult result = OptimoveInApp.getInstance().presentInboxMessage(items.get(0));
}

var items = await Optimove.inAppGetInboxItems();
Optimove.inAppPresentInboxMessage(items.first);

var items = await Optimove.getInboxItems();
Optimove.presentInboxMessage(items.first);

Optimove.inAppGetInboxItems().then((items:InAppInboxItem[]) => {
   Optimove.inAppPresentInboxMessage(items[0]);
}, error);

List<InAppInboxItem> items = Optimove.Shared.InAppGetInboxItems();
Optimove.Shared.InAppPresentInboxMessage(items[0]);

//single
let inboxItems = OptimoveInApp.getInboxItems()
if(inboxItems.count > 0)
{
    OptimoveInApp.markAsRead(item: inboxItems[0])
}

//all
OptimoveInApp.markAllInboxItemsAsRead()

//single
List<InAppInboxItem> items = OptimoveInApp.getInstance().getInboxItems(context);

if (items.size() != 0) {
    OptimoveInApp.getInstance().markAsRead(context, items.get(0));
}

//all
OptimoveInApp.getInstance().markAllInboxItemsAsRead(context);

var items = await Optimove.inAppGetInboxItems();

//single
Optimove.inAppMarkAsRead(items.first);
//all
Optimove.inAppMarkAllInboxItemsAsRead();

var items = await Optimove.inAppGetInboxItems();

//single
Optimove.inAppMarkAsRead(items.first);
//all
Optimove.inAppMarkAllInboxItemsAsRead();

//single
Optimove.inAppGetInboxItems().then((items:InAppInboxItem[]) => {
   Optimove.markAsRead(items[0]);
}, error);

//all
Optimove.markAllInboxItemsAsRead();

//single
int targetId = 0(for example); 
List<InAppInboxItem> items = Optimove.Shared.InAppGetInboxItems();
foreach (var item in items) {
  if (item.Id == targetId){
    bool result = Optimove.Shared.InAppMarkAsRead(item);
    break;
  }
}

//all
Optimove.Shared.MarkAllInboxItemsAsRead();

let inboxItems = OptimoveInApp.getInboxItems()
if(inboxItems.count > 0)
{
    OptimoveInApp.deleteMessageFromInbox(item: inboxItems[0]);
}

List<InAppInboxItem> items = OptimoveInApp.getInstance().getInboxItems(context);
if (items.size() != 0) {
    OptimoveInApp.getInstance().deleteMessageFromInbox(context, items.get(0));
}

var items = await Optimove.inAppGetInboxItems();
Optimove.inAppDeleteMessageFromInbox(items.first);

var items = await Optimove.inAppGetInboxItems();
Optimove.inAppDeleteMessageFromInbox(items.first);

Optimove.inAppGetInboxItems().then((items:InAppInboxItem[]) => {
   Optimove.inAppDeleteMessageFromInbox(items[0]);
}, error);

int targetId = 0 (for example);
List<InAppInboxItem> items = Optimove.Shared.InAppGetInboxItems();
foreach (var item in items) {
  if (item.Id == targetId){
    bool result = Optimove.Shared.InAppDeleteMessageFromInbox(item);
    break;
  }
}

OptimoveInApp.setOnInboxUpdated(inboxUpdatedHandlerBlock: {() -> Void in
    let inboxItems = OptimoveInApp.getInboxItems()

    //refresh your inbox
});

// Note, you can do OptimoveInApp.setOnInboxUpdated(inboxUpdatedHandlerBlock: nil) when you stop being interested in inbox updates.

OptimoveInApp.getInstance().setOnInboxUpdated(() -> {
    List<InAppInboxItem> items = OptimoveInApp.getInstance().getInboxItems(context);

    //refresh your inbox
});

// Note, you can do OptimoveInApp.getInstance().setOnInboxUpdated(null) when you stop being interested in inbox updates.

var items = await Optimove.inAppGetInboxItems();
Optimove.inAppDeleteMessageFromInbox(items.first);

Optimove.setOnInboxUpdatedHandler(() {
      _loadState();
});

Optimove.setOnInboxUpdatedHandler(() => {
   //
});

Optimove.Shared.SetOnInboxUpdatedHandler(() => {
   //handle
});

 OptimoveInApp.getInboxSummaryAsync(inboxSummaryBlock: {(summary:InAppInboxSummary?) -> Void in
    if let inboxSummary = summary {
        print("total: \(inboxSummary.totalCount) unread: \(inboxSummary.unreadCount)")
    }
});

OptimoveInApp.getInstance().getInboxSummaryAsync(context, (InAppInboxSummaryInfo summary) -> {
    if (summary != null){
        summary.getTotalCount();
        summary.getUnreadCount();
    }
});

var summary = await Optimove.inAppGetInboxSummary();

var summary = await Optimove.inAppGetInboxSummary();

Optimove.inAppGetInboxSummary().then((inboxSummary: InAppInboxSummary) => {
  //
}, error);

Optimove.Shared.GetInboxSummaryAsync((InAppInboxSummary summary) => {
            //use summary
        });

let inboxItems = OptimoveInApp.getInboxItems()

if(inboxItems.count > 0)
{
    // Default width is 300px
    let url = inboxItems[0].getImageUrl();

    // Get URL to a 200px wide image
    let url = items[0].getImageUrl(width: 200);    
}

List<InAppInboxItem> items = OptimoveInApp.getInstance().getInboxItems(context);

if (items.size() != 0) 
{
    // Default width is 300px
    URL u = items.get(0).getImageUrl();

    // Get URL to a 200px wide image
    URL u = items.get(0).getImageUrl(200);
}

var items = await Optimove.inAppGetInboxItems();
items[0].imageUrl;

var items = await Optimove.inAppGetInboxItems();
String url = items.first["imageUrl"];

Optimove.inAppGetInboxItems().then((items:InAppInboxItem[]) => {
   items[0]["imageUrl"];
}, error);

List<InAppInboxItem> items = Optimove.Shared.InAppGetInboxItems();
Optimove.Shared.InAppPresentInboxMessage(items[0].ImageUrl);

SDK version 5.3.0+

SDK version 7.2.0+

OptimoveInApp.setDisplayMode(mode: .paused)
OptimoveInApp.setDisplayMode(mode: .automatic)
OptimoveInApp.getDisplayMode()

OptimoveInApp.getInstance().setDisplayMode(OptimoveConfig.InAppDisplayMode.PAUSED);
OptimoveInApp.getInstance().setDisplayMode(OptimoveConfig.InAppDisplayMode.AUTOMATIC);
OptimoveConfig.InAppDisplayMode mode = OptimoveInApp.getInstance().getDisplayMode();

let cfg = OptimoveConfigBuilder(optimoveCredentials: "<YOUR_OPTIMOVE_CREDENTIALS>", optimobileCredentials: "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>")
    .enableInAppMessaging(inAppConsentStrategy: .autoEnroll, defaultDisplayMode: .paused)
    .build()

OptimoveConfig config = new OptimoveConfig.Builder(
    "<YOUR_OPTIMOVE_CREDENTIALS>","<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>"
    ).enableInAppMessaging(OptimoveConfig.InAppConsentStrategy.AUTO_ENROLL, OptimoveConfig.InAppDisplayMode.PAUSED)
    .build()

OptimoveInApp.setDisplayMode(mode: .automatic)

OptimoveInApp.getInstance().setDisplayMode(OptimoveConfig.InAppDisplayMode.AUTOMATIC);

1. Confirm the subdomain matches the domain you set in the Associated Domains capability 
in your Xcode project.

2. Toggle the switch next to iOS Config on. Enter the URL to your app in the App Store, 
the Bundle ID for your app and your Apple Developer Account Team ID (which can be found 
in the Apple Membership Section -> https://developer.apple.com/account/#/membership).

To use Deferred Deep Links with your Android app, toggle the switch next to Android Config on. 
Enter the URL to your app in the Play Store, the Package for your app and the colon separated, 
SHA256 signing certificate fingerprint(s).

Note that if you are publishing to Google Play and app signing by Google Play is enabled, 
you need to add two SHA256 fingerprints: one obtained from signing APK locally and one 
obtained from Google Play console. Fingerprints are necessary for deep linking into your app 
without showing a disambiguation dialog.

To use Deferred Deep Links with your Android app, toggle the switch next to Android Config on. 
Enter the URL to your app in the Play Store, the Package for your app and the colon separated, 
SHA256 signing certificate fingerprint(s).

Note that if you are publishing to Google Play and app signing by Google Play is enabled, 
you need to add two SHA256 fingerprints: one obtained from signing APK locally and one 
obtained from Google Play console. Fingerprints are necessary for deep linking into your app 
without showing a disambiguation dialog. 

To use Deferred Deep Links with your Android app, toggle the switch next to Android Config on.
Enter the URL to your app in the Play Store, the Package for your app and the colon separated, 
SHA256 signing certificate fingerprint(s).

Note that if you are publishing to Google Play and app signing by Google Play is enabled, 
you need to add two SHA256 fingerprints: one obtained from signing APK locally and one 
obtained from Google Play console. Fingerprints are necessary for deep linking into your app
without showing a disambiguation dialog.

To use Deferred Deep Links with your Android app, toggle the switch next to Android Config on.
Enter the URL to your app in the Play Store, the Package for your app and the colon separated, 
SHA256 signing certificate fingerprint(s).

Note that if you are publishing to Google Play and app signing by Google Play is enabled, 
you need to add two SHA256 fingerprints: one obtained from signing APK locally and one 
obtained from Google Play console. Fingerprints are necessary for deep linking into your app
without showing a disambiguation dialog.

To use Deferred Deep Links with your Android app, toggle the switch next to Android Config on.
Enter the URL to your app in the Play Store, the Package for your app and the colon separated, 
SHA256 signing certificate fingerprint(s).

Note that if you are publishing to Google Play and app signing by Google Play is enabled, 
you need to add two SHA256 fingerprints: one obtained from signing APK locally and one 
obtained from Google Play console. Fingerprints are necessary for deep linking into your app
without showing a disambiguation dialog.

// If your app doesn't use scenes, add to your AppDelegate.swift:
func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    return Optimove.shared.application(application, continue: userActivity, restorationHandler: restorationHandler)
}

// If your app uses scenes: add to SceneDelegate.swift:
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    guard let _ = (scene as? UIWindowScene) else { return }

    // Deep links from cold starts
    if let userActivity = connectionOptions.userActivities.first {
        Optimove.shared.scene(scene, continue: userActivity)
    }
}

func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
    Optimove.shared.scene(scene, continue: userActivity)
}


// Configure a deep link handler:
let cfg = OptimoveConfigBuilder(optimoveCredentials: "<YOUR_OPTIMOVE_CREDENTIALS>", optimobileCredentials: "<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>")
    .enableDeepLinking({ (resolution) in
        print("Deep link resolution result: \(resolution)")
    })
    .build()
Optimove.initialize(config: cfg)

/* 
Finally, you need to associate a domain with your app. Note that the subdomain you specify 
here should match the one you specified on the deep link configuration page in the Optimove UI.

1. Add the Associated Domains capability to your main app target
2. Set 'domains' to applinks:{yourSubdomain}.lnk.click 
*/

// 1. Add an intent filter to your main activity:

<intent-filter android:label="deepLabel" android:autoVerify="true">
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <!-- Specify which URIs should be matched. Note, domain should be .lnk.click -->
    <data android:scheme="https" android:host="subdomain.lnk.click"/>
</intent-filter>

/*
Note that the subdomain you specify above should match the one you specified on the deep link 
configuration page on the Optimove UI.

Note that setting android:autoVerify="true" will verify ownership of the domain, so, 
instead of offering a list of apps to select from your app will open automatically.
No further actions are needed to enable this
*/

// 3. Add following overrides to the main activity:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Optimove.getInstance().seeIntent(getIntent(), savedInstanceState);
}

@Override
public void onWindowFocusChanged(boolean hasFocus) {
    super.onWindowFocusChanged(hasFocus);
    Optimove.getInstance().seeInputFocus(hasFocus);
}

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    Optimove.getInstance().seeIntent(intent);
}

// 4. Configure a deep link handler:

OptimoveConfig config = new OptimoveConfig.Builder(
    "<YOUR_OPTIMOVE_CREDENTIALS>","<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>"
    ).enableDeepLinking(null, new MyDeferredDeepLinkHandler())
    .build());

Optimove.initialize(this, config);

// 5. A stub implementation of the handler could be as follows:

public class MyDeferredDeepLinkHandler implements DeferredDeepLinkHandlerInterface {
    public void handle(Context context, DeferredDeepLinkHelper.DeepLinkResolution resolution, String link, @Nullable DeferredDeepLinkHelper.DeepLink data){
       //- Inspect the data payload and run code as needed.
   }
}

/************** Android **************/

// Make sure that the initialization builder method deeplinkEnabled is called with true:
OptimoveReactNativeInitializer.initializeOptimove(
    OptimoveReactNativeConfig.newInstance()
                                .optimoveCredentials("<YOUR OPTIMOVE CREDENTIALS>")
                                .optimobileCredentials("<YOUR OPTIMOBILE CREDENTIALS>")
                                .deeplinkEnabled(true)
                                //...
                                .build(), getApplicationContext());
    
// Add an intent filter to your main activity:
<intent-filter android:label="deepLabel" android:autoVerify="true">
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <!-- Specify which URIs should be matched. Note, domain should be .lnk.click -->
    <data android:scheme="https" android:host="subdomain.lnk.click"/>
</intent-filter>
    
/*
Note that the subdomain you specify above should match the one you specified on the deep 
link configuration page on the Optimove UI.

Note that setting android:autoVerify="true" will verify ownership of the domain, so, instead 
of offering a list of apps to select from your app will open automatically. No further 
actions are needed to enable this.
*/
    
// Add following overrides to the main activity:
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Optimove.getInstance().seeIntent(getIntent(), savedInstanceState);
}

@Override
public void onWindowFocusChanged(boolean hasFocus) {
    super.onWindowFocusChanged(hasFocus);
    Optimove.getInstance().seeInputFocus(hasFocus);
}

@Override
public void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    Optimove.getInstance().seeIntent(intent);
}

/************** iOS **************/
// Make sure that the initialization enableDeferredDeepLinking param is true:

OptimoveInitializer.initialize(
  "<YOUR OPTIMOVE CREDENTIALS>", 
  optimobileCredentials: "<YOUR OPTIMOBILE CREDENTIALS>", 
  inAppConsentStrategy: "auto-enroll|in-app-disabled|explicit-by-user",
  enableDeferredDeepLinking: true)

/*
Associate a domain with your app. Note that the subdomain you specify here should match the one 
you specified on the deep link configuration page in the Optimove UI.

Add the Associated Domains capability to your main app target. Set 'domains' to 
applinks:{yourSubdomain}.lnk.click */

// Add the following to the AppDelegate (Objective C)
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> *restorableObjects))restorationHandler {
    return [OptimoveInitializer application:application userActivity:userActivity restorationHandler:restorationHandler];
}

/************** Typescript / Javascript **************/
// Finally, configure a deep link handler:
Optimove.setDeepLinkHandler((deepLink) => {
   
});

/************** Android **************/
// Add an intent filter to your main activity:

<intent-filter android:label="deepLabel" android:autoVerify="true">
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    <!-- Specify which URIs should be matched. Note, domain should be .lnk.click -->
    <data android:scheme="https" android:host="subdomain.lnk.click"/>
</intent-filter>

/* Note that the subdomain you specify above should match the one you specified on the deep link
configuration page on the Optimove UI.

Note that setting android:autoVerify="true" will verify ownership of the domain, so, instead of 
offering a list of apps to select from your app will open automatically. No further actions are 
eeded to enable this */

// Add following overrides to the main activity:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Optimove.getInstance().seeIntent(getIntent(), savedInstanceState);
}

@Override
public void onWindowFocusChanged(boolean hasFocus) {
    super.onWindowFocusChanged(hasFocus);
    Optimove.getInstance().seeInputFocus(hasFocus);
}

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    Optimove.getInstance().seeIntent(intent);
}

// Configure a deep link handler:

OptimoveConfig config = new OptimoveConfig.Builder(
    "<YOUR_OPTIMOVE_CREDENTIALS>","<YOUR_OPTIMOVE_MOBILE_CREDENTIALS>"
    ).enableDeepLinking(null, new MyDeferredDeepLinkHandler())
    .build());

Optimove.initialize(this, config);

// A stub implementation of the handler could be as follows:

public class MyDeferredDeepLinkHandler implements DeferredDeepLinkHandlerInterface {
    public void handle(Context context, DeferredDeepLinkHelper.DeepLinkResolution resolution, String link, @Nullable DeferredDeepLinkHelper.DeepLink data){
       //- Inspect the data payload and run code as needed.
   }
}

/************** iOS **************
First, you need to associate a domain with your app. Note that the subdomain you specify here 
should match the one you specified on the deep link configuration page in the Optimove UI. */

// Add the Associated Domains capability to your main app target. Set 'domains' to 
applinks:{yourSubdomain}.lnk.click

// Add the following to the AppDelegate.swift in your native project:

override func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
        return Optimove.shared.application(application, continue: userActivity, restorationHandler: restorationHandler)
    }
}

// To enable deferred deep linking add the flag below to your optimove.json:
{
  ...
  "enableDeferredDeepLinking": true
}

/************** Android **************/
// Modify config.xml to add the following:

<widget 
    ...
    xmlns:android="http://schemas.android.com/apk/res/android"
>
    ...
    <platform name="android">
    	<config-file parent="/manifest/application/activity" target="AndroidManifest.xml">
    		<intent-filter android:label="deepLabel" android:autoVerify="true">
    		    <action android:name="android.intent.action.VIEW" />
    		    <category android:name="android.intent.category.DEFAULT" />
    		    <category android:name="android.intent.category.BROWSABLE" />
    		    <!-- Specify which URIs should be matched. Note, domain should be .lnk.click -->
    		    <data android:scheme="https" android:host="cordova-example-optimove.lnk.click"/>
    		</intent-filter>
    	</config-file>
    
    	<edit-config file="AndroidManifest.xml" target="/manifest/application/activity/intent-filter/category/[@android:name='android.intent.category.LAUNCHER']/../.." mode="merge">
    		<activity android:name="OptimoveMainActivity"/>
    	</edit-config>
    </platform>
</widget>

/* Note that the subdomain you specify above should match the one you specified on the deep link
configuration page on the Optimove UI.

Note that setting android:autoVerify="true" will verify ownership of the domain, so, instead of 
fering a list of apps to select from your app will open automatically. No further actions are 
needed to enable this.

Make sure to run cordova prepare android to apply changes from config.xml. 

Troubleshooting:
 config.xml changes set launcher activity to OptimoveMainActivity which extends MainActivity 
 generated by Cordova. OptimoveMainActivity has overrides required for Optimove DDL to function.
 If you are having trouble with this setup you can manually copy the overrides into the activity 
 of your choice. */


/************** iOS **************/
// First, you need to associate a domain with your app. Note that the subdomain you specify here 
// should match the one you specified on the deep link configuration page in the Optimove UI.

//Add the Associated Domains capability to your main app target. Set 'domains' to 
applinks:{yourSubdomain}.lnk.click

// Next, if your generated native project contains AppDelegate (most likely), add the 
//following to the AppDelegate.m:

#import "Bridging-Header.h"

...

- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray<id<UIUserActivityRestoring>> *restorableObjects))restorationHandler {
    return [Optimove_Cordova application:application userActivity:userActivity restorationHandler:restorationHandler];
}

//If instead there is a SceneDelegate, add the following to the SceneDelegate.m:

#import "Bridging-Header.h"

...

- (void) scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity API_AVAILABLE(ios(13.0)){
    [Optimove_Cordova scene:scene userActivity:userActivity];
}

- (void)scene:(UIScene * _Nonnull)scene willConnectToSession:(UISceneSession * _Nonnull)session options:(UISceneConnectionOptions * _Nonnull)connectionOptions API_AVAILABLE(ios(13.0)){
    [Optimove_Cordova scene:scene session:session options:connectionOptions];
}


/************** Typescript / Javascript **************/
// Finally, configure a deep link handler:

Optimove.setDeepLinkHandler((deepLink: DeepLink) => {
   //
});

// To enable Deferred Deep Linking update your `optimove.json`:
{
  ...
  "deferredDeepLinkingHost": "<YOUR_SUBDOMAIN>.lnk.click"
}

/********************** Android **********************

Next, modify `/Assets/Plugins/Android/AndroidManifest.xml` to uncomment the following:

<!-- <intent-filter android:label="deepLabel" android:autoVerify="true">
		<action android:name="android.intent.action.VIEW" />
		<category android:name="android.intent.category.DEFAULT" />
		<category android:name="android.intent.category.BROWSABLE" />
		<data android:scheme="https" android:host="<YOUR_SUBDOMAIN>.lnk.click"/>
     </intent-filter> -->
     
Note that the subdomain you specify above should match the one you specified on the deep link configuration page on the Optimove UI.
Note that setting `android:autoVerify="true"` will verify ownership of the domain, so, instead of offering a list of apps to select from your app will open automatically. No further actions are needed to enable this.

********************** iOS **********************

DDL configuration is done automatically based on updated `optimove.json`. No additional steps required.

*********************** Usage ***********************

To configure a deep link handler:  */

Optimove.Shared.SetDeepLinkResolvedHandler ( (DeepLink ddl) =>{
   //
});

//v3
let tenant = OptimoveTenantInfo(tenantToken: "<YOUR_TENANT_TOKEN>",
configName:"<YOUR_CONFIG_NAME>")

Optimove.configure(for: tenant)

//v5
let config = OptimoveConfigBuilder(
    optimoveCredentials: "your-optimove-credentials",
    optimobileCredentials: "your-optimobile-credentials"
).build()

Optimove.initialize(with: config)

import UserNotifications
import OptimoveNotificationServiceExtension

class NotificationService: UNNotificationServiceExtension {
    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        OptimoveNotificationService.didReceive(request, withContentHandler: contentHandler)
    }
}

//v4
implementation 'com.optimove.sdk:optimove-sdk:4.+'

//v5
implementation 'com.optimove.android:optimove-android:5.+'

//v4
Optimove.configure(this, new TenantInfo("<YOUR_OPTIMOVE_TENANT_TOKEN>", "<YOUR_OPTIMOVE_CONFIG_NAME>"));

//v5
Optimove.initialize(this, new OptimoveConfig.Builder(
        "your-optimove-credentials",
        "your-optimobile-credentials")
        .build());

Optimove.configure(this, new TenantInfo(BuildConfig.OPTIMOVE_TENANT_TOKEN, BuildConfig.OPTIMOVE_CONFIG_NAME));

maven {
	url  "https://mobiussolutionsltd.bintray.com/optimove-sdk"
}

buildscript {
	repositories {
	  mavenCentral()
	  //...
	}
  //...
}

<application
  <service  
    android:name="com.optimove.sdk.optimove_sdk.optipush.messaging.OptipushMessagingService"  
    android:exported="false">  
    <intent-filter>             
      <action android:name="com.google.firebase.MESSAGING_EVENT"/>  
    </intent-filter>
  </service>
</application>

// change:
new OptipushFcmTokenHandler().onTokenRefresh();

// to:
Optimove.getInstance().fcmTokenRefreshed();