example_basic.cpp

Basic usage of ASMIRA SDK.

Basic usage of ASMIRA SDK

/****************************************************************
* Name:       example_basic.cpp
* Purpose:    Smallest useful ASMIRA SDK client: connect, join a
*             room, and receive decoded video frames.
* Copyright:  AnsuR Technologies
****************************************************************/

#include <asmirasdk.h>
#include <chrono>
#include <thread>

struct context_t {
    asdk::sdk_t* sdk = nullptr;
    asdk::ServerState serverState = asdk::ServerStateUndef;
    bool roomListReceived = false;
    bool roomJoined = false;
    uint32_t framesReceived = 0;
};
 
int main()
{
    context_t context;
 
    // Loads asmirasdk.dll / libasmirasdk.so and checks the version.
    context.sdk = asdk::Initialize();
    if (!context.sdk) {
        puts("Failed to initialize the ASMIRA SDK");
        return 1;
    }
 
    // Install the callbacks before connecting. Each one runs on an SDK thread,
    // so keep the work short and never block.
    context.sdk->SetServerStateCallback([](const asdk::ServerState serverState,
                                           void* opaque) {
        reinterpret_cast<context_t*>(opaque)->serverState = serverState;
    }, &context);
 
    // The response is a bit set, so test the bit rather than comparing.
    context.sdk->SetAuthenticateResponseCallback([](const asdk::AuthenticationResponse response,
                                                   void*) {
        if ((response & asdk::AuthenticationResponseSuccess))
            puts("Authenticated");
        else
            printf("Login refused (0x%x)\n", response);
    });
 
    // Announced once per room after RequestRoomListSubscribe.
    context.sdk->SetRoomAnnounceCallback([](const char* roomName, const uint32_t roomID,
                                            const asdk::RoomStateValue state,
                                            const asdk::RoomFlagValue flags, void* opaque) {
        printf("Room \"%s\" (id %u)%s%s\n", roomName, roomID,
               (state & asdk::RoomStatePassword) ? " [password]" : "",
               (flags & asdk::RoomFlagChatViewers) ? " [chat]" : "");
        reinterpret_cast<context_t*>(opaque)->roomListReceived = true;
    }, &context);
 
    // Answers SendRequest and SendRequestStr. optionalData carries any payload
    // the request produced and is valid for the duration of this call only.
    context.sdk->SetRoomResponseCallback([](const asdk::Request request,
                                            const asdk::RoomResponse response,
                                            const void*, const uint32_t, void* opaque) {
        if (request == asdk::RequestRoomJoin)
            reinterpret_cast<context_t*>(opaque)->roomJoined =
                (response == asdk::RoomResponseSuccess);
    }, &context);
 
    // Decoded RGB video. frame and frame->data are only valid for the duration
    // of this call, so copy anything that has to outlive it.
    context.sdk->SetFrameCallback([](const asdk::frame_t* frame, void* opaque) {
        context_t* context = reinterpret_cast<context_t*>(opaque);
        if (++context->framesReceived == 1)
            printf("First frame: %dx%d\n", frame->width, frame->height);
    }, &context);
 
    // Use ConnectSecured with a certificate from RequestCertificate for TLS.
    if (context.sdk->Connect("127.0.0.1", 30100, 5000, true, "test", "password",
                             asdk::UserCapabilityViewer, asdk::DeviceCapabilityBasic,
                             "Basic Example") != asdk::StatusOK) {
        printf("Connect failed: %s\n", context.sdk->errorStr);
        context.sdk->Unload();
        return 1;
    }
 
    // Connecting and joining are asynchronous: ask, then wait for the callback
    // to report the result.
    const asdk::TimePointSteady start = asdk::TimeNowSteady();
    bool subscribed = false;
    bool joinRequested = false;
 
    while (asdk::TimeSpentSteady(start) < 30000) {
        if (context.serverState == asdk::ServerStateAuthenticateError) {
            puts("Authentication failed");
            break;
        }
        if (context.serverState == asdk::ServerStateConnectedAndAuthenticated) {
            if (!subscribed)
                subscribed = context.sdk->SendRequest(asdk::RequestRoomListSubscribe) ==
                             asdk::StatusOK;
            else if (context.roomListReceived && !joinRequested)
                joinRequested = context.sdk->SendRequestStr(asdk::RequestRoomJoin, "test") ==
                                asdk::StatusOK;
        }
        if (context.roomJoined && context.framesReceived > 0)
            break;
 
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
 
    printf("Received %u frames\n", context.framesReceived);
 
    context.sdk->Disconnect();
    context.sdk->Unload();
    return 0;
}