interactivity.h

//*********************************************************
//
// Copyright (c) Microsoft. All rights reserved.
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//*********************************************************
#pragma once

extern "C" {

    struct interactive_object
    {
        const char* id;
        size_t idLength;
    };
    int interactive_auth_get_short_code(const char* clientId, const char* clientSecret, char* shortCode, size_t* shortCodeLength, char* shortCodeHandle, size_t* shortCodeHandleLength);

    int interactive_auth_wait_short_code(const char* clientId, const char* clientSecret, const char* shortCodeHandle, char* refreshToken, size_t* refreshTokenLength);

    int interactive_auth_is_token_stale(const char* token, bool* isStale);

    int interactive_auth_refresh_token(const char* clientId, const char* clientSecret, const char* staleToken, char* refreshToken, size_t* refreshTokenLength);

    int interactive_auth_parse_refresh_token(const char* token, char* authorization, size_t* authorizationLength);
    typedef void* interactive_session;  

    int interactive_open_session(interactive_session* session);

    int interactive_connect(interactive_session session, const char* auth, const char* versionId, const char* shareCode, bool setReady);

    int interactive_set_ready(interactive_session session, bool isReady);

    int interactive_run(interactive_session session, unsigned int maxEventsToProcess);

    enum interactive_state
    {
        interactive_disconnected,
        interactive_connecting,
        interactive_connected,
        interactive_ready
    };

    int interactive_get_state(interactive_session session, interactive_state* state);

    int interactive_set_session_context(interactive_session session, void* context);

    int interactive_get_session_context(interactive_session session, void** context);

    enum interactive_throttle_type
    {
        throttle_global,
        throttle_input,
        throttle_participant_join,
        throttle_participant_leave
    };

    int interactive_set_bandwidth_throttle(interactive_session session, interactive_throttle_type throttleType, unsigned int maxBytes, unsigned int bytesPerSecond);

    int interactive_capture_transaction(interactive_session session, const char* transactionId);

    void interactive_close_session(interactive_session session);
    struct interactive_user
    {
        unsigned int id;
        const char* userName;       
        bool isBroadcasting;
        unsigned int level;
        unsigned int experience;
        unsigned int sparks;
        const char* avatarUrl;
    };

    typedef void(*on_interactive_user)(void* context, interactive_session session, const interactive_user* user);

    int interactive_get_user(interactive_session session, on_interactive_user onUser);

    struct interactive_control : public interactive_object
    {
        const char* kind;
        size_t kindLength;
    };

    enum interactive_control_event
    {
        interactive_control_created,
        interactive_control_updated,
        interactive_control_deleted
    };

    // Known control properties
    #define CONTROL_PROP_DISABLED "disabled"
    #define CONTROL_PROP_POSITION "position"

    #define BUTTON_PROP_KEY_CODE "keyCode"
    #define BUTTON_PROP_TEXT "text"
    #define BUTTON_PROP_TOOLTIP "tooltip"
    #define BUTTON_PROP_COST "cost"
    #define BUTTON_PROP_PROGRESS "progress"
    #define BUTTON_PROP_COOLDOWN "cooldown"

    #define JOYSTICK_PROP_SAMPLE_RATE "sampleRate"
    #define JOYSTICK_PROP_ANGLE "angle"
    #define JOYSTICK_PROP_INTENSITY "intensity"

    enum interactive_property_type
    {
        interactive_unknown_t,
        interactive_int_t,
        interactive_bool_t,
        interactive_float_t,
        interactive_string_t,
        interactive_array_t,
        interactive_object_t
    };

    typedef void(*on_control_enumerate)(void* context, interactive_session session, const interactive_control* control);

    int interactive_control_trigger_cooldown(interactive_session session, const char* controlId, const unsigned long long cooldownMs);

    int interactive_control_get_property_count(interactive_session session, const char* controlId, size_t* count);

    int interactive_control_get_property_data(interactive_session session, const char* controlId, size_t index, char* propName, size_t* propNameLength, interactive_property_type* type);

    int interactive_control_get_meta_property_count(interactive_session session, const char* controlId, size_t* count);

    int interactive_control_get_meta_property_data(interactive_session session, const char* controlId, size_t index, char* propName, size_t* propNameLength, interactive_property_type* type);

    int interactive_control_get_property_int(interactive_session session, const char* controlId, const char* key, int* property);

    int interactive_control_get_property_int64(interactive_session session, const char* controlId, const char* key, long long* property);

    int interactive_control_get_property_bool(interactive_session session, const char* controlId, const char* key, bool* property);

    int interactive_control_get_property_float(interactive_session session, const char* controlId, const char* key, float* property);

    int interactive_control_get_property_string(interactive_session session, const char* controlId, const char* key, char* property, size_t* propertyLength);

    int interactive_control_set_property_null(interactive_session session, const char* controlId, const char* key);

    int interactive_control_set_property_int(interactive_session session, const char* controlId, const char* key, int property);

    int interactive_control_set_property_int64(interactive_session session, const char* controlId, const char* key, long long property);

    int interactive_control_set_property_bool(interactive_session session, const char* controlId, const char* key, bool property);

    int interactive_control_set_property_float(interactive_session session, const char* controlId, const char* key, float property);

    int interactive_control_set_property_string(interactive_session session, const char* controlId, const char* key, char* property);

    int interactive_control_get_meta_property_int(interactive_session session, const char* controlId, const char* key, int* property);

    int interactive_control_get_meta_property_int64(interactive_session session, const char* controlId, const char* key, long long* property);

    int interactive_control_get_meta_property_bool(interactive_session session, const char* controlId, const char* key, bool* property);

    int interactive_control_get_meta_property_float(interactive_session session, const char* controlId, const char* key, float* property);

    int interactive_control_get_meta_property_string(interactive_session session, const char* controlId, const char* key, char* property, size_t* propertyLength);
    struct interactive_group : public interactive_object
    {
        const char* sceneId;
        size_t sceneIdLength;
    };

    typedef void(*on_group_enumerate)(void* context, interactive_session session, const interactive_group* group);

    int interactive_get_groups(interactive_session session, on_group_enumerate onGroup);

    int interactive_create_group(interactive_session session, const char* groupId, const char* sceneId);

    int interactive_group_set_scene(interactive_session session, const char* groupId, const char* sceneId);
    struct interactive_scene : public interactive_object
    {
    };

    typedef void(*on_scene_enumerate)(void* context, interactive_session session, const interactive_scene* scene);

    int interactive_get_scenes(interactive_session session, on_scene_enumerate onScene);

    int interactive_scene_get_groups(interactive_session session, const char* sceneId, on_group_enumerate onGroup);

    int interactive_scene_get_controls(interactive_session session, const char* sceneId, on_control_enumerate onControl);
    typedef void(*on_error)(void* context, interactive_session session, int errorCode, const char* errorMessage, size_t errorMessageLength);

    typedef void(*on_state_changed)(void* context, interactive_session session, interactive_state previousState, interactive_state newState);

    enum interactive_input_type
    {
        input_type_key,
        input_type_click,
        input_type_move,
        input_type_custom
    };

    enum interactive_button_action
    {
        interactive_button_action_up,
        interactive_button_action_down
    };

    struct interactive_input
    {
        interactive_control control;
        interactive_input_type type;
        const char* participantId;
        size_t participantIdLength;
        const char* jsonData;
        size_t jsonDataLength;
        const char* transactionId;
        size_t transactionIdLength;
        struct buttonData
        {
            interactive_button_action action;
        } buttonData;
        struct coordinateData
        {
            float x;
            float y;
        } coordinateData;
    };

    typedef void(*on_input)(void* context, interactive_session session, const interactive_input* input);

    struct interactive_participant : public interactive_object
    {
        unsigned int userId;
        const char* userName;
        size_t usernameLength;
        unsigned int level;
        unsigned long long lastInputAtMs;
        unsigned long long connectedAtMs;
        bool disabled;
        const char* groupId;
        size_t groupIdLength;
    };

    enum interactive_participant_action
    {
        participant_join,
        participant_leave,
        participant_update
    };

    typedef void(*on_participants_changed)(void* context, interactive_session session, interactive_participant_action action, const interactive_participant* participant);

    typedef void(*on_transaction_complete)(void* context, interactive_session session, const char* transactionId, size_t transactionIdLength, unsigned int error, const char* errorMessage, size_t errorMessageLength);

    typedef void(*on_control_changed)(void* context, interactive_session session, interactive_control_event eventType, const interactive_control* control);

    typedef void(*on_unhandled_method)(void* context, interactive_session session, const char* methodJson, size_t methodJsonLength);

    int interactive_set_error_handler(interactive_session session, on_error onError);

    int interactive_set_state_changed_handler(interactive_session session, on_state_changed onStateChanged);

    int interactive_set_input_handler(interactive_session session, on_input onInput);

    int interactive_set_participants_changed_handler(interactive_session session, on_participants_changed onParticipantsChanged);

    int interactive_set_transaction_complete_handler(interactive_session session, on_transaction_complete onTransactionComplete);

    int interactive_set_control_changed_handler(interactive_session session, on_control_changed onControlChanged);

    int interactive_set_unhandled_method_handler(interactive_session session, on_unhandled_method onUnhandledMethod);
    typedef void(*on_participant_enumerate)(void* context, interactive_session session, const interactive_participant* participant);

    int interactive_get_participants(interactive_session session, on_participant_enumerate onParticipant);

    int interactive_participant_set_group(interactive_session session, const char* participantId, const char* groupId);

    int interactive_participant_get_user_id(interactive_session session, const char* participantId, unsigned int* userId);

    int interactive_participant_get_user_name(interactive_session session, const char* participantId, char* userName, size_t* userNameLength);

    int interactive_participant_get_level(interactive_session session, const char* participantId, unsigned int* level);

    int interactive_participant_get_last_input_at(interactive_session session, const char* participantId, unsigned long long* lastInputAt);

    int interactive_participant_get_connected_at(interactive_session session, const char* participantId, unsigned long long* connectedAt);

    int interactive_participant_is_disabled(interactive_session session, const char* participantId, bool* isDisabled);

    int interactive_participant_get_group(interactive_session session, const char* participantId, char* group, size_t* groupLength);
    typedef void(*on_method_reply)(void* context, interactive_session session, const char* replyJson, size_t replyJsonLength);

    int interactive_queue_method(interactive_session session, const char* method, const char* paramsJson, const on_method_reply onReply);

    enum interactive_debug_level
    {
        interactive_debug_none = 0,
        interactive_debug_error,
        interactive_debug_warning,
        interactive_debug_info,
        interactive_debug_trace
    };

    typedef void(*on_debug_msg)(const interactive_debug_level dbgMsgType, const char* dbgMsg, size_t dbgMsgSize);

    void interactive_config_debug_level(const interactive_debug_level dbgLevel);

    void interactive_config_debug(const interactive_debug_level dbgLevel, on_debug_msg dbgCallback);
    typedef enum mixer_result_code
    {
        MIXER_OK,
        MIXER_ERROR,
        MIXER_ERROR_AUTH,
        MIXER_ERROR_AUTH_DENIED,
        MIXER_ERROR_AUTH_INVALID_TOKEN,
        MIXER_ERROR_BUFFER_SIZE,
        MIXER_ERROR_CANCELLED,
        MIXER_ERROR_HTTP,
        MIXER_ERROR_INIT,
        MIXER_ERROR_INVALID_CALLBACK,
        MIXER_ERROR_INVALID_CLIENT_ID,
        MIXER_ERROR_INVALID_OPERATION,
        MIXER_ERROR_INVALID_POINTER,
        MIXER_ERROR_INVALID_PROPERTY_TYPE,
        MIXER_ERROR_INVALID_VERSION_ID,
        MIXER_ERROR_JSON_PARSE,
        MIXER_ERROR_METHOD_CREATE,
        MIXER_ERROR_NO_HOST,
        MIXER_ERROR_NO_REPLY,
        MIXER_ERROR_OBJECT_NOT_FOUND,
        MIXER_ERROR_PROPERTY_NOT_FOUND,
        MIXER_ERROR_TIMED_OUT,
        MIXER_ERROR_UNKNOWN_METHOD,
        MIXER_ERROR_UNRECOGNIZED_DATA_FORMAT,
        MIXER_ERROR_WS_CLOSED,
        MIXER_ERROR_WS_CONNECT_FAILED,
        MIXER_ERROR_WS_DISCONNECT_FAILED,
        MIXER_ERROR_WS_READ_FAILED,
        MIXER_ERROR_WS_SEND_FAILED,
        MIXER_ERROR_NOT_CONNECTED,
        MIXER_ERROR_OBJECT_EXISTS,
        MIXER_ERROR_INVALID_STATE
    } mixer_result_code;
}