Delegates Reference - LCK Documentation

What Problem Does This Solve?

Delegates let you react to LCK events in real-time:

Recording started/stopped
Save progress updates
Button interactions
Camera mode changes
Audio callbacks

Instead of polling state every frame, you bind handlers that fire when events occur. This keeps your code clean and responsive.

When to Use This

Reference this when:

Building custom recording UI
Handling recording lifecycle events
Responding to user interactions
Processing audio data
Tracking save progress

Delegate Types

LCK uses two kinds of delegates:

Type	Usage	Binding Method
Dynamic Multicast	Blueprint-compatible, multiple bindings	`AddDynamic()`
Non-Dynamic Multicast	C++ only, multiple bindings	`AddUObject()` or `AddLambda()`
Raw/Lambda	C++ only, single or multiple bindings	`BindLambda()` or `AddLambda()`

Audio delegates are SINGLE delegates (not multicast). Use BindLambda(), not AddLambda(). Each bind replaces the previous one.

DataModel delegates are non-dynamic multicast. Most delegates on ULCKTabletDataModel (camera mode, mic state, video quality, recording state) use DECLARE_MULTICAST_DELEGATE, not DECLARE_DYNAMIC_MULTICAST_DELEGATE. Bind with AddUObject() or AddLambda(), not AddDynamic().

Recording Lifecycle Delegates

FOnRecordingSaveFinished

What it’s for: Know when recording save completes

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnRecordingSaveFinished, bool, Success);

Declared on: ULCKService Parameters:

Success (bool) — True if save succeeded, false on error

Usage:

// Subscribe (dynamic multicast -- use AddDynamic)
Service->OnRecordingSaveFinished.AddDynamic(this, &AMyActor::HandleSaveFinished);

// Handler
UFUNCTION()
void AMyActor::HandleSaveFinished(bool bSuccess)
{
    if (bSuccess)
    {
        ShowNotification(TEXT("Recording saved!"));
        PlaySuccessSound();
    }
    else
    {
        ShowError(TEXT("Failed to save recording"));
    }
}

FOnRecordingSaveProgress

What it’s for: Update progress bar during save

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnRecordingSaveProgress, float, Progress);

Declared on: ULCKService Parameters:

Progress (float) — Value from 0.0 (start) to 1.0 (complete)

Usage:

Service->OnRecordingSaveProgress.AddDynamic(this, &AMyUI::UpdateProgressBar);

UFUNCTION()
void AMyUI::UpdateProgressBar(float Progress)
{
    ProgressBar->SetPercent(Progress);
    ProgressText->SetText(FText::AsPercent(Progress));
}

FOnRecordingError

What it’s for: Handle recording errors with context

DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
    FOnRecordingError,
    FString, ErrorMessage,
    int32, ErrorCode
);

Declared on: ULCKService Parameters:

ErrorMessage (FString) — Human-readable error description
ErrorCode (int32) — Numeric error code (see ELCKError)

Usage:

Service->OnRecordingError.AddDynamic(this, &AMyActor::HandleRecordingError);

UFUNCTION()
void AMyActor::HandleRecordingError(FString ErrorMessage, int32 ErrorCode)
{
    UE_LOG(LogLCK, Error, TEXT("Recording error %d: %s"), ErrorCode, *ErrorMessage);

    // Show user-friendly message
    ShowErrorDialog(ErrorMessage);

    // Log to analytics
    Analytics->TrackError(TEXT("Recording"), ErrorCode);
}

Camera & Settings Delegates

FOnTabletCameraModeChanged

What it’s for: React to camera mode switches

DECLARE_MULTICAST_DELEGATE_OneParam(FOnTabletCameraModeChanged, UClass*);

Declared on: ULCKTabletDataModel Parameters:

UClass* — The new camera mode class (e.g., ULCKSelfieCameraMode, ULCKFirstPersonCameraMode, ULCKThirdPersonCameraMode)

This is a non-dynamic multicast delegate. Use AddUObject() or AddLambda(), not AddDynamic().

Usage:

// Subscribe (non-dynamic -- use AddUObject, not AddDynamic)
DataModel->OnTabletCameraModeChanged.AddUObject(this, &AMyUI::HandleCameraMode);

// Handler (no UFUNCTION() needed for non-dynamic delegates)
void AMyUI::HandleCameraMode(UClass* ModeClass)
{
    if (ModeClass->IsChildOf(ULCKSelfieCameraMode::StaticClass()))
    {
        CameraModeText->SetText(FText::FromString("Selfie"));
    }
    else if (ModeClass->IsChildOf(ULCKFirstPersonCameraMode::StaticClass()))
    {
        CameraModeText->SetText(FText::FromString("First Person"));
    }
    else if (ModeClass->IsChildOf(ULCKThirdPersonCameraMode::StaticClass()))
    {
        CameraModeText->SetText(FText::FromString("Third Person"));
    }
}

FOnMicStateChanged

What it’s for: Update UI when mic state changes

DECLARE_MULTICAST_DELEGATE_OneParam(FOnMicStateChanged, ELCKMicState);

Declared on: ULCKTabletDataModel Parameters:

ELCKMicState — New microphone state (On, Off, No_Access)

This is a non-dynamic multicast delegate. Use AddUObject() or AddLambda(), not AddDynamic().

Usage:

// Subscribe (non-dynamic -- use AddUObject, not AddDynamic)
DataModel->OnMicStateChanged.AddUObject(this, &AMicButton::UpdateIcon);

void AMicButton::UpdateIcon(ELCKMicState NewState)
{
    switch (NewState)
    {
        case ELCKMicState::On:
            Icon->SetBrush(MicOnTexture);
            Icon->SetColorAndOpacity(FLinearColor::White);
            break;
        case ELCKMicState::Off:
            Icon->SetBrush(MicOffTexture);
            Icon->SetColorAndOpacity(FLinearColor::Gray);
            break;
        case ELCKMicState::No_Access:
            Icon->SetBrush(MicBlockedTexture);
            ShowPermissionPrompt();
            break;
    }
}

FOnVideoQualityChanged

What it’s for: React to quality profile changes

DECLARE_MULTICAST_DELEGATE_OneParam(FOnVideoQualityChanged, ELCKVideoQuality);

Declared on: ULCKTabletDataModel

This is a non-dynamic multicast delegate. Use AddUObject() or AddLambda(), not AddDynamic().

Usage:

DataModel->OnVideoQualityChanged.AddUObject(this, &AMyUI::HandleQualityChanged);

void AMyUI::HandleQualityChanged(ELCKVideoQuality NewQuality)
{
    // Update quality display
}

FOnRecordStateChange

What it’s for: React to recording state changes on the DataModel

DECLARE_MULTICAST_DELEGATE_OneParam(FOnRecordStateChange, ELCKRecordingState);

Declared on: ULCKTabletDataModel

This is a non-dynamic multicast delegate. Use AddUObject() or AddLambda(), not AddDynamic().

Usage:

DataModel->OnRecordStateChanged.AddUObject(this, &AMyUI::HandleRecordStateChanged);

void AMyUI::HandleRecordStateChanged(ELCKRecordingState NewState)
{
    switch (NewState)
    {
        case ELCKRecordingState::Idle:
            // Ready to record
            break;
        case ELCKRecordingState::Recording:
            // Recording in progress
            break;
        case ELCKRecordingState::Saving:
            // Saving to disk
            break;
    }
}

FOnScreenOrientationChanged

What it’s for: React to screen orientation changes

DECLARE_MULTICAST_DELEGATE_OneParam(FOnScreenOrientationChanged, ELCKScreenOrientation);

Declared on: ULCKTabletDataModel

This is a non-dynamic multicast delegate. Use AddUObject() or AddLambda(), not AddDynamic().

Usage:

DataModel->OnScreenOrientationChanged.AddUObject(this, &AMyUI::HandleOrientationChanged);

void AMyUI::HandleOrientationChanged(ELCKScreenOrientation NewOrientation)
{
    // Update UI layout for new orientation
}

UI Interaction Delegates

FOnTapStarted

What it’s for: Handle button presses

DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnTapStarted);

Usage:

RecordButton->OnTapStarted.AddDynamic(this, &AMyActor::HandleRecordButton);

UFUNCTION()
void AMyActor::HandleRecordButton()
{
    if (Service->IsRecording())
    {
        Service->StopRecording();
    }
    else
    {
        Service->StartRecording();
    }
}

LCK buttons include automatic 0.25s cooldown. Don’t add your own debouncing.

FOnStepperValueChanged

What it’s for: Handle stepper control changes (increment/decrement buttons)

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnStepperValueChanged, int8, NewValue);

Parameters:

NewValue (int8) — Direction: -1 (decrease) or +1 (increase)

Usage:

FOVStepper->OnStepperValueChanged.AddDynamic(this, &ACamera::AdjustFOV);

UFUNCTION()
void ACamera::AdjustFOV(int8 Direction)
{
    CurrentFOV += Direction * 5.0f; // Adjust by 5 degrees
    CurrentFOV = FMath::Clamp(CurrentFOV, 30.0f, 120.0f);
    UpdateCamera();
}

FOnPad2DChanged

What it’s for: Handle 2D directional pad input

DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPad2DChanged, FIntPoint, NewValue);

Parameters:

NewValue (FIntPoint) — Direction as (X, Y) where values are -1, 0, or +1

Usage:

Pad2D->OnPad2DChanged.AddDynamic(this, &ANavigator::HandleDirection);

UFUNCTION()
void ANavigator::HandleDirection(FIntPoint Direction)
{
    // Direction.X: -1 (left), 0 (none), +1 (right)
    // Direction.Y: -1 (down), 0 (none), +1 (up)

    if (Direction.X != 0)
    {
        // Handle horizontal
        ScrollHorizontal(Direction.X);
    }

    if (Direction.Y != 0)
    {
        // Handle vertical
        ScrollVertical(Direction.Y);
    }
}

Audio Delegates

FOnRenderAudioDelegate

What it’s for: Process raw audio data from audio sources

DECLARE_MULTICAST_DELEGATE_FourParams(
    FDelegateRenderAudio,
    TArrayView<const float>, // PCM samples (interleaved)
    int32,                    // Channels
    int32,                    // Sample rate (Hz)
    ELCKAudioChannel          // Source channel type
);

typedef FDelegateRenderAudio::FDelegate FOnRenderAudioDelegate;

Parameters:

PCM (TArrayView<const float>) — Interleaved audio samples (32-bit float)
Channels (int32) — Number of channels (typically 2 for stereo)
SampleRate (int32) — Audio sample rate in Hz (typically 48000)
Source (ELCKAudioChannel) — Audio source type (Game, Microphone, VoiceChat)

This is a SINGLE delegate (not multicast). Use BindLambda(), not AddLambda(). Each bind replaces the previous one.Audio callbacks may come from different threads. Use AsyncTask(ENamedThreads::GameThread, ...) if accessing game thread objects.

Usage:

// Bind audio callback (replaces any existing binding)
AudioSource->OnAudioDataDelegate.BindLambda([this](
    TArrayView<const float> PCM,
    int32 Channels,
    int32 SampleRate,
    ELCKAudioChannel SourceChannel)
{
    // PCM format: interleaved 32-bit float samples
    // Example: [L, R, L, R, L, R, ...] for stereo

    // Calculate RMS volume
    float Sum = 0.0f;
    for (float Sample : PCM)
    {
        Sum += Sample * Sample;
    }
    float RMS = FMath::Sqrt(Sum / PCM.Num());

    // Update UI on game thread
    AsyncTask(ENamedThreads::GameThread, [this, RMS]()
    {
        UpdateVolumeIndicator(RMS);
    });
});

Fire the delegate (from audio source implementation):

// Inside ILCKAudioSource::Render() or similar
TArray<float> PCMData = GetAudioBuffer();
OnAudioDataDelegate.ExecuteIfBound(PCMData, 2, 48000, ELCKAudioChannel::Game);

Async Operation Delegates

FOnLCKRecorderBoolResult

What it’s for: Handle async operation results

DECLARE_DELEGATE_OneParam(FOnLCKRecorderBoolResult, bool /*bSuccess*/);

Usage:

Recorder->StartRecordingAsync(
    FOnLCKRecorderBoolResult::CreateLambda([this](bool bSuccess)
    {
        if (bSuccess)
        {
            ShowRecordingIndicator();
            UE_LOG(LogLCK, Log, TEXT("Recording started"));
        }
        else
        {
            ShowError(TEXT("Failed to start recording"));
        }
    })
);

FOnLCKRecorderProgress

What it’s for: Track save/encoding progress

DECLARE_DELEGATE_OneParam(FOnLCKRecorderProgress, float /*Progress*/);

Usage:

Recorder->StopRecordingAsync(
    FOnLCKRecorderBoolResult::CreateLambda([this](bool bSuccess)
    {
        if (bSuccess)
        {
            ShowSuccess(TEXT("Recording saved"));
        }
    }),
    FOnLCKRecorderProgress::CreateLambda([this](float Progress)
    {
        ProgressBar->SetPercent(Progress);
        StatusText->SetText(FText::Format(
            LOCTEXT("SavingProgress", "Saving... {0}%"),
            FText::AsPercent(Progress)
        ));
    })
);

Binding Patterns

Dynamic Delegates (Blueprint-Compatible)

Used for FOnRecordingSaveFinished, FOnRecordingSaveProgress, FOnRecordingError, and UI delegates like FOnTapStarted.

// Header
UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    UFUNCTION()
    void HandleButtonTap();
};

// Implementation
void AMyActor::BeginPlay()
{
    Super::BeginPlay();
    Button->OnTapStarted.AddDynamic(this, &AMyActor::HandleButtonTap);
}

void AMyActor::HandleButtonTap()
{
    // Handle tap
}

Non-Dynamic Multicast (C++ Only)

Used for DataModel delegates like FOnTabletCameraModeChanged, FOnMicStateChanged, FOnVideoQualityChanged, FOnRecordStateChange.

// Header -- no UFUNCTION() needed
UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    void HandleCameraMode(UClass* ModeClass);
    void HandleMicState(ELCKMicState NewState);
};

// Implementation
void AMyActor::BeginPlay()
{
    Super::BeginPlay();

    ULCKTabletDataModel* DataModel = Tablet->GetDataModel();

    // Use AddUObject for member functions
    DataModel->OnTabletCameraModeChanged.AddUObject(this, &AMyActor::HandleCameraMode);
    DataModel->OnMicStateChanged.AddUObject(this, &AMyActor::HandleMicState);

    // Or use AddLambda for inline handlers
    DataModel->OnVideoQualityChanged.AddLambda([this](ELCKVideoQuality NewQuality)
    {
        UpdateQualityDisplay(NewQuality);
    });
}

Lambda Binding (C++ Only)

// Non-dynamic multicast delegate (DataModel events)
DataModel->OnTabletCameraModeChanged.AddLambda([this](UClass* ModeClass)
{
    UpdateCameraModeUI(ModeClass);
});

// Dynamic multicast delegate (UI events -- use AddDynamic, not AddLambda)
Button->OnTapStarted.AddDynamic(this, &AMyActor::OnRecordButtonTapped);

// Single delegate (audio)
AudioSource->OnAudioDataDelegate.BindLambda([this](auto PCM, auto Channels, auto SampleRate, auto Source)
{
    ProcessAudio(PCM);
});

Removing Bindings

// Dynamic delegate
Button->OnTapStarted.RemoveDynamic(this, &AMyActor::HandleButtonTap);

// Non-dynamic delegate with handle
FDelegateHandle Handle = DataModel->OnMicStateChanged.AddUObject(this, &AMyActor::HandleMicState);
DataModel->OnMicStateChanged.Remove(Handle);

// Lambda with handle
FDelegateHandle LambdaHandle = Delegate.AddLambda([](){ /* ... */ });
Delegate.Remove(LambdaHandle);

// Clear all
Delegate.Clear();

Complete Example: Recording UI

UCLASS()
class ARecordingUI : public AActor
{
    GENERATED_BODY()

protected:
    virtual void BeginPlay() override
    {
        Super::BeginPlay();

        ULCKService* Service = GetLCKService();
        ALCKTablet* Tablet = FindTablet();

        if (!Service || !Tablet) return;

        ULCKTabletDataModel* DataModel = Tablet->GetDataModel();

        // Recording lifecycle (dynamic multicast -- use AddDynamic)
        Service->OnRecordingSaveFinished.AddDynamic(this, &ARecordingUI::OnSaveFinished);
        Service->OnRecordingSaveProgress.AddDynamic(this, &ARecordingUI::OnSaveProgress);
        Service->OnRecordingError.AddDynamic(this, &ARecordingUI::OnError);

        // State changes (non-dynamic multicast -- use AddUObject)
        DataModel->OnRecordStateChanged.AddUObject(this, &ARecordingUI::OnStateChanged);
        DataModel->OnMicStateChanged.AddUObject(this, &ARecordingUI::OnMicChanged);

        // UI interactions (dynamic multicast -- use AddDynamic)
        RecordButton->OnTapStarted.AddDynamic(this, &ARecordingUI::OnRecordButton);
        MicButton->OnTapStarted.AddDynamic(this, &ARecordingUI::OnMicButton);
    }

    UFUNCTION()
    void OnRecordButton()
    {
        if (Service->IsRecording())
            Service->StopRecording();
        else
            Service->StartRecording();
    }

    UFUNCTION()
    void OnMicButton()
    {
        bool bCurrentState = Service->IsMicrophoneEnabled();
        Service->SetMicrophoneEnabled(!bCurrentState);
    }

    // Non-dynamic delegate handler (no UFUNCTION needed)
    void OnStateChanged(ELCKRecordingState NewState)
    {
        switch (NewState)
        {
            case ELCKRecordingState::Recording:
                RecordButton->SetText(FText::FromString("Stop"));
                RecordingIndicator->SetVisibility(ESlateVisibility::Visible);
                break;
            case ELCKRecordingState::Idle:
                RecordButton->SetText(FText::FromString("Record"));
                RecordingIndicator->SetVisibility(ESlateVisibility::Hidden);
                break;
            case ELCKRecordingState::Saving:
                ProgressPanel->SetVisibility(ESlateVisibility::Visible);
                break;
        }
    }

    UFUNCTION()
    void OnSaveProgress(float Progress)
    {
        ProgressBar->SetPercent(Progress);
    }

    UFUNCTION()
    void OnSaveFinished(bool bSuccess)
    {
        ProgressPanel->SetVisibility(ESlateVisibility::Hidden);

        if (bSuccess)
            ShowNotification(TEXT("Recording saved!"));
    }

    UFUNCTION()
    void OnError(FString ErrorMessage, int32 ErrorCode)
    {
        ShowErrorDialog(ErrorMessage);
    }

    // Non-dynamic delegate handler (no UFUNCTION needed)
    void OnMicChanged(ELCKMicState NewState)
    {
        switch (NewState)
        {
            case ELCKMicState::On:
                MicIcon->SetBrush(MicOnTexture);
                break;
            case ELCKMicState::Off:
                MicIcon->SetBrush(MicOffTexture);
                break;
            case ELCKMicState::No_Access:
                ShowPermissionDialog();
                break;
        }
    }
};

Key Takeaways

Use delegates for events — Don’t poll state every frame

Dynamic vs non-dynamic matters — DataModel delegates use AddUObject/AddLambda, Service delegates use AddDynamic

Audio delegates are SINGLE — Use BindLambda, not AddLambda

Thread safety matters — Audio callbacks may come from any thread

Remove bindings on cleanup — Prevent dangling pointers

Dynamic delegates for Blueprint — Use UFUNCTION handlers with AddDynamic

Error Codes — Error handling patterns
Service Interface — ULCKService API reference
Architecture — How delegates flow through the system

​What Problem Does This Solve?

​When to Use This

​Delegate Types

​Recording Lifecycle Delegates

​FOnRecordingSaveFinished

​FOnRecordingSaveProgress

​FOnRecordingError

​Camera & Settings Delegates

​FOnTabletCameraModeChanged

​FOnMicStateChanged

​FOnVideoQualityChanged

​FOnRecordStateChange

​FOnScreenOrientationChanged

​UI Interaction Delegates

​FOnTapStarted

​FOnStepperValueChanged

​FOnPad2DChanged

​Audio Delegates

​FOnRenderAudioDelegate

​Async Operation Delegates

​FOnLCKRecorderBoolResult

​FOnLCKRecorderProgress

​Binding Patterns

​Dynamic Delegates (Blueprint-Compatible)

​Non-Dynamic Multicast (C++ Only)

​Lambda Binding (C++ Only)

​Removing Bindings

​Complete Example: Recording UI

​Key Takeaways

​Related

What Problem Does This Solve?

When to Use This

Delegate Types

Recording Lifecycle Delegates

FOnRecordingSaveFinished

FOnRecordingSaveProgress

FOnRecordingError

Camera & Settings Delegates

FOnTabletCameraModeChanged

FOnMicStateChanged

FOnVideoQualityChanged

FOnRecordStateChange

FOnScreenOrientationChanged

UI Interaction Delegates

FOnTapStarted

FOnStepperValueChanged

FOnPad2DChanged

Audio Delegates

FOnRenderAudioDelegate

Async Operation Delegates

FOnLCKRecorderBoolResult

FOnLCKRecorderProgress

Binding Patterns

Dynamic Delegates (Blueprint-Compatible)

Non-Dynamic Multicast (C++ Only)

Lambda Binding (C++ Only)

Removing Bindings

Complete Example: Recording UI

Key Takeaways

Related