Very minimal first version; connects, sends presence updates inline, disconnects. Other than opening pipe does no allocations.

This commit is contained in:
Chris Marsh 2017-06-29 09:16:25 -07:00
parent 390bed4d71
commit 4b77b81b2d

View file

@ -1,23 +1,288 @@
#include "discord-rpc.h"
static DiscordEventHandlers Handlers;
#include <stdint.h>
#include <stdio.h>
#include <string.h>
// todo: think about making per-platform versions of this whole file, or wrapping the platform specific parts -- win32 for first version
#include <windows.h>
static const wchar_t* PipeName = L"\\\\.\\pipe\\DiscordRpcServer";
static HANDLE PipeHandle{INVALID_HANDLE_VALUE};
static char ApplicationId[64]{};
static DiscordEventHandlers Handlers{};
static char MessageBuffer[64 * 1024];
// if only there was a standard library function for this
size_t StringCopy(char* dest, const char* src, size_t maxBytes) {
if (!dest || !src || !maxBytes) {
return 0;
}
size_t copied;
for (copied = 1; *src && copied < maxBytes; ++copied) {
*dest++ = *src++;
}
*dest = 0;
return copied - 1;
}
size_t StringCopy(char* dest, const char* src) {
if (!dest || !src) {
return 0;
}
size_t copied;
for (copied = 1; *src; ++copied) {
*dest++ = *src++;
}
*dest = 0;
return copied - 1;
}
void EscapeString(char*& dest, const char* src)
{
for (char c = *src++; c; c = *src++) {
switch (c) {
case '\"':
case '\\':
*dest++ = '\\';
*dest++ = c;
break;
case '\b':
*dest++ = '\\';
*dest++ = 'b';
break;
case '\f': // Form feed(ascii code 0C)
*dest++ = '\\';
*dest++ = 'f';
break;
case '\n': // New line
*dest++ = '\\';
*dest++ = 'n';
break;
case '\r': // Carriage return
*dest++ = '\\';
*dest++ = 'r';
break;
case '\t': // Tab
*dest++ = '\\';
*dest++ = 't';
break;
default:
*dest++ = c;
break;
}
}
}
template<typename T> void NumberToString(char*& dest, T number)
{
if (!number) {
*dest++ = '0';
return;
}
if (number < 0) {
*dest++ = '-';
number = -number;
}
char temp[32];
int place = 0;
while (number) {
auto digit = number % 10;
number = number / 10;
temp[place++] = '0' + (char)digit;
}
for (--place; place >= 0; --place) {
*dest++ = temp[place];
}
*dest = 0;
}
void JsonWritePropName(char*& dest, const char* name)
{
*dest++ = '"';
dest += StringCopy(dest, name);
*dest++ = '"';
*dest++ = ':';
*dest++ = ' ';
}
void JsonWritePropSep(char*& dest)
{
*dest++ = ',';
*dest++ = ' ';
}
void JsonWriteStringProp(char*& dest, const char* name, const char* value)
{
JsonWritePropName(dest, name);
*dest++ = '"';
EscapeString(dest, value);
*dest++ = '"';
JsonWritePropSep(dest);
}
template<typename T>
void JsonWriteNumberAsStringProp(char*& dest, const char* name, T value)
{
JsonWritePropName(dest, name);
*dest++ = '"';
NumberToString(dest, value);
*dest++ = '"';
JsonWritePropSep(dest);
}
template<typename T>
void JsonWriteNumberProp(char*& dest, const char* name, T value)
{
JsonWritePropName(dest, name);
NumberToString(dest, value);
JsonWritePropSep(dest);
}
void JsonWriteBoolProp(char*& dest, const char* name, bool value)
{
JsonWritePropName(dest, name);
dest += StringCopy(dest, value ? "true" : "false");
JsonWritePropSep(dest);
}
void JsonWriteRichPresenceObj(char*& dest, const DiscordRichPresence* presence)
{
*dest++ = '{';
if (presence->state) {
JsonWriteStringProp(dest, "state", presence->state);
}
if (presence->details) {
JsonWriteStringProp(dest, "details", presence->details);
}
if (presence->startTimestamp) {
JsonWriteNumberAsStringProp(dest, "start_timestamp", presence->startTimestamp);
}
if (presence->endTimestamp) {
JsonWriteNumberAsStringProp(dest, "end_timestamp", presence->endTimestamp);
}
if (presence->largeImageKey) {
JsonWriteStringProp(dest, "large_image_key", presence->largeImageKey);
}
if (presence->largeImageText) {
JsonWriteStringProp(dest, "large_image_text", presence->largeImageText);
}
if (presence->smallImageKey) {
JsonWriteStringProp(dest, "small_image_key", presence->smallImageKey);
}
if (presence->smallImageText) {
JsonWriteStringProp(dest, "small_image_text", presence->smallImageText);
}
if (presence->partyId) {
JsonWriteStringProp(dest, "party_id", presence->partyId);
}
if (presence->partyMax) {
JsonWriteNumberProp(dest, "party_size", presence->partySize);
JsonWriteNumberProp(dest, "party_max", presence->partyMax);
}
if (presence->matchSecret) {
JsonWriteStringProp(dest, "match_secret", presence->matchSecret);
}
if (presence->joinSecret) {
JsonWriteStringProp(dest, "join_secret", presence->joinSecret);
}
if (presence->spectateSecret) {
JsonWriteStringProp(dest, "spectate_secret", presence->spectateSecret);
}
JsonWriteBoolProp(dest, "instance", presence->instance);
dest -= 1;
*(dest - 1) = '}';
}
void OpenConnection()
{
for (;;) {
PipeHandle = CreateFileW(PipeName, GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
if (PipeHandle != INVALID_HANDLE_VALUE) {
break;
}
if (GetLastError() != ERROR_PIPE_BUSY) {
printf("Could not open pipe. Error: %d\n", GetLastError());
return;
}
if (!WaitNamedPipeW(PipeName, 10000)) {
printf("Could not open pipe: 10 second wait timed out.\n");
return;
}
}
}
void CloseConnection()
{
CloseHandle(PipeHandle);
PipeHandle = INVALID_HANDLE_VALUE;
if (Handlers.disconnected) {
Handlers.disconnected();
}
}
void Discord_Initialize(const char* applicationId, DiscordEventHandlers* handlers)
{
StringCopy(ApplicationId, applicationId, sizeof(ApplicationId));
if (handlers) {
memcpy(&Handlers, handlers, sizeof(Handlers));
Handlers = *handlers;
}
else {
memset(&Handlers, 0, sizeof(Handlers));
Handlers = {};
}
OpenConnection();
if (PipeHandle != INVALID_HANDLE_VALUE) {
if (Handlers.ready) {
Handlers.ready();
}
}
}
void Discord_Shutdown()
{
Handlers = {};
CloseConnection();
}
void Discord_UpdatePresence(const DiscordRichPresence* presence)
{
if (PipeHandle == INVALID_HANDLE_VALUE) {
OpenConnection();
if (PipeHandle == INVALID_HANDLE_VALUE) {
return;
}
}
int32_t* totalLength = (int32_t*)MessageBuffer;
char* jsonStart = MessageBuffer + sizeof(int32_t);
char* jsonWrite = jsonStart;
JsonWriteRichPresenceObj(jsonWrite, presence);
*totalLength = sizeof(int32_t) + (jsonWrite - jsonStart);
BOOL success = WriteFile(PipeHandle, MessageBuffer, *totalLength, nullptr, nullptr);
if (!success) {
CloseConnection();
}
}