let segmentConfiguration = AnalyticsConfiguration(writeKey: SEGMENT_API_KEY)
// Make other configuration changes
let uxcamMiddleware = BlockMiddleware(block: { (context, next) in

switch (context.eventType) {
// Add your cases here
  }
default: break

}
next(context)

})

segmentConfiguration.sourceMiddleware = [uxcamMiddleware]
Analytics.setup(with: segmentConfiguration)

SEGAnalyticsConfiguration *segmentConfiguration = [SEGAnalyticsConfiguration configurationWithWriteKey: SEGMENT_API_KEY
// Make other configuration changes
SEGBlockMiddleware *uxcamMiddleware = [[SEGBlockMiddleware alloc] initWithBlock:^(SEGContext * _Nonnull context, SEGMiddlewareNext  _Nonnull next) {

switch (context.eventType) {

    // Add your cases here
    
default: break;
}

next(context);

}];
segmentConfiguration.sourceMiddleware = @[uxcamMiddleware];
[SEGAnalytics setupWithConfiguration:segmentConfiguration];

new Analytics.Builder(getApplicationContext(), SEGMENT_API_KEY)
      .recordScreenViews()
      .useSourceMiddleware(new Middleware() {
          @Override
          public void intercept(Chain chain) {
              BasePayload payload = chain.payload();
              switch (payload.type()) {

                   // Add your cases here
                    
              }
              chain.proceed(payload);
         }
     }).build();

Analytics.Builder(applicationContext, SEGMENT_API_KEY)
  .recordScreenViews() 
  .useSourceMiddleware { chain ->
     val payload = chain.payload()
     when (payload.type()) {
             
    			// Add your cases here
    }
     chain.proceed(payload)
 }.build()

case .track:

   if let track = context.payload as? TrackPayload {

       var properties = [String: String]()
       // Stringify track properties
       track.properties?.forEach({ (key: AnyHashable, value: Any) in

       properties["\(key)"] = "\(value)"

       })

     let check = track.event
     if check != "button to ignore" {
     UXCam.logEvent(track.event, withProperties: properties)

    }}

case SEGEventTypeTrack:

if ([context.payload isKindOfClass:[SEGTrackPayload class]]) {

SEGTrackPayload *track = (SEGTrackPayload *)context.payload;
// Converting property from Segment payload to match UXCam payload
// Stringifying Key and Value of properties
NSDictionary *oldProperties = track.properties;
NSMutableDictionary *newProperties = [NSMutableDictionary dictionary];
if (oldProperties != nil && oldProperties.count > 0) {

[oldProperties enumerateKeysAndObjectsUsingBlock:^(id  _Nonnull key, id  _Nonnull obj, BOOL * _Nonnull stop) {

NSString *keyString = [NSString stringWithFormat:@"%@", key];
NSString *value = [NSString stringWithFormat:@"%@", obj];
newProperties[keyString] = value;

}];

}
[UXCam logEvent:track.event withProperties:newProperties];

}
break;

case track:
      Map<String, Object> params = new HashMap<>();

        String key = payload.getString("event");
        ValueMap map = payload.getValueMap("properties");
            if (map != null) {
               for (Map.Entry<String, Object> entry : map.entrySet()) {
                   params.put(entry.getKey(), entry.getValue());
               }
            }

         UXCam.logEvent(key, params);
         break;

BasePayload.Type.track -> {
   val params: MutableMap<String, Any> = HashMap()
   val key = payload.getString("event")

   payload.getValueMap("properties")?.let {
      for ((paramKey, paramValue) in it) {
        params[paramKey] = paramValue
      }
   }

   UXCam.logEvent(key, params)
}

case .screen:

        if let screen = context.payload as? ScreenPayload {

          var properties = [String: String]()
          // Stringify track properties
          screen.properties?.forEach({ (key: AnyHashable, value: Any) in

           properties["\(key)"] = "\(value)"

        })

          UXCam.tagScreenName(screen.name)

        }

case screen:
   String screenName = payload.getString("name");
   UXCam.tagScreenName(screenName);
   Break;

BasePayload.Type.screen -> {
     val screenName = payload.getString("name")
     UXCam.tagScreenName(screenName)
}

case .identify:

        if let user = context.payload as? IdentifyPayload {

          var userProperties = [String: String]()
          // Stringify track properties
          user.traits?.forEach({ (key: AnyHashable, value: Any) in

           userProperties["\(key)"] = "\(value)"

        })

          UXCam.setUserIdentity(user.userId)

        }

case identify:
   String userId = payload.userId();
    if (userId != null) {
        UXCam.setUserIdentity(userId);
    }

   Object payloadTraits = payload.get("traits");
    if (payloadTraits instanceof Map) {
        Map<Object, Object> traits = (Map<Object, Object>) payloadTraits;
         for (Map.Entry<Object, Object> entry : traits.entrySet()) {                                      UXCam.setUserProperty(entry.getKey().toString(), entry.getValue().toString());
         }
    }
break;

BasePayload.Type.identify -> {
             payload.userId()?.let {
                 UXCam.setUserIdentity(it)
             }

             payload["traits"]?.let {
                 val traits: Map<*, *>? = it as? Map<*, *>
                 traits?.let {
                     for ((key, value) in traits) {
                         UXCam.setUserProperty(key.toString(), value.toString())
                     }
                 }
            }
         }

// UXCamSegmentPlugin.ts
 
import {
 EventPlugin,
 IdentifyEventType,
 TrackEventType,
 ScreenEventType,
 PluginType,
 JsonValue,
 } from '@segment/analytics-react-native';
 
 import RNUxcam from 'react-native-ux-cam';
  export class UXCamSegmentPlugin extends EventPlugin {
 
   type = PluginType.before;
  
   identify(event: IdentifyEventType) {
     if (event.userId) { RNUxcam.setUserIdentity(event.userId); }
     if (event.traits) {
       Object.entries(event.traits).forEach(
         ([key, value]) => this.setUserProperty(key, value)
     );
      
     }
     return event;
   }
 
   setUserProperty(key: string, value: JsonValue) {
     // Only string and number are supported for UXCam setUserProperty
       if (typeof value === 'string' || typeof value === 'number') {
         RNUxcam.setUserProperty(key, value);
       }
   }
    track(event: TrackEventType) {
     if (event.properties) {
       RNUxcam.logEvent(event.event, event.properties);
     }
     return event;
   }
    screen(event: ScreenEventType) {
     RNUxcam.tagScreenName(event.name);
     return event;
   }
 }

import { UXCamSegmentPlugin } from './src/helpers/segment_plugin';
segmentClient.add({ plugin: new UXCamSegmentPlugin() });

export const segmentClient = createClient({
   writeKey: "SEGMENT_KEY",
   trackAppLifecycleEvents: true,
   //additional config options
  });

// below example will call `logEvent` method on UXCam
segmentClient.track(“button-click”, {“button”: true})

segmentClient.screen(“screen1”) // call `tagScreenName` method on UXCam