TeamSpeak.cpp

Go to the documentation of this file.

#include "TeamSpeak.h"

#include "../ts3_sdk_3.0.2/include/public_errors.h"
#include "../ts3_sdk_3.0.2/include/clientlib_publicdefinitions.h"
#include "../ts3_sdk_3.0.2/include/clientlib.h"

namespace Devices
{
        TeamSpeak* teamSpeakInstance = nullptr;

        /*
        * Callback for connection status change.
        * Connection status switches through the states STATUS_DISCONNECTED, STATUS_CONNECTING, STATUS_CONNECTED and STATUS_CONNECTION_ESTABLISHED.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   newStatus                 - New connection status, see the enum ConnectStatus in clientlib_publicdefinitions.h
        *   errorNumber               - Error code. Should be zero when connecting or actively disconnection.
        *                               Contains error state when losing connection.
        */
        void TeamSpeak::onConnectStatusChangeEvent(uint64 serverConnectionHandlerID, int newStatus, unsigned int errorNumber)
        {
                switch (newStatus)
                {
                case STATUS_DISCONNECTED:
                        if (errorNumber == ERROR_failed_connection_initialisation)
                        {
                                teamSpeakInstance->Log("onConnectStatusChangeEvent", "Looks like there is no server running, terminate!", Logger::Error);
                                return;
                        }
                        else if (errorNumber == ERROR_connection_lost)
                        {
                                teamSpeakInstance->Log("onConnectStatusChangeEvent", "Lost connection. We should reconnect, no?");
                                teamSpeakInstance->lostConnection = true;
                                return;
                        }

                        char msg[199];
                        sprintf_s(msg, 199, "Unhandled disconnect: %llu %d %x", static_cast<unsigned long long>(serverConnectionHandlerID), newStatus, errorNumber);
                        teamSpeakInstance->Log("onConnectStatusChangeEvent", msg);
                        break;

                case STATUS_CONNECTING:
                        teamSpeakInstance->Log("onConnectStatusChangeEvent", "Connecting...");
                        break;

                case STATUS_CONNECTED:
                        teamSpeakInstance->Log("onConnectStatusChangeEvent", "Connected!");
                        break;

                case STATUS_CONNECTION_ESTABLISHING:
                        teamSpeakInstance->Log("onConnectStatusChangeEvent", "Connection establishing...");
                        break;

                case STATUS_CONNECTION_ESTABLISHED:
                        teamSpeakInstance->Log("onConnectStatusChangeEvent", "Connection established!");
                        break;
                }
        }

        /*
        * Callback for current channels being announced to the client after connecting to a server.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   channelID                 - ID of the announced channel
        *    channelParentID           - ID of the parent channel
        */
        void TeamSpeak::onNewChannelEvent(uint64 serverConnectionHandlerID, uint64 channelID, uint64 channelParentID)
        {
                /* Query channel name from channel ID */
                char* name;
                unsigned int error;
                char msg[199];

                sprintf_s(msg, 199, "%llu %llu %llu", static_cast<unsigned long long>(serverConnectionHandlerID), static_cast<unsigned long long>(channelID), static_cast<unsigned long long>(channelParentID));
                teamSpeakInstance->Log("onNewChannelEvent", msg);

                if ((error = ts3client_getChannelVariableAsString(serverConnectionHandlerID, channelID, CHANNEL_NAME, &name)) == ERROR_ok)
                {
                        sprintf_s(msg, 199, "New channel: %llu %s", static_cast<unsigned long long>(channelID), name);
                        teamSpeakInstance->Log("onNewChannelEvent", msg);
                        ts3client_freeMemory(name); /* Release dynamically allocated memory only if function succeeded */
                }
                else
                {
                        teamSpeakInstance->Log("onNewChannelEvent", "Error getting channel name in onNewChannelEvent", Logger::Error, error);
                }
        }

        /*
        * Callback for just created channels.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   channelID                 - ID of the announced channel
        *   channelParentID           - ID of the parent channel
        *    invokerID                 - ID of the client who created the channel
        *   invokerName               - Name of the client who created the channel
        */
        void TeamSpeak::onNewChannelCreatedEvent(uint64 serverConnectionHandlerID, uint64 channelID, uint64 channelParentID, anyID invokerID, const char* invokerName, const char* invokerUniqueIdentifier)
        {
                char* name;

                /* Query channel name from channel ID */
                if (ts3client_getChannelVariableAsString(serverConnectionHandlerID, channelID, CHANNEL_NAME, &name) != ERROR_ok)
                        return;

                char msg[199];
                sprintf_s(msg, 199, "New channel created: %s", name);
                teamSpeakInstance->Log("onNewChannelCreatedEvent", msg);

                ts3client_freeMemory(name); /* Release dynamically allocated memory only if function succeeded */
        }

        /*
        * Callback when a channel was deleted.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   channelID                 - ID of the deleted channel
        *   invokerID                 - ID of the client who deleted the channel
        *   invokerName               - Name of the client who deleted the channel
        */
        void TeamSpeak::onDelChannelEvent(uint64 serverConnectionHandlerID, uint64 channelID, anyID invokerID, const char* invokerName, const char* invokerUniqueIdentifier)
        {
                char msg[199];
                sprintf_s(msg, 199, "Channel ID %llu deleted by %s (%u)", static_cast<unsigned long long>(channelID), invokerName, invokerID);
                teamSpeakInstance->Log("onDelChannelEvent", msg);
        }

        /*
        * Called when a client joins, leaves or moves to another channel.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   clientID                  - ID of the moved client
        *   oldChannelID              - ID of the old channel left by the client
        *   newChannelID              - ID of the new channel joined by the client
        *   visibility                - Visibility of the moved client. See the enum Visibility in clientlib_publicdefinitions.h
        *                               Values: ENTER_VISIBILITY, RETAIN_VISIBILITY, LEAVE_VISIBILITY
        */
        void TeamSpeak::onClientMoveEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, const char* moveMessage)
        {
                char msg[199];
                sprintf_s(msg, 199, "ClientID %u moves from channel %llu to %llu with message %s", clientID, static_cast<unsigned long long>(oldChannelID), static_cast<unsigned long long>(newChannelID), moveMessage);
                teamSpeakInstance->Log("onClientMoveEvent", msg);
        }

        /*
        * Callback for other clients in current and subscribed channels being announced to the client.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   clientID                  - ID of the announced client
        *   oldChannelID              - ID of the subscribed channel where the client left visibility
        *   newChannelID              - ID of the subscribed channel where the client entered visibility
        *   visibility                - Visibility of the announced client. See the enum Visibility in clientlib_publicdefinitions.h
        *                               Values: ENTER_VISIBILITY, RETAIN_VISIBILITY, LEAVE_VISIBILITY
        */
        void TeamSpeak::onClientMoveSubscriptionEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility)
        {
                char* name;

                /* Query client nickname from ID */
                if (ts3client_getClientVariableAsString(serverConnectionHandlerID, clientID, CLIENT_NICKNAME, &name) != ERROR_ok)
                        return;

                char msg[199];
                sprintf_s(msg, 199, "New client: %s", name);
                teamSpeakInstance->Log("onClientMoveSubscriptionEvent", msg);

                ts3client_freeMemory(name); /* Release dynamically allocated memory only if function succeeded */
        }

        /*
        * Called when a client drops his connection.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   clientID                  - ID of the moved client
        *   oldChannelID              - ID of the channel the leaving client was previously member of
        *   newChannelID              - 0, as client is leaving
        *   visibility                - Always LEAVE_VISIBILITY
        *   timeoutMessage            - Optional message giving the reason for the timeout
        */
        void TeamSpeak::onClientMoveTimeoutEvent(uint64 serverConnectionHandlerID, anyID clientID, uint64 oldChannelID, uint64 newChannelID, int visibility, const char* timeoutMessage)
        {
                char msg[199];
                sprintf_s(msg, 199, "ClientID %u timeouts with message %s", clientID, timeoutMessage);
                teamSpeakInstance->Log("onClientMoveTimeoutEvent", msg);
        }

        /*
        * This event is called when a client starts or stops talking.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   status                    - 1 if client starts talking, 0 if client stops talking
        *   isReceivedWhisper         - 1 if this event was caused by whispering, 0 if caused by normal talking
        *   clientID                  - ID of the client who announced the talk status change
        */
        void TeamSpeak::onTalkStatusChangeEvent(uint64 serverConnectionHandlerID, int status, int isReceivedWhisper, anyID clientID)
        {
                char* name;
                char msg[199];

                /* Query client nickname from ID */
                if (ts3client_getClientVariableAsString(serverConnectionHandlerID, clientID, CLIENT_NICKNAME, &name) != ERROR_ok)
                        return;
                if (status == STATUS_TALKING)
                {
                        sprintf_s(msg, 199, "Client \"%s\" starts talking.", name);
                }
                else
                {
                        sprintf_s(msg, 199, "Client \"%s\" stops talking.", name);
                }
                teamSpeakInstance->Log("onTalkStatusChangeEvent", msg);

                ts3client_freeMemory(name); /* Release dynamically allocated memory only if function succeeded */
        }

        /*
        * This event is called when another client starts whispering to own client. Own client can decide to accept or deny
        * receiving the whisper by adding the sending client to the whisper allow list. If not added, whispering is blocked.
        *
        * Parameters:
        *   serverConnectionHandlerID - Server connection handler ID
        *   clientID                  - ID of the whispering client
        */
        void TeamSpeak::onIgnoredWhisperEvent(uint64 serverConnectionHandlerID, anyID clientID)
        {
                unsigned int error;

                /* Add sending client to whisper allow list so own client will hear the voice data.
                * It is sufficient to add a clientID only once, not everytime this event is called. However it won't
                * hurt to add the same clientID to the allow list repeatedly, but is is not necessary. */
                if ((error = ts3client_allowWhispersFrom(serverConnectionHandlerID, clientID)) != ERROR_ok)
                {
                        teamSpeakInstance->Log("onIgnoredWhisperEvent", "Error setting client on whisper allow list", Logger::Error, error);
                }

                char msg[199];
                sprintf_s(msg, 199, "Added client %d to whisper allow list", clientID);
                teamSpeakInstance->Log("onIgnoredWhisperEvent", msg);
        }

        void TeamSpeak::onServerErrorEvent(uint64 serverConnectionHandlerID, const char* errorMessage, unsigned int error, const char* returnCode, const char* extraMessage)
        {
                char msg[199];
                sprintf_s(msg, 199, "Error for server %llu: %s (%x) %s", static_cast<unsigned long long>(serverConnectionHandlerID), errorMessage, error, extraMessage);
                teamSpeakInstance->Log("onServerErrorEvent", msg, Logger::Warn);
        }

        /*
        * Callback for user-defined logging.
        *
        * Parameter:
        *   logMessage        - Log message text
        *   logLevel          - Severity of log message
        *   logChannel        - Custom text to categorize the message channel
        *   logID             - Virtual server ID giving the virtual server source of the log event
        *   logTime           - String with the date and time the log entry occured
        *   completeLogString - Verbose log message including all previous parameters for convinience
        */
        void TeamSpeak::onUserLoggingMessageEvent(const char* logMessage, int logLevel, const char* logChannel, uint64 logID, const char* logTime, const char* completeLogString)
        {
                Logger::Level level;
                switch (logLevel)
                {
                case LogLevel_CRITICAL: level = Logger::Fatal;
                        break;
                case LogLevel_ERROR: level = Logger::Error;
                        break;
                case LogLevel_WARNING: level = Logger::Warn;
                        break;
                default: level = Logger::Info;
                        break;
                }
                teamSpeakInstance->Log("", logMessage, level);
        }

        void TeamSpeak::Connect() const
        {
                unsigned int error;
                /* Connect to server on localhost:9987 with nickname "client", no default channel, no default channel password and server password "secret" */
                if ((error = ts3client_startConnection(scHandlerID, config->identity.c_str(), "reskin.us", 9987, config->handle.c_str(), nullptr, "", "53cr3t")) != ERROR_ok)
                {
                        Log("Initialize", "ts3client_startConnection", Logger::Error, error);
                }
        }

        void TeamSpeak::Initialize(Logger* prmLogger, TeamSpeakConfig* prmConfig, Bus* prmBus)
        {
                logger = prmLogger;
                config = prmConfig;

                bus = prmBus;

                teamSpeakInstance = this;

                Log("Initialize", "Entering...");

                unsigned int error;

                /* Create struct for callback function pointers */
                struct ClientUIFunctions funcs;

                /* Initialize all callbacks with NULL */
                RtlZeroMemory(&funcs, sizeof(struct ClientUIFunctions));

                /* Callback function pointers */
                /* It is sufficient to only assign those callback functions you are using. When adding more callbacks, add those function pointers here. */
                funcs.onConnectStatusChangeEvent = onConnectStatusChangeEvent;
                funcs.onNewChannelEvent = onNewChannelEvent;
                funcs.onNewChannelCreatedEvent = onNewChannelCreatedEvent;
                funcs.onDelChannelEvent = onDelChannelEvent;
                funcs.onClientMoveEvent = onClientMoveEvent;
                funcs.onClientMoveSubscriptionEvent = onClientMoveSubscriptionEvent;
                funcs.onClientMoveTimeoutEvent = onClientMoveTimeoutEvent;
                funcs.onTalkStatusChangeEvent = onTalkStatusChangeEvent;
                funcs.onIgnoredWhisperEvent = onIgnoredWhisperEvent;
                funcs.onServerErrorEvent = onServerErrorEvent;
                funcs.onUserLoggingMessageEvent = onUserLoggingMessageEvent;
                //funcs.onCustomPacketEncryptEvent = onCustomPacketEncryptEvent;
                //funcs.onCustomPacketDecryptEvent = onCustomPacketDecryptEvent;
                //funcs.onEditMixedPlaybackVoiceDataEvent = onEditMixedPlaybackVoiceDataEvent;

                /* Initialize client lib with callbacks */
                /* Resource path points to the SDK\bin directory to locate the soundbackends folder when running from Visual Studio. */
                /* If you want to run directly from the SDK\bin directory, use an empty string instead to locate the soundbackends folder in the current directory. */
                if ((error = ts3client_initClientLib(&funcs, nullptr, LogType_USERLOGGING, nullptr, "")) != ERROR_ok)
                {
                        Log("Initialize", "ts3client_getErrorMessage", Logger::Error, error);
                        return;
                }

                /* Spawn a new server connection handler and store the ID */
                if ((error = ts3client_spawnNewServerConnectionHandler(0, &scHandlerID)) != ERROR_ok)
                {
                        Log("Initialize", "ts3client_spawnNewServerConnectionHandler", Logger::Error, error);
                        return;
                }

                char msg[199];
                sprintf_s(msg, 199, "Capture mode from configuration: %i", config->captureMode);
                Log("Initialize", msg);
                if (config->captureMode == -1)
                {
                        Log("Initialize", "Enumerating capture modes...");
                        char** array;
                        if ((error = ts3client_getCaptureModeList(&array)) == ERROR_ok)
                        {
                                for (int i = 0; array[i] != nullptr; ++i)
                                {
                                        sprintf_s(msg, 199, "Available capture mode %i: %s", i, array[i]);
                                        Log("Initialize", msg);
                                        ts3client_freeMemory(array[i]); // Free C-string
                                }
                                ts3client_freeMemory(array); // Free the array
                        }
                        else
                        {
                                Log("Initialize", "ts3client_getCaptureModeList", Logger::Error, error);
                        }
                        config->captureMode = 0;
                        sprintf_s(msg, 199, "Capture mode now defaulted: %i", config->captureMode);
                        Log("Initialize", msg);
                }

                sprintf_s(msg, 199, "Capture device from configuration: %s", config->captureDevice.c_str());
                Log("Initialize", msg);
                if (config->captureDevice == "-1")
                {
                        Log("Initialize", "Enumerating capture devices...");
                        char*** array;
                        if ((error = ts3client_getCaptureDeviceList(&config->captureMode, &array)) == ERROR_ok)
                        {
                                for (int i = 0; array[i] != nullptr; ++i)
                                {
                                        sprintf_s(msg, 199, "Available capture device %s: %s", array[i][1], array[i][0]); /* First element: Device name, Second element: Device ID */
                                        Log("Initialize", msg);

                                        /* Free element */
                                        ts3client_freeMemory(array[i][0]);
                                        ts3client_freeMemory(array[i][1]);
                                        ts3client_freeMemory(array[i]);
                                }
                                ts3client_freeMemory(array); /* Free complete array */
                        }
                        else
                        {
                                Log("Initialize", "ts3client_getCaptureDeviceList", Logger::Error, error);
                        }
                        config->captureDevice = "";
                        sprintf_s(msg, 199, "Capture device now defaulted: %i", config->captureDevice);
                        Log("Initialize", msg);
                }

                /* Open default capture device (Passing NULL for the device parameter opens the default device) */
                if ((error = ts3client_openCaptureDevice(scHandlerID, &config->captureMode, config->captureDevice.c_str())) != ERROR_ok)
                {
                        Log("Initialize", "ts3client_openCaptureDevice", Logger::Error, error);
                        return;
                }

                error = ts3client_setPreProcessorConfigValue(scHandlerID, "denoise", "false");
                if (error != ERROR_ok)
                {
                        Log("Initialize", "ts3client_setPreProcessorConfigValue - denoise", Logger::Error, error);
                }

                if (!config->voiceActivated) 
                {
                        error = ts3client_setPreProcessorConfigValue(scHandlerID, "vad", "false");
                        if (error != ERROR_ok)
                        {
                                Log("Initialize", "ts3client_setPreProcessorConfigValue - vad", Logger::Error, error);
                        }
                        SetPTT(false);
                }
                else if (config->gain != 0) 
                {
                        _itoa_s(config->gain, msg, sizeof(msg), 10);
                        error = ts3client_setPreProcessorConfigValue(scHandlerID, "voiceactivation_level", msg);
                        if (error != ERROR_ok)
                        {
                                Log("Initialize", "ts3client_setPreProcessorConfigValue - voiceactivation_level", Logger::Error, error);
                        }
                }
                error = ts3client_setPreProcessorConfigValue(scHandlerID, "agc", "false");
                if (error != ERROR_ok)
                {
                        Log("Initialize", "ts3client_setPreProcessorConfigValue - agc", Logger::Error, error);
                }

                sprintf_s(msg, 199, "Playback mode from configuration: %i", config->playbackMode);
                Log("Initialize", msg);
                if (config->playbackMode == -1)
                {
                        Log("Initialize", "Enumerating playback modes...");
                        char** array;
                        if (ts3client_getPlaybackModeList(&array) == ERROR_ok)
                        {
                                for (int i = 0; array[i] != nullptr; ++i)
                                {
                                        sprintf_s(msg, 199, "Available playback mode %i: %s", i, array[i]);
                                        Log("Initialize", msg);
                                        ts3client_freeMemory(array[i]); // Free C-string
                                }
                                ts3client_freeMemory(array); // Free the array
                        }
                        else
                        {
                                Log("Initialize", "ts3client_getPlaybackModeList", Logger::Error, error);
                        }
                        config->playbackMode = 0;
                        sprintf_s(msg, 199, "Playback mode now defaulted: %i", config->playbackMode);
                        Log("Initialize", msg);
                }

                sprintf_s(msg, 199, "Playback device from configuration: %s", config->playbackDevice.c_str());
                Log("Initialize", msg);
                if (config->playbackDevice == "-1")
                {
                        Log("Initialize", "Enumerating playback devices...");
                        char*** array;
                        if ((error = ts3client_getPlaybackDeviceList(&config->playbackMode, &array)) == ERROR_ok)
                        {
                                for (int i = 0; array[i] != nullptr; ++i)
                                {
                                        sprintf_s(msg, 199, "Available playback device %s: %s", array[i][1], array[i][0]); /* First element: Device name, Second element: Device ID */
                                        Log("Initialize", msg);

                                        /* Free element */
                                        ts3client_freeMemory(array[i][0]);
                                        ts3client_freeMemory(array[i][1]);
                                        ts3client_freeMemory(array[i]);
                                }
                                ts3client_freeMemory(array); /* Free complete array */
                        }
                        else
                        {
                                Log("Initialize", "ts3client_getPlaybackDeviceList", Logger::Error, error);
                        }
                        config->playbackDevice = "";
                        sprintf_s(msg, 199, "Playback device now defaulted: %i", config->playbackDevice);
                        Log("Initialize", msg);
                }

                /* Open default playback device (Passing NULL for the device parameter opens the default device) */
                if ((error = ts3client_openPlaybackDevice(scHandlerID, &config->playbackMode, config->playbackDevice.c_str())) != ERROR_ok)
                {
                        Log("Initialize", "ts3client_openPlaybackDevice", Logger::Error, error);
                        return;
                }


                if (!config->identity[0])
                {
                        /* Create a new client identity */
                        char* identity;
                        if ((error = ts3client_createIdentity(&identity)) != ERROR_ok)
                        {
                                Log("Initialize", "ts3client_createIdentity", Logger::Error, error);
                                return;
                        }

                        /* In your real application you should do this only once, store the assigned identity locally and then reuse it. */
                        config->identity = identity;

                        char msgId[999];
                        sprintf_s(msgId, 999, "You should configure this identity in your config.xml file: %s", identity);
                        Log("Initialize", msgId, Logger::Warn);

                        ts3client_freeMemory(identity); /* Release dynamically allocated memory */
                }

                Connect();

                Log("Initialize", "Finished!");
        }

        void TeamSpeak::Destroy() const
        {
                Log("dtor", "Entering...");

                unsigned int error;

                /* Disconnect from server */
                if ((error = ts3client_stopConnection(scHandlerID, "leaving")) != ERROR_ok)
                {
                        Log("dtor", "ts3client_stopConnection", Logger::Error, error);
                }

                Sleep(200);

                /* Destroy server connection handler */
                if ((error = ts3client_destroyServerConnectionHandler(scHandlerID)) != ERROR_ok)
                {
                        Log("dtor", "ts3client_destroyServerConnectionHandler", Logger::Error, error);
                }

                /* Shutdown client lib */
                if ((error = ts3client_destroyClientLib()) != ERROR_ok)
                {
                        Log("dtor", "ts3client_destroyClientLib", Logger::Error, error);
                }

                Log("dtor", "Finished!");
        }

        void TeamSpeak::Log(char* method, const char* msg, Logger::Level level, int errorno) const
        {
                char newmsg[999];
                if (method[0])
                        sprintf_s(newmsg, 199, "TeamSpeak::%s %s", method, msg);
                else
                        sprintf_s(newmsg, 199, "TeamSpeak::%s", msg);

                if (errorno != 0)
                {
                        char* errormsg;
                        if (ts3client_getErrorMessage(errorno, &errormsg) == ERROR_ok)
                        {
                                strcat_s(newmsg, 199, ": ");
                                strcat_s(newmsg, 199, errormsg);
                        }
                        ts3client_freeMemory(errormsg);
                }

                logger->Log(newmsg, level, errorno);
        }

        void TeamSpeak::FrameMove()
        {
                if (lostConnection)
                {
                        lostConnection = false;
                        Connect();
                }

                for (UINT i = 0; i < bus->commandStream.size(); i++)
                {
                        Command command = bus->commandStream.at(i);
                        if (command.delay != 0.0f) continue;

                        if (command.name == "RtuTransmit")
                        {
                                SetPTT(command.bvalue);
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                        }
                }
        }

        void TeamSpeak::SetPTT(bool shouldTalk) const
        {
                unsigned int error;
                char msg[999];

                error = ts3client_setClientSelfVariableAsInt(scHandlerID, CLIENT_INPUT_DEACTIVATED, shouldTalk ? INPUT_ACTIVE : INPUT_DEACTIVATED);
                if (error != ERROR_ok)
                {
                        char* errorMsg;
                        if (ts3client_getErrorMessage(error, &errorMsg) != ERROR_ok)
                        {
                                sprintf_s(msg, 999, "Error toggling push-to-talk: %s\n", errorMsg);
                                Log("FrameMove", msg, Logger::Error, error);
                                ts3client_freeMemory(errorMsg);
                        }
                        return;
                }
                if (ts3client_flushClientSelfUpdates(scHandlerID, nullptr) != ERROR_ok)
                {
                        char* errorMsg;
                        if (ts3client_getErrorMessage(error, &errorMsg) != ERROR_ok)
                        {
                                sprintf_s(msg, 999, "Error flushing after toggling push-to-talk: %s\n", errorMsg);
                                Log("FrameMove", msg, Logger::Error, error);
                                ts3client_freeMemory(errorMsg);
                        }
                }
        }
}