Unreal Engine

class DemoPushListener: public PushListener {
public:
    using OnRecvPushMessageCallback = std::function<void(const PushMessage &)>;
    using OnRevokePushMessageCallback = std::function<void(const FString &)>;
    using OnNotificationClickedCallback = std::function<void(const FString &)>;
    
    void SetCallback(OnRecvPushMessageCallback recv_cb, OnRevokePushMessageCallback revoke_cb, OnNotificationClickedCallback clicked_cb) {
        on_recv_message_callback_ = std::move(recv_cb);
        on_revoke_message_callback_ = std::move(revoke_cb);
        on_notification_clicked_callback_ = std::move(clicked_cb);
    }
    
    void OnRecvPushMessage(const PushMessage& message) override {
        if (on_recv_message_callback_) {
            on_recv_message_callback_(message);
        }
    }
    
    void OnRevokePushMessage(const FString& messageID) override {
        if (on_revoke_message_callback_) {
            on_revoke_message_callback_(messageID);
        }
    }
    void OnNotificationClicked(const FString& ext) override {
        if (on_notification_clicked_callback_) {
            on_notification_clicked_callback_(ext);
        }
    }
    
private:
    OnRecvPushMessageCallback on_recv_message_callback_;
    OnRevokePushMessageCallback on_revoke_message_callback_;
    OnNotificationClickedCallback on_notification_clicked_callback_;
};

auto listener = new DemoPushListener();
listener.SetCallback(
    [](const PushMessage& message) {
        UE_LOG(LogTemp, Warning, TEXT("Push Called in OnRecvPushMessage. Message title: %s, desc: %s, ext: %s, id: %s"), *message.GetTitle(), *message.GetDesc(), *message.GetExt(), *message.GetMessageID());
    },
    [](const FString& messageID) {
        UE_LOG(LogTemp, Warning, TEXT("Push Called in OnRevokePushMessage. Message id: %s"), *messageID);
    },
    [](const FString& ext) {
        UE_LOG(LogTemp, Warning, TEXT("Push Called in OnNotificationClicked. Message ext: %s"), *ext);
    }
);
PushManager::GetInstance()->AddPushListener(&DEMO_PUSH_LISTENER);

template <class T>
class DemoPushValueCallback : public PushValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T &)>;
    using ErrorCallback = std::function<void(int, const FString &)>;
    
    DemoPushValueCallback<T>() = default;
    ~DemoPushValueCallback() override = default;
    
    void SetCallback(SuccessCallback success_cb, ErrorCallback error_cb) {
        success_callback_ = std::move(success_cb);
        error_callback_ = std::move(error_cb);
    }
    
    void OnSuccess(const T &value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const FString &error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }
    
private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};

auto callback = new DemoPushValueCallback<FString>();
callback->SetCallback(
    [=](const FString &value) {
      UE_LOG(LogTemp, Warning, TEXT("Push succeed, device token is %s"), *value);
      delete callback;
    },
    [=](int error_code, const FString &error_message) {
      UE_LOG(LogTemp, Warning, TEXT("Push failed erro code: %d, desc: %s"), error_code, *error_message);
      delete callback;
    }
);
PushManager::GetInstance()->RegisterPush(your sdkAppId, "your appKey", callback);