Skip to content

Process Customization

This article outlines the available Face SDK process customization options.

Session Video Recording

You can decide whether to record the liveness assessment session and how to save the video to the server:

  • Record the session and send the video to the server with an additional request (default setting). This provides quicker user response, but there's a risk of video loss if the application is closed before transmission completion.
  • Record the session and send the video to the server with a Liveness package. This may result in longer response times, as the response appears only after the package reaches the server completely.
  • Disable video recording.

Recording the session and sending the video to the server with an additional request:

let configuration = LivenessConfiguration {
    $0.recordingProcess = .asynchronousUpload
}

FaceSDK.service.startLiveness(from: viewController,
    animated: true,
    configuration: configuration) { response in

}

RFSLivenessConfiguration *configuration = [RFSLivenessConfiguration configurationWithBuilder:^(RFSLivenessConfigurationBuilder * _Nonnull builder) {
    builder.recordingProcess = RFSRecordingProcessAsynchronousUpload;
}];

[RFSFaceSDK.service startLivenessFrom:viewController
    animated:YES
    configuration:configuration
    onLiveness:^(RFSLivenessResponse * _Nonnull response) {

} completion:^{

}];

val configuration = LivenessConfiguration.Builder()
    .setRecordingProcess(RecordingProcess.ASYNCHRONOUS_UPLOAD)
    .build()
FaceSDK.Instance().startLiveness(
    context,
    configuration
) { response -> }

LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .setRecordingProcess(RecordingProcess.ASYNCHRONOUS_UPLOAD)
    .build();
FaceSDK.Instance().startLiveness(context,
    configuration,
    response -> {

        });

var livenessResponse = await FaceSDK.instance.startLiveness(
  config: LivenessConfig(
    recordingProcess: RecordingProcess.ASYNCHRONOUS_UPLOAD,
  ),
);

var livenessResponse = await FaceSDK.instance.startLiveness({
  config: new LivenessConfig({
    recordingProcess: RecordingProcess.ASYNCHRONOUS_UPLOAD,
  }),
})

// Android
LivenessConfiguration.Builder config = new();
config.SetRecordingProcess(RecordingProcess.AsynchronousUpload);
FaceSDK.Instance().StartLiveness(Platform.AppContext, config.Build(), this);

// iOS
RFSFaceSDK.Service.StartLivenessFrom(CurrentPresenter, true, RFSLivenessConfiguration.ConfigurationWithBuilder((RFSLivenessConfigurationBuilder builder) =>
{
    builder.RecordingProcess = RFSRecordingProcess.AsynchronousUpload;
}), (RFSLivenessResponse response) =>
{
}, () => { });

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.ASYNCHRONOUS_UPLOAD
}, (response) => { }, _ => { })

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.ASYNCHRONOUS_UPLOAD
}, function (m) { }, function (e) { })

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.ASYNCHRONOUS_UPLOAD
})

Recording the session and sending the video to the server with a Liveness package:

let configuration = LivenessConfiguration {
    $0.recordingProcess = .synchronousUpload
}

FaceSDK.service.startLiveness(from: viewController,
    animated: true,
    configuration: configuration) { response in

}

RFSLivenessConfiguration *configuration = [RFSLivenessConfiguration configurationWithBuilder:^(RFSLivenessConfigurationBuilder * _Nonnull builder) {
    builder.recordingProcess = RFSRecordingProcessSynchronousUpload;
}];

[RFSFaceSDK.service startLivenessFrom:viewController
    animated:YES
    configuration:configuration
    onLiveness:^(RFSLivenessResponse * _Nonnull response) {

} completion:^{

}];

val configuration = LivenessConfiguration.Builder()
    .setRecordingProcess(RecordingProcess.SYNCHRONOUS_UPLOAD)
    .build()
FaceSDK.Instance().startLiveness(
    context,
    configuration
) { response -> }

LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .setRecordingProcess(RecordingProcess.SYNCHRONOUS_UPLOAD)
    .build();
FaceSDK.Instance().startLiveness(context,
    configuration,
    response -> {

        });

var livenessResponse = await FaceSDK.instance.startLiveness(
  config: LivenessConfig(
    recordingProcess: RecordingProcess.SYNCHRONOUS_UPLOAD,
  ),
);

var livenessResponse = await FaceSDK.instance.startLiveness({
  config: new LivenessConfig({
    recordingProcess: RecordingProcess.SYNCHRONOUS_UPLOAD,
  }),
})

// Android
LivenessConfiguration.Builder config = new();
config.SetRecordingProcess(RecordingProcess.SynchronousUpload);
FaceSDK.Instance().StartLiveness(Platform.AppContext, config.Build(), this);

// iOS
RFSFaceSDK.Service.StartLivenessFrom(CurrentPresenter, true, RFSLivenessConfiguration.ConfigurationWithBuilder((RFSLivenessConfigurationBuilder builder) =>
{
    builder.RecordingProcess = RFSRecordingProcess.SynchronousUpload;
}), (RFSLivenessResponse response) =>
{
}, () => { });

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.SYNCHRONOUS_UPLOAD
}, (response) => { }, _ => { })

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.SYNCHRONOUS_UPLOAD
}, function (m) { }, function (e) { })

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.SYNCHRONOUS_UPLOAD
})

Disabling the session recording:

let configuration = LivenessConfiguration {
    $0.recordingProcess = .notUpload
}

FaceSDK.service.startLiveness(from: viewController, 
    animated: true,  
    configuration: configuration) { response in

}

RFSLivenessConfiguration *configuration = [RFSLivenessConfiguration configurationWithBuilder:^(RFSLivenessConfigurationBuilder * _Nonnull builder) {
    builder.recordingProcess = RFSRecordingProcessNotUpload;
  }];

[RFSFaceSDK.service startLivenessFrom:viewController
    animated:YES
    configuration:configuration
    onLiveness:^(RFSLivenessResponse * _Nonnull response) {

} completion:^{

}];

val configuration = LivenessConfiguration.Builder()
    .setRecordingProcess(RecordingProcess.NOT_UPLOAD)
    .build()
FaceSDK.Instance().startLiveness(
    context,
    configuration
) { response -> }

LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .setRecordingProcess(RecordingProcess.NOT_UPLOAD)
    .build();
FaceSDK.Instance().startLiveness(context,
    configuration,
    response -> {

        });

var livenessResponse = await FaceSDK.instance.startLiveness(
  config: LivenessConfig(
    recordingProcess: RecordingProcess.NOT_UPLOAD,
  ),
);

var livenessResponse = await FaceSDK.instance.startLiveness({
  config: new LivenessConfig({
    recordingProcess: RecordingProcess.NOT_UPLOAD,
  }),
})

// Android
LivenessConfiguration.Builder config = new();
config.SetRecordingProcess(RecordingProcess.NotUpload);
FaceSDK.Instance().StartLiveness(Platform.AppContext, config.Build(), this);

// iOS
RFSFaceSDK.Service.StartLivenessFrom(CurrentPresenter, true, RFSLivenessConfiguration.ConfigurationWithBuilder((RFSLivenessConfigurationBuilder builder) =>
{
    builder.RecordingProcess = RFSRecordingProcess.NotUpload;
}), (RFSLivenessResponse response) =>
{
}, () => { });

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.NOT_UPLOAD
}, (response) => { }, _ => { })

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.NOT_UPLOAD
}, function (m) { }, function (e) { })

FaceSDK.startLiveness({
  recordingProcess: RecordingProcess.NOT_UPLOAD
})

Turning Off Vibration

For the Liveness and Capture features, for each correct action a vibration signal is turned on by default:

  • When the user aligns their face for a selfie and the system captures the frame (Liveness and Capture).
  • As the user turns their head to the required segment and a frame is captured. This process is repeated for each required head movement segment, providing feedback through vibration each time a frame is successfully captured (Liveness).

To turn the vibration signal off, use the following code blocks.

Capture

let configuration = FaceCaptureConfiguration {
    $0.vibrateOnSteps = false
}
FaceSDK.service.presentFaceCaptureViewController(from: viewController,
    animated: true,
    configuration: configuration) { response in
    // handle response
} completion: {
    // handle completion
}

RFSFaceCaptureConfiguration *configuration = [RFSFaceCaptureConfiguration configurationWithBuilder:^(RFSFaceCaptureConfigurationBuilder *builder) {
    builder.vibrateOnSteps = NO;
}];

[RFSFaceSDK.service presentFaceCaptureViewControllerFrom:self.viewController
    animated:YES 
    configuration:configuration
    onCapture:^(RFSFaceCaptureResponse *response) {

} completion:^{

}];

val configuration: FaceCaptureConfiguration = FaceCaptureConfiguration.Builder()
    .setVibrateOnStep(false)
    .build()

FaceCaptureConfiguration configuration = new FaceCaptureConfiguration.Builder()
    .setVibrateOnStep(false)
    .build();

var config = FaceCaptureConfig(
  vibrateOnSteps: false,
);

var config = new FaceCaptureConfig({
  vibrateOnSteps: false,
})

// Android
FaceCaptureConfiguration.Builder config = new();
config.SetVibrateOnStep(false);
FaceSDK.Instance().PresentFaceCaptureActivity(Platform.AppContext, config.Build(), this);

// iOS
RFSFaceSDK.Service.PresentFaceCaptureViewControllerFrom(CurrentPresenter, true, RFSFaceCaptureConfiguration.ConfigurationWithBuilder((RFSFaceCaptureConfigurationBuilder builder) =>
{
    builder.VibrateOnSteps = false;
}), (RFSFaceCaptureResponse captureResponse) =>
{
}, null);

FaceSDK.startFaceCapture({
  vibrateOnSteps: false
}, _ => { }, _ => { })

FaceSDK.startFaceCapture({
  vibrateOnSteps: false
}, function (m) { }, function (e) { })

FaceSDK.startFaceCapture({
  vibrateOnSteps: false
})

Liveness

let configuration = LivenessConfiguration {
    $0.vibrateOnSteps = false
    }

FaceSDK.service.startLiveness(from: viewController,
    animated: true,
    configuration: configuration1) { response in
    // handle response
    }

RFSLivenessConfiguration *configuration = [RFSLivenessConfiguration configurationWithBuilder:^(RFSLivenessConfigurationBuilder * _Nonnull builder) {
    builder.vibrateOnSteps = NO;
}];

[RFSFaceSDK.service startLivenessFrom:viewController
    animated:YES
    configuration:configuration
    onLiveness:^(RFSLivenessResponse * _Nonnull response) {

} completion:^{

}];

val configuration: LivenessConfiguration = LivenessConfiguration.Builder()
    .setVibrateOnStep(false)
    .build()

LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .setVibrateOnStep(false)
    .build();

var config = LivenessConfig(
  vibrateOnSteps: false,
);

var config = new LivenessConfig({
  vibrateOnSteps: false,
})

// Android
LivenessConfiguration.Builder config = new();
config.SetVibrateOnStep(false);
FaceSDK.Instance().StartLiveness(Platform.AppContext, config.Build(), this);

// iOS
RFSFaceSDK.Service.StartLivenessFrom(CurrentPresenter, true, RFSLivenessConfiguration.ConfigurationWithBuilder((RFSLivenessConfigurationBuilder builder) =>
{
    builder.VibrateOnSteps = false;
}), (RFSLivenessResponse response) =>
{
}, () => { });

FaceSDK.startLiveness({
  vibrateOnSteps: false
}, _ => { }, _ => { })

FaceSDK.startLiveness({
  vibrateOnSteps: false
}, function (m) { }, function (e) { })

FaceSDK.startLiveness({
  vibrateOnSteps: false
})

Configuring Device Orientation

When an application is running on a tablet device, the device may be physically positioned in landscape orientation. In such cases, to ensure the UI displays correctly, you need to enable the appropriate interface orientation.

Info

Note that on iPad, when restricting portrait or landscape orientation in your application, the supportedInterfaceOrientations system method is used. This method is triggered each time the device orientation changes, allowing the Face SDK to respond accordingly.

However, on iPad, applications are launched in multitasking mode by default, and in this mode, supportedInterfaceOrientations is not called by the system. This is default iOS behavior and not specific to the SDK. As a result, any orientation-restricting logic based on this method will not function correctly out of the box.

To ensure proper orientation handling on iPad, enable the "Requires full screen" flag in your project’s Target settings. Once this flag is enabled, the application will run in full screen on iPad, and the system will begin invoking supportedInterfaceOrientations as expected. This ensures the Face SDK can track and handle orientation changes correctly.

You can find more information in iOS developer documentation.

There are three screen orientation options available:

  • Landscape only, where the interface is fixed in horizontal mode regardless of device rotation.
  • Portrait only, which keeps the screen in a vertical layout at all times.
  • Both Portrait and Landscape orientations, allowing the screen to automatically rotate based on how the user holds the device.

Capture

  • Portrait
let configuration = FaceCaptureConfiguration {
    $0.screenOrientation = [.portrait]
}
FaceSDK.service.presentFaceCaptureViewController(from: viewController,
    animated: true,
    configuration: configuration) { response in
    // handle response
} completion: {
    // handle completion
}

RFSFaceCaptureConfiguration *configuration = [RFSFaceCaptureConfiguration configurationWithBuilder:^(RFSFaceCaptureConfigurationBuilder *builder) {
    builder.screenOrientation = RFSScreenOrientationPortrait;
}];

[RFSFaceSDK.service presentFaceCaptureViewControllerFrom:viewController
    animated:YES
    configuration:configuration
    onCapture:^(RFSFaceCaptureResponse *response) {

} completion:^{

}];

val configuration: FaceCaptureConfiguration = FaceCaptureConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.PORTRAIT)
    .build()

FaceCaptureConfiguration configuration = new FaceCaptureConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.PORTRAIT)
    .build();

var config = new FaceCaptureConfig(
  screenOrientation: [ScreenOrientation.PORTRAIT],
);

var config = new FaceCaptureConfig({
  screenOrientation: [ScreenOrientation.PORTRAIT],
});

// Android
FaceCaptureConfiguration configuration = new FaceCaptureConfiguration.Builder()
    .SetScreenOrientation(ScreenOrientation.Portrait)
    .Build();

// iOS
RFSFaceCaptureConfiguration.ConfigurationWithBuilder((RFSFaceCaptureConfigurationBuilder builder) => {
    builder.ScreenOrientation = RFSScreenOrientation.Portrait;
});

var config = new FaceCaptureConfig()
config.screenOrientation = [Enum.ScreenOrientation.PORTRAIT]

var config = new FaceCaptureConfig()
config.screenOrientation = [Enum.ScreenOrientation.PORTRAIT]

var config = new FaceCaptureConfig()
config.screenOrientation = [Enum.ScreenOrientation.PORTRAIT]
  • Landscape
let configuration = FaceCaptureConfiguration {
    $0.screenOrientation = [.landscape]
}
FaceSDK.service.presentFaceCaptureViewController(from: viewController,
    animated: true,
    configuration: configuration) { response in
    // handle response
} completion: {
    // handle completion
}

RFSFaceCaptureConfiguration *configuration = [RFSFaceCaptureConfiguration configurationWithBuilder:^(RFSFaceCaptureConfigurationBuilder *builder) {
    builder.screenOrientation = RFSScreenOrientationLandscape;
}];

[RFSFaceSDK.service presentFaceCaptureViewControllerFrom:viewController
                                                animated:YES
                                        configuration:configuration
                                            onCapture:^(RFSFaceCaptureResponse *response) {

} completion:^{

}];

val configuration: FaceCaptureConfiguration = FaceCaptureConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.LANDSCAPE)
    .build()

FaceCaptureConfiguration configuration = new FaceCaptureConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.LANDSCAPE)
    .build();

var config = new FaceCaptureConfig(
  screenOrientation: [ScreenOrientation.LANDSCAPE],
);

var config = new FaceCaptureConfig({
  screenOrientation: [ScreenOrientation.LANDSCAPE],
});

// Android
FaceCaptureConfiguration configuration = new FaceCaptureConfiguration.Builder()
    .SetScreenOrientation(ScreenOrientation.Landscape)
    .Build();

// iOS
RFSFaceCaptureConfiguration.ConfigurationWithBuilder((RFSFaceCaptureConfigurationBuilder builder) => {
    builder.ScreenOrientation = RFSScreenOrientation.Landscape;
});

var config = new FaceCaptureConfig()
config.screenOrientation = [Enum.ScreenOrientation.LANDSCAPE]

var config = new FaceCaptureConfig()
config.screenOrientation = [Enum.ScreenOrientation.LANDSCAPE]

var config = new FaceCaptureConfig()
config.screenOrientation = [Enum.ScreenOrientation.LANDSCAPE]
  • Portrait and landscape
let configuration = FaceCaptureConfiguration {
    $0.screenOrientation = [.portrait, .landscape]
}
FaceSDK.service.presentFaceCaptureViewController(from: viewController,
    animated: true,
    configuration: configuration) { response in
    // handle response
} completion: {
    // handle completion
}

RFSFaceCaptureConfiguration *configuration = [RFSFaceCaptureConfiguration configurationWithBuilder:^(RFSFaceCaptureConfigurationBuilder *builder) {
    builder.screenOrientation = RFSScreenOrientationPortrait | RFSScreenOrientationLandscape;
}];

[RFSFaceSDK.service presentFaceCaptureViewControllerFrom:viewController
    animated:YES
    configuration:configuration
    onCapture:^(RFSFaceCaptureResponse *response) {

} completion:^{

}];

val configuration: FaceCaptureConfiguration = FaceCaptureConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.PORTRAIT, ScreenOrientation.LANDSCAPE)
    .build()

FaceCaptureConfiguration configuration = new FaceCaptureConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.PORTRAIT, ScreenOrientation.LANDSCAPE)
    .build();

var config = new FaceCaptureConfig(
  screenOrientation: [
    ScreenOrientation.PORTRAIT,
    ScreenOrientation.LANDSCAPE
  ],
);

var config = new FaceCaptureConfig({
  screenOrientation: [
    ScreenOrientation.PORTRAIT,
    ScreenOrientation.LANDSCAPE
  ],
})

// Android
FaceCaptureConfiguration configuration = new FaceCaptureConfiguration.Builder()
    .SetScreenOrientation(ScreenOrientation.Portrait, ScreenOrientation.Landscape)
    .Build();

// iOS
RFSFaceCaptureConfiguration.ConfigurationWithBuilder((RFSFaceCaptureConfigurationBuilder builder) => {
    builder.ScreenOrientation = RFSScreenOrientation.Portrait | RFSScreenOrientation.Landscape;
});

var config = new FaceCaptureConfig()
config.screenOrientation = [
  Enum.ScreenOrientation.PORTRAIT,
  Enum.ScreenOrientation.LANDSCAPE
]

var config = new FaceCaptureConfig()
config.screenOrientation = [
  Enum.ScreenOrientation.PORTRAIT,
  Enum.ScreenOrientation.LANDSCAPE
]

var config = new FaceCaptureConfig()
config.screenOrientation = [
  Enum.ScreenOrientation.PORTRAIT,
  Enum.ScreenOrientation.LANDSCAPE
]

Liveness

  • Portrait
let configuration = LivenessConfiguration {
    $0.screenOrientation = [.portrait]
}

FaceSDK.service.startLiveness(from: viewController,
    animated: true,
    configuration: configuration) { response in
    // handle response
}

RFSLivenessConfiguration *configuration = [RFSLivenessConfiguration configurationWithBuilder:^(RFSLivenessConfigurationBuilder * _Nonnull builder) {
    builder.screenOrientation = RFSScreenOrientationPortrait;
}];

[RFSFaceSDK.service startLivenessFrom:viewController
    animated:YES
    configuration:configuration
    onLiveness:^(RFSLivenessResponse * _Nonnull response) {

} completion:^{

}];

val configuration: LivenessConfiguration = LivenessConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.PORTRAIT)
    .build()

LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.PORTRAIT)
    .build();

var config = new LivenessConfig(
  screenOrientation: [ScreenOrientation.PORTRAIT],
);

var config = new LivenessConfig({
  screenOrientation: [ScreenOrientation.PORTRAIT],
});

// Android
LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .SetScreenOrientation(ScreenOrientation.Portrait)
    .Build();

// iOS
RFSLivenessConfiguration.ConfigurationWithBuilder((RFSLivenessConfigurationBuilder builder) => {
    builder.ScreenOrientation = RFSScreenOrientation.Portrait;
});

var config = new LivenessConfig()
config.screenOrientation = [ScreenOrientation.PORTRAIT]

var config = new LivenessConfig()
config.screenOrientation = [ScreenOrientation.PORTRAIT]

var config = new LivenessConfig()
config.screenOrientation = [ScreenOrientation.PORTRAIT]
  • Landscape
let configuration = LivenessConfiguration {
    $0.screenOrientation = [.landscape]
}

FaceSDK.service.startLiveness(from: viewController,
    animated: true,
    configuration: configuration) { response in
    // handle response
}

RFSLivenessConfiguration *configuration = [RFSLivenessConfiguration configurationWithBuilder:^(RFSLivenessConfigurationBuilder * _Nonnull builder) {
    builder.screenOrientation = RFSScreenOrientationLandscape;
}];

[RFSFaceSDK.service startLivenessFrom:viewController
    animated:YES
    configuration:configuration
    onLiveness:^(RFSLivenessResponse * _Nonnull response) {

} completion:^{

}];

val configuration: LivenessConfiguration = LivenessConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.LANDSCAPE)
    .build()

LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.LANDSCAPE)
    .build();

var config = new LivenessConfig(
  screenOrientation: [ScreenOrientation.LANDSCAPE],
);

var config = new LivenessConfig({
  screenOrientation: [ScreenOrientation.LANDSCAPE],
});

// Android
LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .SetScreenOrientation(ScreenOrientation.Landscape)
    .Build();

// iOS
RFSLivenessConfiguration.ConfigurationWithBuilder((RFSLivenessConfigurationBuilder builder) => {
    builder.ScreenOrientation = RFSScreenOrientation.Landscape;
});

var config = new LivenessConfig()
config.screenOrientation = [ScreenOrientation.LANDSCAPE]

var config = new LivenessConfig()
config.screenOrientation = [ScreenOrientation.LANDSCAPE]

var config = new LivenessConfig()
config.screenOrientation = [ScreenOrientation.LANDSCAPE]
  • Portrait and landscape
let configuration = LivenessConfiguration {
    $0.screenOrientation = [.portrait, .landscape]
}

FaceSDK.service.startLiveness(from: viewController,
    animated: true,
    configuration: configuration) { response in
    // handle response
}

RFSLivenessConfiguration *configuration = [RFSLivenessConfiguration configurationWithBuilder:^(RFSLivenessConfigurationBuilder * _Nonnull builder) {
    builder.screenOrientation = RFSScreenOrientationPortrait | RFSScreenOrientationLandscape;
}];

[RFSFaceSDK.service startLivenessFrom:viewController
    animated:YES
    configuration:configuration
    onLiveness:^(RFSLivenessResponse * _Nonnull response) {

} completion:^{

}];

val configuration: LivenessConfiguration = LivenessConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.PORTRAIT, ScreenOrientation.LANDSCAPE)
    .build()

LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .setScreenOrientation(ScreenOrientation.PORTRAIT, ScreenOrientation.LANDSCAPE)
    .build();

var config = new LivenessConfig(
  screenOrientation: [
    ScreenOrientation.PORTRAIT,
    ScreenOrientation.LANDSCAPE
  ],
);

var config = new LivenessConfig({
  screenOrientation: [
    ScreenOrientation.PORTRAIT,
    ScreenOrientation.LANDSCAPE
  ],
})

// Android
LivenessConfiguration configuration = new LivenessConfiguration.Builder()
    .SetScreenOrientation(ScreenOrientation.Portrait, ScreenOrientation.Landscape)
    .Build();

// iOS
RFSLivenessConfiguration.ConfigurationWithBuilder((RFSLivenessConfigurationBuilder builder) => {
    builder.ScreenOrientation = RFSScreenOrientation.Portrait | RFSScreenOrientation.Landscape;
});

var config = new LivenessConfig()
config.screenOrientation = [
  ScreenOrientation.PORTRAIT,
  ScreenOrientation.LANDSCAPE
]

var config = new LivenessConfig()
config.screenOrientation = [
  ScreenOrientation.PORTRAIT,
  ScreenOrientation.LANDSCAPE
]

var config = new LivenessConfig()
config.screenOrientation = [
  ScreenOrientation.PORTRAIT,
  ScreenOrientation.LANDSCAPE
]