How to Create Custom Integrations

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import com.rudderstack.sdk.kotlin.android.plugins.devicemode.IntegrationPlugin;
import com.rudderstack.sdk.kotlin.core.internals.logger.LoggerAnalytics;
import com.rudderstack.sdk.kotlin.core.internals.models.*;

import java.util.HashMap;
import java.util.Map;

import kotlinx.serialization.json.JsonObject;
import kotlinx.serialization.json.JsonElement;

/**
 * Custom integration plugin for CustomDestination
 */
public class MyCustomIntegrationPlugin extends IntegrationPlugin {

    /**
     * The instance of the destination SDK which is wrapped with this integration plugin.
     * Here, `CustomDestinationSdk` is a sample third party SDK class which you can wrap with an integration plugin.
     */
    private CustomDestinationSdk destinationSdk;

    // Unique identifier for your integration
    private static final String KEY = "CustomDestination";

    @NonNull
    @Override
    public String getKey() {
        return KEY;
    }

    /**
     * Initialize your destination SDK
     * Note: destinationConfig will be empty for custom integrations
     */
    @Override
    public void create(@NonNull JsonObject destinationConfig) {
        // Initialize with your custom configuration
        String apiKey = "your-api-key";
        String serverUrl = "https://api.yourdestination.com";
        destinationSdk = CustomDestinationSdk.initialize(apiKey, serverUrl);
        LoggerAnalytics.INSTANCE.debug("MyCustomDestination: SDK initialized");
    }

    /**
     * Return the destination SDK instance
     */
    @Nullable
    @Override
    public Object getDestinationInstance() {
        return destinationSdk;
    }

    /**
     * Implement event methods to forward events to your destination SDK.
     * Call the appropriate methods on your destination SDK instance.
     */
    @Override
    public void track(@NonNull TrackEvent payload) {
        if (destinationSdk != null) {
            Map<String, Object> properties = convertJsonObjectToMap(payload.getProperties());
            destinationSdk.trackEvent(payload.getEvent(), properties);
        }
    }

    @Override
    public void identify(@NonNull IdentifyEvent payload) {
        if (destinationSdk != null) {
            Map<String, Object> traits = new HashMap<>();
            JsonElement traitsElement = payload.getContext().get("traits");
            if (traitsElement != null && traitsElement.isJsonObject()) {
                traits = convertJsonObjectToMap(traitsElement.getAsJsonObject());
            }
            destinationSdk.identifyUser(payload.getUserId(), traits);
        }
    }

    @Override
    public void screen(@NonNull ScreenEvent payload) {
        if (destinationSdk != null) {
            Map<String, Object> properties = convertJsonObjectToMap(payload.getProperties());
            destinationSdk.trackScreen(payload.getScreenName(), properties);
        }
    }

    @Override
    public void group(@NonNull GroupEvent payload) {
        if (destinationSdk != null) {
            Map<String, Object> traits = payload.getTraits() != null 
                ? convertJsonObjectToMap(payload.getTraits()) 
                : new HashMap<>();
            destinationSdk.setGroup(payload.getGroupId(), traits);
        }
    }

    @Override
    public void alias(@NonNull AliasEvent payload) {
        if (destinationSdk != null) {
            destinationSdk.aliasUser(payload.getUserId(), payload.getPreviousId());
        }
    }

    /**
     * Optional: Implement flush method if supported by your destination SDK
     */
    @Override
    public void flush() {
        if (destinationSdk != null) {
            destinationSdk.flush();
            LoggerAnalytics.INSTANCE.debug("MyCustomDestination: Flushed events");
        }
    }

    /**
     * Optional: Implement reset method if supported by your destination SDK
     */
    @Override
    public void reset() {
        if (destinationSdk != null) {
            destinationSdk.reset();
            LoggerAnalytics.INSTANCE.debug("MyCustomDestination: Reset user data");
        }
    }

    /**
     * Utility method to convert JsonObject to Map for Java compatibility
     */
    private Map<String, Object> convertJsonObjectToMap(JsonObject jsonObject) {
        Map<String, Object> map = new HashMap<>();
        // Implementation depends on your JsonObject structure
        // This is a simplified example - you may need more robust conversion
        // You would typically iterate through the JsonObject and convert each element
        return map;
    }
}

import android.app.Application;

import com.rudderstack.sdk.kotlin.android.Configuration;
import com.rudderstack.sdk.kotlin.android.javacompat.ConfigurationBuilder;
import com.rudderstack.sdk.kotlin.android.javacompat.JavaAnalytics;

public class MyApp extends Application {
    
    private JavaAnalytics analytics;
    
    @Override
    public void onCreate() {
        super.onCreate();
        
        // Initialize Analytics
        Configuration config = new ConfigurationBuilder(this, "your-write-key", "your-data-plane-url")
                .build();
        analytics = new JavaAnalytics(config);
        
        // Create and add your custom integration
        MyCustomIntegrationPlugin customIntegration = new MyCustomIntegrationPlugin();
        
        // Add the integration to analytics
        analytics.add(customIntegration);
    }
}

#import <Foundation/Foundation.h>
@import RudderStackAnalytics;

// MyCustomIntegrationPlugin.h
@interface MyCustomIntegrationPlugin : NSObject<RSSIntegrationPlugin>
@end

// MyCustomIntegrationPlugin.m
@interface MyCustomIntegrationPlugin()
@property SampleDestination *destination;
@end

@implementation MyCustomIntegrationPlugin

@synthesize pluginType;
@synthesize key;

- (NSString*)key {
    return @"MyCustomDestination";
}

- (RSSPluginType)pluginType {
    return RSSPluginTypeTerminal;
}

/**
 * The instance of the destination SDK which is wrapped with this integration plugin.
 */
- (id _Nullable)getDestinationInstance { 
    return self.destination;
}

/**
 * Initialize your destination SDK
 * Note: destinationConfig will be empty for custom integrations
 */
- (BOOL)createWithDestinationConfig:(NSDictionary<NSString *,id> * _Nonnull)destinationConfig error:(NSError * _Nullable __autoreleasing * _Nullable)error {
    if (_destination == nil) {
        _destination = [SampleDestination createWithApiKey:@"MyCustomDeviceDestination"];
    }
    return YES;
}

/**
 * Implement event methods to forward events to your destination SDK.
 * Call the appropriate methods on your destination SDK instance.
 */
- (void)identify:(RSSIdentifyEvent *)payload {
    [_destination identifyUser:payload.userId ?: @"" traits:payload.traits ?: @{}];
}
     
- (void)track:(RSSTrackEvent *)payload {
    [_destination trackEvent:payload.eventName properties:payload.properties ?: @{}];
}

- (void)screen:(RSSScreenEvent *)payload {
    [_destination screen:payload.screenName properties:payload.properties ?: @{}];
}

- (void)group:(RSSGroupEvent *)payload {
    [_destination group:payload.groupId traits:payload.traits ?: @{}];
}

- (void)alias:(RSSAliasEvent *)payload {
    [_destination aliasUser:payload.userId ?: @"" previousId:payload.previousId];
}

/**
 * Optional: Implement flush method if supported by your destination SDK
 */
- (void)flush {
    [_destination flush];
}

/**
 * Optional: Implement reset method if supported by your destination SDK
 */
- (void)reset {
    [_destination reset];
}

@end

#import <UIKit/UIKit.h>
@import RudderStackAnalytics;

// AppDelegate.m
@interface AppDelegate ()
@property RSSAnalytics *analytics;
@end

@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Initialize Analytics
    NSString *writeKey = @"your-write-key";
    NSString *dataPlaneUrl = @"your-data-plane-url";
    
    RSSConfigurationBuilder *builder = [[RSSConfigurationBuilder alloc] initWithWriteKey:writeKey dataPlaneUrl:dataPlaneUrl];
    self.analytics = [[RSSAnalytics alloc] initWithConfiguration:[builder build]];
    
    // Create and add your custom integration
    MyCustomIntegrationPlugin *customIntegration = [MyCustomIntegrationPlugin new];
    // Add the integration to analytics
    [self.analytics addPlugin:customIntegration];
    
    return YES;
}

@end