example_complete.cpp

This is a minimal but complete example using ASMIRA SDK

#include <asmirasdk.h>
#include <string>
#include <thread>
#include <chrono>
 
#ifdef USE_STB_IMAGE_WRITE
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <stb_image_write.h>
 
static void WriteImage(const char* filename, const uint8_t* data, 
                       const uint32_t width, const uint32_t height)
{
    stbi_write_png(filename, width, height, 3, data, width * 3);
}
#endif
 
enum RoomJoinedState {
    RoomJoinedStateUndef,
    RoomJoinedStateReceivedList,
    RoomJoinedStatePending,
    RoomJoinedStateSuccess,
    RoomJoinedStateError
};
 
enum State {
    StateDisconnect,
    StateConnect,
    StateConnecting,
    StateRequestRooms,
    StateRequestRoomsPending,
    StateRequestJoinRoomPending,
    StateReady
};
 
struct context_s {
    asdk::ServerState serverState = asdk::ServerStateUndef;
    RoomJoinedState roomJoinedState = RoomJoinedStateUndef;
    uint16_t clientRoomID = 0;
    State state = StateDisconnect;
    asdk::sdk_t* sdk = nullptr;
    const int serverPort = 30100;
};
 
static bool Connect(context_s& context)
{
#ifdef EXAMPLE_TLS
    asdk::CertificateState state;
    asdk::certificate_t cert;
    if (context.sdk->RequestCertificate("127.0.0.1", context.serverPort + 1, "sender", "sender", &state, &cert) == asdk::StatusOK) {
        puts("Connecting to server...");
        if (context.sdk->ConnectSecured("127.0.0.1", context.serverPort, false, "sender", "sender",
                                        asdk::UserCapabilityViewer, asdk::DeviceCapabilityDisplay, cert.data)) {
            puts("Conencted to server");
            return true;
        }
        else 
            puts("Failed to connect to server");
    }
    else
        puts("Failed to request certificate");
#else
    if (context.sdk->Connect("127.0.0.1", context.serverPort, 5000, true, "test", "password",
                             asdk::UserCapabilityViewer, asdk::DeviceCapabilityBasic, "Test User")) {
        puts("Conencted to server");
        return true;
    }
    else
        puts("Failed to connect to server");
#endif
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return false;
}
 
static bool RequestRooms(context_s& context)
{
    return context.sdk->SendRequest(asdk::RequestRoomListSubscribe) == asdk::StatusOK;
}
 
static bool JoinRoom(context_s& context, const char *roomName)
{
    return context.sdk->SendRequestStr(asdk::RequestRoomJoin, roomName) == asdk::StatusOK;
}
 
int main()
{
    context_s context;
    context.sdk = asdk::Initialize();
    if (context.sdk) {
 
        context.sdk->SetAuthenticateResponseCallback([](const asdk::AuthenticationResponse response, 
                                                        void* opaque /* context* */) {
            context_s* context = reinterpret_cast<context_s*>(opaque);
            if ((response & asdk::AuthenticationResponseSuccess)) {
                context->serverState = asdk::ServerStateConnectedAndAuthenticated;
                puts("Server authenticated your connection");
            }
            else {
                context->serverState = asdk::ServerStateAuthenticateError;
                printf("Server failed(%d) to authenticate your connection", response);
            }
        }, &context);
 
        context.sdk->SetServerStateCallback([](const asdk::ServerState state, void* opaque /* context* */) {
            reinterpret_cast<context_s*>(opaque)->serverState = state;
        }, &context);
 
        context.sdk->SetRoomAnnounceCallback([](const char* roomName, const uint32_t roomID,
                                                const asdk::RoomStateValue state,
                                                const asdk::RoomFlagValue flags,
                                                void* opaque /* context* */) {
            // Got first room, there may be many more
            reinterpret_cast<context_s*>(opaque)->roomJoinedState = RoomJoinedStateReceivedList;
            printf("Room(%s) with ID(%d) announced\n", roomName, roomID);
        }, &context);
 
        context.sdk->SetRoomResponseCallback([](const asdk::Request request, const asdk::RoomResponse response,
                                                const void* optionalData, const uint32_t optionalDataSize, 
                                                void* opaque /* context* */) {
            context_s* context = reinterpret_cast<context_s*>(opaque);
            if (response == asdk::RoomResponseSuccess) {
                context->roomJoinedState = RoomJoinedStateSuccess;
                if (optionalData && optionalDataSize == sizeof(uint16_t)) {
                    context->clientRoomID = *reinterpret_cast<const uint16_t*>(optionalData);
                    context->state = StateReady;
                    printf("Joined room and got asigned ID(%d)\n", context->clientRoomID);
                }
                else {
                    context->roomJoinedState = RoomJoinedStateError;
                    puts("Failed to join room");
                }
            }
            else 
                printf("Failed(%d) to join room on command(%d)\n", response, request);
 
        }, &context);
 
        context.sdk->SetRoomClientAddedCallback([](const uint32_t clientID, const char* userName, 
                                                   const asdk::UserCapabilityValue userCapability,
                                                   const asdk::DeviceCapabilityValue deviceCapability, 
                                                   void* opaque /* context* */) {
            printf("Client(%d) with name(%s) added to room\n", clientID, userName);
        }, & context);
 
        context.sdk->SetRoomClientRemovedCallback([](const uint32_t clientID, void* opaque /* context* */) {
            printf("Client(%d) removed from room\n", clientID);
        }, & context);
 
        context.sdk->SetVideoModeCallback([](const asdk::video_mode_t* videoMode, void* opaque /* context* */) {
            puts("Video mode changed");
        }, &context);
 
        context.sdk->SetVideoOptionsCallback([](const asdk::video_options_t* videoOptions, void* opaque /* context* */) {
            puts("Video options changed");
        }, &context);
 
        context.sdk->SetFrameCallback([](const asdk::frame_t* frame, void* opaque /* context* */) {
#ifdef USE_STB_IMAGE_WRITE
            WriteImage("frame.png", frame->data, frame->width, frame->height);
#endif // USE_STB_IMAGE_WRITE  
        }, &context);
 
        context.sdk->SetEncodedStreamCallback([](const asdk::StreamType type, const void* data, 
                                                 const uint32_t dataSize, void* opaque /* context* */) {
            switch (type) {
            case asdk::StreamTypeUnknown:  
            case asdk::StreamType264Frame: 
            case asdk::StreamType265Frame: 
            case asdk::StreamTypeAV1Frame: 
            case asdk::StreamTypeMPEGTS:   
            case asdk::StreamTypeWEBP:     
                break;
            }
        }, &context);
 
        context.sdk->SetRoomPreviewImageCallback([](const uint32_t roomID, const uint64_t utc, 
                                                     const asdk::ImageFormat imageFormat, 
                                                     const uint8_t* data, const uint32_t size, 
                                                     void* opaque /* context* */) {
            printf("Room(%d) preview image received with format(%d) and size(%d)\n", roomID, imageFormat, size);
        }, & context);
 
        while (true) {
            switch (context.state) {
            case StateDisconnect: 
                context.state = StateConnect;
                context.serverState     = asdk::ServerStateUndef;
                context.roomJoinedState = RoomJoinedStateUndef;
                break;
            case StateConnect:
                if (Connect(context)) context.state = StateConnecting;
                else                  context.state = StateDisconnect;
                break;
            case StateConnecting:
                if (context.serverState == asdk::ServerStateConnectedAndAuthenticated) {
                    context.state = StateRequestRooms;
                    puts("Server authenticated your connection");
                }
                else if (context.serverState == asdk::ServerStateAuthenticateError) {
                    context.state = StateDisconnect;
                    puts("Server failed to authenticate your connection");
                    std::this_thread::sleep_for(std::chrono::seconds(5));
                }
                break;
            case StateRequestRooms:
                if (RequestRooms(context)) context.state = StateRequestRoomsPending;
                else                       context.state = StateDisconnect;
                break;
            case StateRequestRoomsPending:
                if (context.roomJoinedState == RoomJoinedStateReceivedList) {
                    if (JoinRoom(context, "test")) context.state = StateRequestJoinRoomPending;
                    else                           context.state = StateDisconnect;
                }
                break;
            case StateRequestJoinRoomPending:
            case StateReady:
                break;
            }
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    return 0;
}