Changing kebab case filenames in source to snake case for consistency

- Custom serializer to fix utf-8 strings in C#

.clang-format

@@ -1,52 +1,71 @@
 ---
-Language: Cpp
 AccessModifierOffset: -4
 AlignAfterOpenBracket: true
-AlignEscapedNewlinesLeft: true
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
 AlignOperands: false
 AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: false
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: InlineOnly
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Inline
-AlwaysBreakAfterDefinitionReturnType: false
-AlwaysBreakTemplateDeclarations: true
+AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
-BreakBeforeBraces: Stroustrup
-BreakBeforeBinaryOperators: None
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: true
-BinPackParameters: false
+AlwaysBreakTemplateDeclarations: true
 BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Stroustrup
+BreakBeforeInheritanceComma: true
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeComma
+BreakStringLiterals: true
 ColumnLimit: 100
 CommentPragmas: ''
+CompactNamespaces: false
 ConstructorInitializerAllOnOneLineOrOnePerLine: false
 ConstructorInitializerIndentWidth: 2
 ContinuationIndentWidth: 2
 Cpp11BracedListStyle: true
 DerivePointerAlignment: false
 DisableFormat: false
-ExperimentalAutoDetectBinPacking: false
-ForEachMacros: [ foreach ]
+FixNamespaceComments: true
+ForEachMacros: []
+IndentCaseLabels: false
+IncludeCategories:
+  - Regex: '^("|<)stdafx\.h(pp)?("|>)'
+    Priority: -1
+  - Regex: '^<(W|w)indows.h>'
+    Priority: 1
+  - Regex: '^<'
+    Priority: 2
+  - Regex: '.*'
+    Priority: 3
+IncludeIsMainRegex: '(_test|_win|_linux|_mac|_ios|_osx|_null)?$'
 IndentCaseLabels: false
 IndentWidth: 4
 IndentWrappedFunctionNames: false
 KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd: ''
 MaxEmptyLinesToKeep: 1
 NamespaceIndentation: None
-ObjCBlockIndentWidth: 4
-ObjCSpaceAfterProperty: true
-ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 0
 PenaltyBreakBeforeFirstCallParameter: 1
 PenaltyBreakComment: 300
-PenaltyBreakString: 1000
 PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 9999999
 PointerAlignment: Left
+ReflowComments: true
+SortIncludes: false
+SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
 SpaceBeforeAssignmentOperators: true
 SpaceBeforeParens: ControlStatements
 SpaceInEmptyParentheses: false
@@ -59,4 +78,15 @@ SpacesInSquareBrackets: false
 Standard: Cpp11
 TabWidth: 4
 UseTab: Never
+---
+Language: Cpp
+---
+Language: ObjC
+ObjCBlockIndentWidth: 4
+ObjCSpaceAfterProperty: true
+ObjCSpaceBeforeProtocolList: false
+---
+Language: Java
+BasedOnStyle: Google
+BreakAfterJavaFieldAnnotations: true
 ...

.gitignore

@@ -2,3 +2,4 @@
 /.vscode/
 /thirdparty/
 .vs/
+.DS_Store

.travis.yml

@@ -0,0 +1,47 @@
+language: cpp
+
+env:
+  global:
+    - CLANG_FORMAT_SUFFIX="-dummy" # don't use formatting on Travis, this is
+                                   # needed not to use default 3.5 version
+                                   # which is too old.
+
+matrix:
+  include:
+    - os: linux
+      env: MATRIX_EVAL="CC=gcc-5 && CXX=g++-5"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-5
+    - os: linux
+      env: MATRIX_EVAL="CC=clang-4.0 && CXX=clang++-4.0"
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-trusty-4.0
+          packages:
+            - clang-4.0
+    - os: linux
+      env: MATRIX_EVAL="CC=clang-5.0 && CXX=clang++-5.0"
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-trusty-5.0
+          packages:
+            - clang-5.0
+    - os: osx
+      osx_image: xcode9
+
+# prevent Travis from overwriting our CXX variables
+before_install:
+    - eval "${MATRIX_EVAL}"
+    - echo $CXX
+
+script:
+    - mkdir build
+    - cd build
+    - cmake -DCLANG_FORMAT_SUFFIX=$CLANG_FORMAT_SUFFIX --config Release ..
+    - cmake --build . -- -j2

CMakeLists.txt

@@ -1,6 +1,10 @@
-cmake_minimum_required (VERSION 3.7.0)
+cmake_minimum_required (VERSION 3.2.0)
 project (DiscordRPC)
 
+include(GNUInstallDirs)
+
+option(BUILD_EXAMPLES "Build example apps" ON)
+
 # format
 file(GLOB_RECURSE ALL_SOURCE_FILES
     examples/*.cpp examples/*.h examples/*.c
@@ -8,22 +12,18 @@ file(GLOB_RECURSE ALL_SOURCE_FILES
     src/*.cpp src/*.h src/*.c
 )
 
-find_program(CLANG_FORMAT_CMD clang-format)
+# Set CLANG_FORMAT_SUFFIX if you are using custom clang-format, e.g. clang-format-5.0
+find_program(CLANG_FORMAT_CMD clang-format${CLANG_FORMAT_SUFFIX})
 
 if (CLANG_FORMAT_CMD)
     add_custom_target(
         clangformat
-        COMMAND clang-format
+        COMMAND ${CLANG_FORMAT_CMD}
         -i -style=file -fallback-style=none
         ${ALL_SOURCE_FILES}
         DEPENDS
         ${ALL_SOURCE_FILES}
     )
-else(CLANG_FORMAT_CMD)
-    add_custom_target(
-        clangformat
-        COMMENT "no clang format"
-    )
 endif(CLANG_FORMAT_CMD)
 
 # thirdparty stuff
@@ -32,7 +32,7 @@ execute_process(
     ERROR_QUIET
 )
 
-find_file(RAPIDJSONTEST NAMES rapidjson rapidjson-1.1.0 PATHS ${CMAKE_SOURCE_DIR}/thirdparty)
+find_file(RAPIDJSONTEST NAMES rapidjson rapidjson-1.1.0 PATHS ${CMAKE_SOURCE_DIR}/thirdparty CMAKE_FIND_ROOT_PATH_BOTH)
 if (NOT RAPIDJSONTEST)
     message("no rapidjson, download")
     set(RJ_TAR_FILE ${CMAKE_SOURCE_DIR}/thirdparty/v1.1.0.tar.gz)
@@ -44,11 +44,13 @@ if (NOT RAPIDJSONTEST)
     file(REMOVE ${RJ_TAR_FILE})
 endif(NOT RAPIDJSONTEST)
 
-find_file(RAPIDJSON NAMES rapidjson rapidjson-1.1.0 PATHS ${CMAKE_SOURCE_DIR}/thirdparty)
+find_file(RAPIDJSON NAMES rapidjson rapidjson-1.1.0 PATHS ${CMAKE_SOURCE_DIR}/thirdparty CMAKE_FIND_ROOT_PATH_BOTH)
 
 add_library(rapidjson STATIC IMPORTED ${RAPIDJSON})
 
 # add subdirs
 
 add_subdirectory(src)
-add_subdirectory(examples/send-presence)
+if (BUILD_EXAMPLES)
+    add_subdirectory(examples/send-presence)
+endif(BUILD_EXAMPLES)

LICENSE

@@ -0,0 +1,19 @@
+Copyright 2017 Discord, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,33 +1,27 @@
 # Discord RPC
 
-This is a lib and quick demos that implement the very minimal subset to show current status, and
-have callbacks for where a more complete game would do more things. You can use the lib directly
-if you like, or use it as a guide to writing your own if it doesn't suit your game as is.
+This is a library for interfacing your game with a locally running Discord desktop client. It's known to work on Windows, macOS, and Linux. You can use the lib directly if you like, or use it as a guide to writing your own if it doesn't suit your game as is. PRs/feedback welcome if you have an improvement everyone might want, or can describe how this doesn't meet your needs.
 
-PRs/feedback welcome if you have an improvement everyone might want, or can describe how this
-doesn't meet your needs.
+Included here are some quick demos that implement the very minimal subset to show current status, and
+have callbacks for where a more complete game would do more things (joining, spectating, etc).
 
 ## Documentation
 
-The most up to date documentation for Rich Presence can always be found in our [developer site](https://discordapp.com/developers/docs/topics/rich-presence)!
+The most up to date documentation for Rich Presence can always be found in our [developer site](https://discordapp.com/developers/docs/rich-presence/how-to)!
 
-## Usage
+## Basic Usage
 
 Zeroith, you should be set up to build things because you are a game developer, right?
 
-First, head on over to the [Discord developers site](https://discordapp.com/developers/applications/me)
-and make yourself an app. Keep track of `Client ID` -- you'll need it here to pass to the init
-function.
+First, head on over to the [Discord developers site](https://discordapp.com/developers/applications/me) and make yourself an app. Keep track of `Client ID` -- you'll need it here to pass to the init function.
 
 ### From package
 
-Download a release package, extract it, add `/include` to your compile includes, `/lib` to your
-linker paths, and link with `discord-rpc`.
+Download a release package for your platform(s) -- they have subdirs with various prebuilt options, select the one you need add `/include` to your compile includes, `/lib` to your linker paths, and link with `discord-rpc`. For the dynamically linked builds, you'll need to ship the associated file along with your game.
 
 ### From repo
 
-There's a [CMake](https://cmake.org/download/) file that should be able to generate the lib for
-you; I use it like this:
+There's a [CMake](https://cmake.org/download/) file that should be able to generate the lib for you; Sometimes I use it like this:
 ```sh
     cd <path to discord-rpc>
     mkdir build
@@ -35,25 +29,55 @@ you; I use it like this:
     cmake .. -DCMAKE_INSTALL_PREFIX=<path to install discord-rpc to>
     cmake --build . --config Release --target install
 ```
-Sometimes I use the generated project files. There are a couple of CMake options you might care about:
+There is a wrapper build script `build.py` that runs `cmake` with a few different options.
+
+Usually, I run `build.py` to get things started, then use the generated project files as I work on things. It does depend on `click` library, so do a quick `pip install click` to make sure you have it if you want to run `build.py`.
+
+There are some CMake options you might care about:
 
 | flag | default | does |
 |------|---------|------|
 | `ENABLE_IO_THREAD` | `ON` | When enabled, we start up a thread to do io processing, if disabled you should call `Discord_UpdateConnection` yourself.
-| `BUILD_DYNAMIC_LIB` | `OFF` | Build library as a DLL
+| `USE_STATIC_CRT` | `OFF` | (Windows) Enable to statically link the CRT, avoiding requiring users install the redistributable package. (The prebuilt binaries enable this option)
+| [`BUILD_SHARED_LIBS`](https://cmake.org/cmake/help/v3.7/variable/BUILD_SHARED_LIBS.html) | `OFF` | Build library as a DLL
+
+## Continuous Builds
+
+Why do we have three of these? Three times the fun!
+
+| CI | badge |
+|----|-------|
+| TravisCI | [![Build status](https://travis-ci.org/discordapp/discord-rpc.svg?branch=master)](https://travis-ci.org/discordapp/discord-rpc)
+| AppVeyor | [![Build status](https://ci.appveyor.com/api/projects/status/qvkoc0w1c4f4b8tj?svg=true)](https://ci.appveyor.com/project/crmarsh/discord-rpc)
+| Buildkite (internal) | [![Build status](https://badge.buildkite.com/e103d79d247f6776605a15246352a04b8fd83d69211b836111.svg)](https://buildkite.com/discord/discord-rpc)
 
 ## Sample: send-presence
 
-This is a text adventure "game" that inits/deinits the connection to Discord, and sends a presence
-update on each command.
+This is a text adventure "game" that inits/deinits the connection to Discord, and sends a presence update on each command.
 
 ## Sample: button-clicker
 
-This is a sample [Unity](https://unity3d.com/) project that wraps a DLL version of the library, and
-sends presence updates when you click on a button.
+This is a sample [Unity](https://unity3d.com/) project that wraps a DLL version of the library, and sends presence updates when you click on a button. Run `python build.py unity` in the root directory to build the correct library files and place them in their respective folders.
 
 ## Sample: unrealstatus
 
-This is a sample [Unreal](https://www.unrealengine.com) project that wraps the DLL version of the
-library with an Unreal plugin, exposes a blueprint class for interacting with it, and uses that to
-make a very simple UI.
+This is a sample [Unreal](https://www.unrealengine.com) project that wraps the DLL version of the library with an Unreal plugin, exposes a blueprint class for interacting with it, and uses that to make a very simple UI. Run `python build.py unreal` in the root directory to build the correct library files and place them in their respective folders.
+
+## Wrappers and Implementations
+
+Below is a table of unofficial, community-developed wrappers for and implementations of Rich Presence in various languages. If you would like to have yours added, please make a pull request adding your repository to the table. The repository should include:
+
+- The code
+- A brief ReadMe of how to use it
+- A working example
+
+###### Rich Presence Wrappers and Implementations
+
+| Name | Language |
+|------|----------|
+| [discord-rpc.jar](https://github.com/Vatuu/discord-rpc "Discord-RPC.jar") | Java |
+| [java-discord-rpc](https://github.com/MinnDevelopment/java-discord-rpc) | Java |
+| [Discord-IPC](https://github.com/jagrosh/DiscordIPC) | Java |
+| [Discord Rich Presence](https://npmjs.org/discord-rich-presence) | JavaScript |
+| [drpc4k](https://github.com/Bluexin/drpc4k) | [Kotlin](https://kotlinlang.org/) |
+| [SwordRPC](https://github.com/Azoy/SwordRPC) | [Swift](https://swift.org) |

appveyor.yml

@@ -0,0 +1,17 @@
+version: '{build}'
+install:
+  - python -m pip install click
+
+build_script:
+  - mkdir examples\unrealstatus\Plugins\discordrpc\Binaries\ThirdParty\discordrpcLibrary\Win64
+  - python build.py
+
+artifacts:
+- path: builds\install\win32-dynamic
+  name: win32-dynamic
+- path: builds\install\win32-static
+  name: win32-static
+- path: builds\install\win64-dynamic
+  name: win64-dynamic
+- path: builds\install\win64-static
+  name: win64-static

build.py

@@ -1,13 +1,39 @@
-import click
+#!/usr/bin/env python
+
 import os
 import subprocess
 import sys
 import shutil
 import zipfile
 from contextlib import contextmanager
+import click
+
+
+def get_platform():
+    """ a name for the platform """
+    if sys.platform.startswith('win'):
+        return 'win'
+    elif sys.platform == 'darwin':
+        return 'osx'
+    elif sys.platform.startswith('linux'):
+        return 'linux'
+    raise Exception('Unsupported platform ' + sys.platform)
 
 
 SCRIPT_PATH = os.path.dirname(os.path.abspath(__file__))
+# we use Buildkite which sets this env variable by default
+IS_BUILD_MACHINE = os.environ.get('CI', '') == 'true'
+PLATFORM = get_platform()
+INSTALL_ROOT = os.path.join(SCRIPT_PATH, 'builds', 'install')
+
+
+def get_signtool():
+    """ get path to code signing tool """
+    if PLATFORM == 'win':
+        sdk_dir = os.environ['WindowsSdkDir']
+        return os.path.join(sdk_dir, 'bin', 'x86', 'signtool.exe')
+    elif PLATFORM == 'osx':
+        return '/usr/bin/codesign'
 
 
 @contextmanager
@@ -24,64 +50,264 @@ def cd(new_dir):
 def mkdir_p(path):
     """ mkdir -p """
     if not os.path.isdir(path):
+        click.secho('Making ' + path, fg='yellow')
         os.makedirs(path)
 
 
-def build_lib(build_name, generator, options):
+@click.group(invoke_without_command=True)
+@click.pass_context
+@click.option('--clean', is_flag=True)
+def cli(ctx, clean):
+    """ click wrapper for command line stuff """
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(libs, clean=clean)
+        if IS_BUILD_MACHINE:
+            ctx.invoke(sign)
+        ctx.invoke(archive)
+
+
+@cli.command()
+@click.pass_context
+def unity(ctx):
+    """ build just dynamic libs for use in unity project """
+    ctx.invoke(
+        libs,
+        clean=False,
+        static=False,
+        shared=True,
+        skip_formatter=True,
+        just_release=True
+    )
+    BUILDS = []
+
+    click.echo('--- Copying libs and header into unity example')
+    UNITY_PROJECT_PATH = os.path.join(SCRIPT_PATH, 'examples', 'button-clicker', 'Assets', 'Plugins')
+
+    if sys.platform.startswith('win'):
+        LIBRARY_NAME = 'discord-rpc.dll'
+        BUILD_64_BASE_PATH = os.path.join(SCRIPT_PATH, 'builds', 'win64-dynamic', 'src', 'Release')
+        UNITY_64_DLL_PATH = os.path.join(UNITY_PROJECT_PATH, 'x86_64')
+        BUILDS.append({BUILD_64_BASE_PATH: UNITY_64_DLL_PATH})
+
+        BUILD_32_BASE_PATH = os.path.join(SCRIPT_PATH, 'builds', 'win32-dynamic', 'src', 'Release')
+        UNITY_32_DLL_PATH = os.path.join(UNITY_PROJECT_PATH, 'x86')
+        BUILDS.append({BUILD_32_BASE_PATH: UNITY_32_DLL_PATH})
+
+    elif sys.platform == 'darwin':
+        LIBRARY_NAME = 'discord-rpc.bundle'
+        BUILD_BASE_PATH = os.path.join(SCRIPT_PATH, 'builds', 'osx-dynamic', 'src')
+        UNITY_DLL_PATH = UNITY_PROJECT_PATH
+        os.rename(os.path.join(BUILD_BASE_PATH, 'libdiscord-rpc.dylib'), os.path.join(BUILD_BASE_PATH, 'discord-rpc.bundle'))
+
+        BUILDS.append({BUILD_BASE_PATH: UNITY_DLL_PATH})
+
+    elif sys.platform.startswith('linux'):
+        LIBRARY_NAME = 'discord-rpc.so'
+        BUILD_BASE_PATH = os.path.join(SCRIPT_PATH, 'builds', 'linux-dynamic', 'src')
+        UNITY_DLL_PATH = os.path.join(UNITY_PROJECT_PATH, 'x86')
+        os.rename(os.path.join(BUILD_BASE_PATH, 'libdiscord-rpc.so'), os.path.join(BUILD_BASE_PATH, 'discord-rpc.so'))
+
+        BUILDS.append({BUILD_BASE_PATH: UNITY_DLL_PATH})
+
+    else:
+        raise Exception('Unsupported platform ' + sys.platform)
+
+    for build in BUILDS:
+        for i in build:
+            mkdir_p(build[i])
+            shutil.copy(os.path.join(i, LIBRARY_NAME), build[i])
+
+
+@cli.command()
+@click.pass_context
+def unreal(ctx):
+    """ build libs and copy them into the unreal project """
+    ctx.invoke(
+        libs,
+        clean=False,
+        static=False,
+        shared=True,
+        skip_formatter=True,
+        just_release=True
+    )
+    BUILDS = []
+
+    click.echo('--- Copying libs and header into unreal example')
+    UNREAL_PROJECT_PATH = os.path.join(SCRIPT_PATH, 'examples', 'unrealstatus', 'Plugins', 'discordrpc')
+    UNREAL_INCLUDE_PATH = os.path.join(UNREAL_PROJECT_PATH, 'Source', 'ThirdParty', 'DiscordRpcLibrary', 'Include')
+    mkdir_p(UNREAL_INCLUDE_PATH)
+    shutil.copy(os.path.join(SCRIPT_PATH, 'include', 'discord_rpc.h'), UNREAL_INCLUDE_PATH)
+
+    if sys.platform.startswith('win'):
+        LIBRARY_NAME = 'discord-rpc.lib'
+        BUILD_64_BASE_PATH = os.path.join(SCRIPT_PATH, 'builds', 'win64-dynamic', 'src', 'Release')
+        UNREAL_64_DLL_PATH = os.path.join(UNREAL_PROJECT_PATH, 'Source', 'ThirdParty', 'DiscordRpcLibrary', 'Win64')
+        BUILDS.append({BUILD_64_BASE_PATH: UNREAL_64_DLL_PATH})
+
+        BUILD_32_BASE_PATH = os.path.join(SCRIPT_PATH, 'builds', 'win32-dynamic', 'src', 'Release')
+        UNREAL_32_DLL_PATH = os.path.join(UNREAL_PROJECT_PATH, 'Source', 'ThirdParty', 'DiscordRpcLibrary', 'Win32')
+        BUILDS.append({BUILD_32_BASE_PATH: UNREAL_32_DLL_PATH})
+
+    elif sys.platform == 'darwin':
+        LIBRARY_NAME = 'libdiscord-rpc.dylib'
+        BUILD_BASE_PATH = os.path.join(SCRIPT_PATH, 'builds', 'osx-dynamic', 'src')
+        UNREAL_DLL_PATH = os.path.join(UNREAL_PROJECT_PATH, 'Source', 'ThirdParty', 'DiscordRpcLibrary', 'Mac')
+
+        BUILDS.append({BUILD_BASE_PATH: UNREAL_DLL_PATH})
+
+    elif sys.platform.startswith('linux'):
+        LIBRARY_NAME = 'libdiscord-rpc.so'
+        BUILD_BASE_PATH = os.path.join(SCRIPT_PATH, 'builds', 'linux-dynamic', 'src')
+        UNREAL_DLL_PATH = os.path.join(UNREAL_PROJECT_PATH, 'Source', 'ThirdParty', 'DiscordRpcLibrary', 'Linux')
+
+        BUILDS.append({BUILD_BASE_PATH: UNREAL_DLL_PATH})
+
+    else:
+        raise Exception('Unsupported platform ' + sys.platform)
+
+    for build in BUILDS:
+        for i in build:
+            mkdir_p(build[i])
+            shutil.copy(os.path.join(i, LIBRARY_NAME), build[i])
+
+
+def build_lib(build_name, generator, options, just_release):
+    """ Create a dir under builds, run build and install in it """
     build_path = os.path.join(SCRIPT_PATH, 'builds', build_name)
-    install_path = os.path.join(SCRIPT_PATH, 'builds', 'install', build_name)
+    install_path = os.path.join(INSTALL_ROOT, build_name)
     mkdir_p(build_path)
     mkdir_p(install_path)
     with cd(build_path):
-        initial_cmake = ['cmake', SCRIPT_PATH, '-DCMAKE_INSTALL_PREFIX=%s' % os.path.join('..', 'install', build_name)]
+        initial_cmake = [
+            'cmake',
+            SCRIPT_PATH,
+            '-DCMAKE_INSTALL_PREFIX=%s' % os.path.join('..', 'install', build_name)
+        ]
         if generator:
             initial_cmake.extend(['-G', generator])
         for key in options:
-            val = 'ON' if options[key] else 'OFF'
-            initial_cmake.append('-D%s=%s' %(key, val))
+            val = options[key]
+            if type(val) is bool:
+                val = 'ON' if val else 'OFF'
+            initial_cmake.append('-D%s=%s' % (key, val))
+        click.echo('--- Building ' + build_name)
         subprocess.check_call(initial_cmake)
-        subprocess.check_call(['cmake', '--build', '.', '--config', 'Debug'])
+        if not just_release:
+            subprocess.check_call(['cmake', '--build', '.', '--config', 'Debug'])
         subprocess.check_call(['cmake', '--build', '.', '--config', 'Release', '--target', 'install'])
 
 
-def create_archive():
-    archive_file_path = os.path.join(SCRIPT_PATH, 'builds', 'discord-rpc.zip')
+@cli.command()
+def archive():
+    """ create zip of install dir """
+    click.echo('--- Archiving')
+    archive_file_path = os.path.join(SCRIPT_PATH, 'builds', 'discord-rpc-%s.zip' % get_platform())
     archive_file = zipfile.ZipFile(archive_file_path, 'w', zipfile.ZIP_DEFLATED)
-    archive_src_base_path = os.path.join(SCRIPT_PATH, 'builds', 'install')
+    archive_src_base_path = INSTALL_ROOT
     archive_dst_base_path = 'discord-rpc'
     with cd(archive_src_base_path):
-        for path, subdirs, filenames in os.walk('.'):
+        for path, _, filenames in os.walk('.'):
             for fname in filenames:
                 fpath = os.path.join(path, fname)
-                archive_file.write(fpath, os.path.normpath(os.path.join(archive_dst_base_path, fpath)))
+                dst_path = os.path.normpath(os.path.join(archive_dst_base_path, fpath))
+                click.echo('Adding ' + dst_path)
+                archive_file.write(fpath, dst_path)
 
 
-@click.command()
+@cli.command()
+def sign():
+    """ Do code signing within install directory using our cert """
+    tool = get_signtool()
+    signable_extensions = set()
+    if PLATFORM == 'win':
+        signable_extensions.add('.dll')
+        sign_command_base = [
+            tool,
+            'sign',
+            '/n', 'Hammer & Chisel Inc.',
+            '/a',
+            '/tr', 'http://timestamp.digicert.com/rfc3161',
+            '/as',
+            '/td', 'sha256',
+            '/fd', 'sha256',
+        ]
+    elif PLATFORM == 'osx':
+        signable_extensions.add('.dylib')
+        sign_command_base = [
+            tool,
+            '--keychain', os.path.expanduser('~/Library/Keychains/login.keychain'),
+            '-vvvv',
+            '--deep',
+            '--force',
+            '--sign', 'Developer ID Application: Hammer & Chisel Inc. (53Q6R32WPB)',
+        ]
+    else:
+        click.secho('Not signing things on this platform yet', fg='red')
+        return
+
+    click.echo('--- Signing')
+    for path, _, filenames in os.walk(INSTALL_ROOT):
+        for fname in filenames:
+            ext = os.path.splitext(fname)[1]
+            if ext not in signable_extensions:
+                continue
+            fpath = os.path.join(path, fname)
+            click.echo('Sign ' + fpath)
+            sign_command = sign_command_base + [fpath]
+            subprocess.check_call(sign_command)
+
+
+@cli.command()
 @click.option('--clean', is_flag=True)
-def main(clean):
-    os.chdir(SCRIPT_PATH)
-
+@click.option('--static', is_flag=True)
+@click.option('--shared', is_flag=True)
+@click.option('--skip_formatter', is_flag=True)
+@click.option('--just_release', is_flag=True)
+def libs(clean, static, shared, skip_formatter, just_release):
+    """ Do all the builds for this platform """
     if clean:
         shutil.rmtree('builds', ignore_errors=True)
 
-    if sys.platform.startswith('win'):
+    mkdir_p('builds')
+
+    if not (static or shared):
+        static = True
+        shared = True
+
+    static_options = {}
+    dynamic_options = {
+        'BUILD_SHARED_LIBS': True,
+        'USE_STATIC_CRT': True,
+    }
+
+    if skip_formatter or IS_BUILD_MACHINE:
+        static_options['CLANG_FORMAT_SUFFIX'] = 'none'
+        dynamic_options['CLANG_FORMAT_SUFFIX'] = 'none'
+
+    if IS_BUILD_MACHINE:
+        just_release = True
+
+    if PLATFORM == 'win':
         generator32 = 'Visual Studio 14 2015'
         generator64 = 'Visual Studio 14 2015 Win64'
-
-        build_lib('win32-static', generator32, {})
-        build_lib('win32-dynamic', generator32, {'BUILD_DYNAMIC_LIB': True})
-        build_lib('win64-static', generator64, {})
-        build_lib('win64-dynamic', generator64, {'BUILD_DYNAMIC_LIB': True})
-
-        # todo: this in some better way
-        src_dll = os.path.join(SCRIPT_PATH, 'builds', 'win64-dynamic', 'src', 'Release', 'discord-rpc.dll')
-        dst_dll = os.path.join(SCRIPT_PATH, 'examples', 'button-clicker', 'Assets', 'Resources', 'discord-rpc.dll')
-        shutil.copy(src_dll, dst_dll)
-        dst_dll = os.path.join(SCRIPT_PATH, 'examples', 'unrealstatus', 'Plugins', 'discordrpc', 'Binaries', 'ThirdParty', 'discordrpcLibrary', 'Win64', 'discord-rpc.dll')
-        shutil.copy(src_dll, dst_dll)
-
-    create_archive()
+        if static:
+            build_lib('win32-static', generator32, static_options, just_release)
+            build_lib('win64-static', generator64, static_options, just_release)
+        if shared:
+            build_lib('win32-dynamic', generator32, dynamic_options, just_release)
+            build_lib('win64-dynamic', generator64, dynamic_options, just_release)
+    elif PLATFORM == 'osx':
+        if static:
+            build_lib('osx-static', None, static_options, just_release)
+        if shared:
+            build_lib('osx-dynamic', None, dynamic_options, just_release)
+    elif PLATFORM == 'linux':
+        if static:
+            build_lib('linux-static', None, static_options, just_release)
+        if shared:
+            build_lib('linux-dynamic', None, dynamic_options, just_release)
 
 
 if __name__ == '__main__':
-    sys.exit(main())
+    os.chdir(SCRIPT_PATH)
+    sys.exit(cli())

documentation/hard-mode.md

@@ -10,7 +10,7 @@ By committing to an RPC-only integration, you decide to forego the work our libr
 
 ## Application Protocol Registration
 
-One thing that cannot be explicitly done over RPC is registering an application protocol for your game. If you choose to do an RPC-only implementation, you will have to register your application protocol yourself in the format of `discord-[your_app_id]://`. You can use `Discord_Register()` from `src/discord-register.cpp` as a good example of how to properly register an application protocol for use with Discord.
+One thing that cannot be explicitly done over RPC is registering an application protocol for your game. If you choose to do an RPC-only implementation, you will have to register your application protocol yourself in the format of `discord-[your_app_id]://`. You can use `Discord_Register()` as a good(?) example of how to properly register an application protocol for use with Discord. For OSX and Linux it is probably simpler to handle the protocol registration as part of your install/packaging.
 
 ## New RPC Command
 
@@ -56,7 +56,9 @@ Below is a full example of a `SET_ACTIVITY` command. Field restrictions like siz
 
 ## New RPC Events
 
-The two new RPC events for Rich Presence power the ability to join and spectate your friends' games. First is the `GAME_JOIN` event:
+The three new RPC events for Rich Presence power the ability to join and spectate your friends' games.
+
+First is the `ACTIVITY_JOIN` event:
 
 ```json
 {
@@ -64,11 +66,11 @@ The two new RPC events for Rich Presence power the ability to join and spectate
   "data": {
     "secret": "025ed05c71f639de8bfaa0d679d7c94b2fdce12f"
   },
-  "evnt": "GAME_JOIN"
+  "evt": "ACTIVITY_JOIN"
 }
 ```
 
-And second is the `GAME_SPECTATE` event:
+Second is the `ACTIVITY_SPECTATE` event:
 
 ```json
 {
@@ -76,7 +78,25 @@ And second is the `GAME_SPECTATE` event:
   "data": {
     "secret": "e7eb30d2ee025ed05c71ea495f770b76454ee4e0"
   },
-  "evnt": "GAME_SPECTATE"
+  "evt": "ACTIVITY_SPECTATE"
+}
+```
+
+And third is the `ACTIVITY_JOIN_REQUEST` event:
+
+```json
+{
+  "cmd": "DISPATCH",
+  "data": {
+    "user": {
+      "id": "53908232506183680",
+      "username": "Mason",
+      "discriminator": "1337",
+      "avatar": "a_bab14f271d565501444b2ca3be944b25"
+    },
+    "secret": "e459ca99273f59909dd16ed97865f3ad"
+  },
+  "evt": "ACTIVITY_JOIN_REQUEST"
 }
 ```
 
@@ -85,7 +105,7 @@ In order to receive these events, you need to [subscribe](https://discordapp.com
 ```json
 {
     "nonce": "be9a6de3-31d0-4767-a8e9-4818c5690015",
-    "evt": "GAME_JOIN",
+    "evt": "ACTIVITY_JOIN",
     "cmd": "SUBSCRIBE"
 }
 ```
@@ -93,7 +113,15 @@ In order to receive these events, you need to [subscribe](https://discordapp.com
 ```json
 {
     "nonce": "ae9qdde3-31d0-8989-a8e9-dnakwy174he",
-    "evt": "GAME_SPECTATE",
+    "evt": "ACTIVITY_SPECTATE",
+    "cmd": "SUBSCRIBE"
+}
+```
+
+```json
+{
+    "nonce": "5dc0c062-98c6-47a0-8922-bbb52e9d6afa",
+    "evt": "ACTIVITY_JOIN_REQUEST",
     "cmd": "SUBSCRIBE"
 }
 ```

examples/button-clicker/.gitignore

@@ -1,6 +1,8 @@
 /Library/
 /Temp/
 /obj/
+/Assets/Plugins/
+/Assets/Plugins.meta
 *.sln
 *.csproj
 *.userprefs

examples/button-clicker/Assets/DiscordController.cs

@@ -1,15 +1,28 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
-public class DiscordController : MonoBehaviour {
-    public DiscordRpc.RichPresence presence;
+[System.Serializable]
+public class DiscordJoinEvent : UnityEngine.Events.UnityEvent<string> { }
+
+[System.Serializable]
+public class DiscordSpectateEvent : UnityEngine.Events.UnityEvent<string> { }
+
+[System.Serializable]
+public class DiscordJoinRequestEvent : UnityEngine.Events.UnityEvent<DiscordRpc.JoinRequest> { }
+
+public class DiscordController : MonoBehaviour
+{
+    public DiscordRpc.RichPresence presence = new DiscordRpc.RichPresence();
     public string applicationId;
     public string optionalSteamId;
     public int callbackCalls;
     public int clickCounter;
+    public DiscordRpc.JoinRequest joinRequest;
     public UnityEngine.Events.UnityEvent onConnect;
     public UnityEngine.Events.UnityEvent onDisconnect;
+    public UnityEngine.Events.UnityEvent hasResponded;
+    public DiscordJoinEvent onJoin;
+    public DiscordJoinEvent onSpectate;
+    public DiscordJoinRequestEvent onJoinRequest;
 
     DiscordRpc.EventHandlers handlers;
 
@@ -20,7 +33,21 @@ public class DiscordController : MonoBehaviour {
 
         presence.details = string.Format("Button clicked {0} times", clickCounter);
 
-        DiscordRpc.UpdatePresence(ref presence);
+        DiscordRpc.UpdatePresence(presence);
+    }
+
+    public void RequestRespondYes()
+    {
+        Debug.Log("Discord: responding yes to Ask to Join request");
+        DiscordRpc.Respond(joinRequest.userId, DiscordRpc.Reply.Yes);
+        hasResponded.Invoke();
+    }
+
+    public void RequestRespondNo()
+    {
+        Debug.Log("Discord: responding no to Ask to Join request");
+        DiscordRpc.Respond(joinRequest.userId, DiscordRpc.Reply.No);
+        hasResponded.Invoke();
     }
 
     public void ReadyCallback()
@@ -47,18 +74,30 @@ public class DiscordController : MonoBehaviour {
     {
         ++callbackCalls;
         Debug.Log(string.Format("Discord: join ({0})", secret));
+        onJoin.Invoke(secret);
     }
 
     public void SpectateCallback(string secret)
     {
         ++callbackCalls;
         Debug.Log(string.Format("Discord: spectate ({0})", secret));
+        onSpectate.Invoke(secret);
     }
 
-    void Start () {
+    public void RequestCallback(ref DiscordRpc.JoinRequest request)
+    {
+        ++callbackCalls;
+        Debug.Log(string.Format("Discord: join request {0}#{1}: {2}", request.username, request.discriminator, request.userId));
+        joinRequest = request;
+        onJoinRequest.Invoke(request);
     }
 
-	void Update () {
+    void Start()
+    {
+    }
+
+    void Update()
+    {
         DiscordRpc.RunCallbacks();
     }
 
@@ -73,6 +112,7 @@ public class DiscordController : MonoBehaviour {
         handlers.errorCallback += ErrorCallback;
         handlers.joinCallback += JoinCallback;
         handlers.spectateCallback += SpectateCallback;
+        handlers.requestCallback += RequestCallback;
         DiscordRpc.Initialize(applicationId, ref handlers, true, optionalSteamId);
     }
 

examples/button-clicker/Assets/DiscordRpc.cs

@@ -1,22 +1,28 @@
-using System.Runtime.InteropServices;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
 
 public class DiscordRpc
 {
-    [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     public delegate void ReadyCallback();
 
-    [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     public delegate void DisconnectedCallback(int errorCode, string message);
 
-    [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     public delegate void ErrorCallback(int errorCode, string message);
 
-    [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     public delegate void JoinCallback(string secret);
 
-    [UnmanagedFunctionPointerAttribute(CallingConvention.Cdecl)]
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     public delegate void SpectateCallback(string secret);
 
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void RequestCallback(ref JoinRequest request);
+
     public struct EventHandlers
     {
         public ReadyCallback readyCallback;
@@ -24,11 +30,75 @@ public class DiscordRpc
         public ErrorCallback errorCallback;
         public JoinCallback joinCallback;
         public SpectateCallback spectateCallback;
+        public RequestCallback requestCallback;
     }
 
-    [System.Serializable]
-    public struct RichPresence
+    [Serializable, StructLayout(LayoutKind.Sequential)]
+    public struct RichPresenceStruct
     {
+        public IntPtr state; /* max 128 bytes */
+        public IntPtr details; /* max 128 bytes */
+        public long startTimestamp;
+        public long endTimestamp;
+        public IntPtr largeImageKey; /* max 32 bytes */
+        public IntPtr largeImageText; /* max 128 bytes */
+        public IntPtr smallImageKey; /* max 32 bytes */
+        public IntPtr smallImageText; /* max 128 bytes */
+        public IntPtr partyId; /* max 128 bytes */
+        public int partySize;
+        public int partyMax;
+        public IntPtr matchSecret; /* max 128 bytes */
+        public IntPtr joinSecret; /* max 128 bytes */
+        public IntPtr spectateSecret; /* max 128 bytes */
+        public bool instance;
+    }
+
+    [Serializable]
+    public struct JoinRequest
+    {
+        public string userId;
+        public string username;
+        public string discriminator;
+        public string avatar;
+    }
+
+    public enum Reply
+    {
+        No = 0,
+        Yes = 1,
+        Ignore = 2
+    }
+
+    [DllImport("discord-rpc", EntryPoint = "Discord_Initialize", CallingConvention = CallingConvention.Cdecl)]
+    public static extern void Initialize(string applicationId, ref EventHandlers handlers, bool autoRegister, string optionalSteamId);
+
+    [DllImport("discord-rpc", EntryPoint = "Discord_Shutdown", CallingConvention = CallingConvention.Cdecl)]
+    public static extern void Shutdown();
+
+    [DllImport("discord-rpc", EntryPoint = "Discord_RunCallbacks", CallingConvention = CallingConvention.Cdecl)]
+    public static extern void RunCallbacks();
+
+    [DllImport("discord-rpc", EntryPoint = "Discord_UpdatePresence", CallingConvention = CallingConvention.Cdecl)]
+    private static extern void UpdatePresenceNative(ref RichPresenceStruct presence);
+
+    [DllImport("discord-rpc", EntryPoint = "Discord_ClearPresence", CallingConvention = CallingConvention.Cdecl)]
+    public static extern void ClearPresence();
+
+    [DllImport("discord-rpc", EntryPoint = "Discord_Respond", CallingConvention = CallingConvention.Cdecl)]
+    public static extern void Respond(string userId, Reply reply);
+
+    public static void UpdatePresence(RichPresence presence)
+    {
+        var presencestruct = presence.GetStruct();
+        UpdatePresenceNative(ref presencestruct);
+        presence.FreeMem();
+    }
+
+    public class RichPresence
+    {
+        private RichPresenceStruct _presence;
+        private readonly List<IntPtr> _buffers = new List<IntPtr>(10);
+
         public string state; /* max 128 bytes */
         public string details; /* max 128 bytes */
         public long startTimestamp;
@@ -44,18 +114,104 @@ public class DiscordRpc
         public string joinSecret; /* max 128 bytes */
         public string spectateSecret; /* max 128 bytes */
         public bool instance;
+
+        /// <summary>
+        /// Get the <see cref="RichPresenceStruct"/> reprensentation of this instance
+        /// </summary>
+        /// <returns><see cref="RichPresenceStruct"/> reprensentation of this instance</returns>
+        internal RichPresenceStruct GetStruct()
+        {
+            if (_buffers.Count > 0)
+            {
+                FreeMem();
+            }
+
+            _presence.state = StrToPtr(state, 128);
+            _presence.details = StrToPtr(details, 128);
+            _presence.startTimestamp = startTimestamp;
+            _presence.endTimestamp = endTimestamp;
+            _presence.largeImageKey = StrToPtr(largeImageKey, 32);
+            _presence.largeImageText = StrToPtr(largeImageText, 128);
+            _presence.smallImageKey = StrToPtr(smallImageKey, 32);
+            _presence.smallImageText = StrToPtr(smallImageText, 128);
+            _presence.partyId = StrToPtr(partyId, 128);
+            _presence.partySize = partySize;
+            _presence.partyMax = partyMax;
+            _presence.matchSecret = StrToPtr(matchSecret, 128);
+            _presence.joinSecret = StrToPtr(joinSecret, 128);
+            _presence.spectateSecret = StrToPtr(spectateSecret, 128);
+            _presence.instance = instance;
+
+            return _presence;
+        }
+
+        /// <summary>
+        /// Returns a pointer to a representation of the given string with a size of maxbytes
+        /// </summary>
+        /// <param name="input">String to convert</param>
+        /// <param name="maxbytes">Max number of bytes to use</param>
+        /// <returns>Pointer to the UTF-8 representation of <see cref="input"/></returns>
+        private IntPtr StrToPtr(string input, int maxbytes)
+        {
+            if (string.IsNullOrEmpty(input)) return IntPtr.Zero;
+            var convstr = StrClampBytes(input, maxbytes);
+            var convbytecnt = Encoding.UTF8.GetByteCount(convstr);
+            var buffer = Marshal.AllocHGlobal(convbytecnt);
+            _buffers.Add(buffer);
+            Marshal.Copy(Encoding.UTF8.GetBytes(convstr), 0, buffer, convbytecnt);
+            return buffer;
+        }
+
+        /// <summary>
+        /// Convert string to UTF-8 and add null termination
+        /// </summary>
+        /// <param name="toconv">string to convert</param>
+        /// <returns>UTF-8 representation of <see cref="toconv"/> with added null termination</returns>
+        private static string StrToUtf8NullTerm(string toconv)
+        {
+            var str = toconv.Trim();
+            var bytes = Encoding.Default.GetBytes(str);
+            if (bytes.Length > 0 && bytes[bytes.Length - 1] != 0)
+            {
+                str += "\0\0";
+            }
+            return Encoding.UTF8.GetString(Encoding.UTF8.GetBytes(str));
+        }
+
+        /// <summary>
+        /// Clamp the string to the given byte length preserving null termination
+        /// </summary>
+        /// <param name="toclamp">string to clamp</param>
+        /// <param name="maxbytes">max bytes the resulting string should have (including null termination)</param>
+        /// <returns>null terminated string with a byte length less or equal to <see cref="maxbytes"/></returns>
+        private static string StrClampBytes(string toclamp, int maxbytes)
+        {
+            var str = StrToUtf8NullTerm(toclamp);
+            var strbytes = Encoding.UTF8.GetBytes(str);
+
+            if (strbytes.Length <= maxbytes)
+            {
+                return str;
+            }
+
+            var newstrbytes = new byte[] { };
+            Array.Copy(strbytes, 0, newstrbytes, 0, maxbytes - 1);
+            newstrbytes[newstrbytes.Length - 1] = 0;
+            newstrbytes[newstrbytes.Length - 2] = 0;
+
+            return Encoding.UTF8.GetString(newstrbytes);
+        }
+
+        /// <summary>
+        /// Free the allocated memory for conversion to <see cref="RichPresenceStruct"/>
+        /// </summary>
+        internal void FreeMem()
+        {
+            for (var i = _buffers.Count - 1; i >= 0; i--)
+            {
+                Marshal.FreeHGlobal(_buffers[i]);
+                _buffers.RemoveAt(i);
+            }
+        }
     }
-
-    [DllImport("discord-rpc", EntryPoint = "Discord_Initialize")]
-    public static extern void Initialize(string applicationId, ref EventHandlers handlers, bool autoRegister, string optionalSteamId);
-
-    [DllImport("discord-rpc", EntryPoint = "Discord_Shutdown")]
-    public static extern void Shutdown();
-
-    [DllImport("discord-rpc", EntryPoint = "Discord_RunCallbacks")]
-    public static extern void RunCallbacks();
-
-    [DllImport("discord-rpc", EntryPoint = "Discord_UpdatePresence")]
-    public static extern void UpdatePresence(ref RichPresence presence);
 }
-

examples/button-clicker/Assets/Editor/BuildHelper.cs

@@ -0,0 +1,101 @@
+using UnityEditor;
+using System.Diagnostics;
+using System.IO;
+
+[InitializeOnLoad]
+public class ScriptBatch
+{
+	static ScriptBatch()
+	{
+		EnsureDLL();
+	}
+
+	public static bool FileExists(string filename)
+	{
+		return new FileInfo(filename).Exists;
+	}
+
+	public static bool RunRpcBuildScript()
+	{
+		UnityEngine.Debug.Log("Try to run build script");
+
+		Process proc = new Process();
+#if UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX
+		proc.StartInfo.UseShellExecute = false;
+		// brew installs cmake in /usr/local/bin, which Unity seems to strip from PATH?
+		string newPath = proc.StartInfo.EnvironmentVariables["PATH"] + ":/usr/local/bin";
+		proc.StartInfo.EnvironmentVariables["PATH"] = newPath;
+#endif
+		proc.StartInfo.FileName = "python";
+		proc.StartInfo.Arguments = "build.py unity";
+		proc.StartInfo.WorkingDirectory = "../..";
+		proc.Start();
+		proc.WaitForExit();
+		return proc.ExitCode == 0;
+	}
+
+	public static void EnsureDLL()
+	{
+		#if UNITY_STANDALONE_WIN || UNITY_EDITOR_WIN
+		string[] dstDirs = { "Assets/Plugins", "Assets/Plugins/x86", "Assets/Plugins/x86_64" };
+		string[] dstDlls = { "Assets/Plugins/x86/discord-rpc.dll", "Assets/Plugins/x86_64/discord-rpc.dll" };
+		string[] srcDlls = { "../../builds/install/win64-dynamic/bin/discord-rpc.dll", "../../builds/install/win64-dynamic/bin/discord-rpc.dll" };
+		#elif UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX
+		string[] dstDirs = { "Assets/Plugins" };
+		string[] dstDlls = { "Assets/Plugins/discord-rpc.bundle" };
+		string[] srcDlls = { "../../builds/install/osx-dynamic/lib/libdiscord-rpc.dylib" };
+		#else
+		string[] dstDirs = { "Assets/Plugins", "Assets/Plugins/x86", "Assets/Plugins/x86_64" };
+		string[] dstDlls = { "Assets/Plugins/x86/discord-rpc.so", "Assets/Plugins/x86_64/discord-rpc.so" };
+		string[] srcDlls = { "../../builds/install/linux-dynamic/bin/discord-rpc.dll", "../../builds/install/win64-dynamic/bin/discord-rpc.dll" };
+		#endif
+
+		Debug.Assert(dstDlls.Length == srcDlls.Length);
+
+		bool exists = true;
+		foreach (string fname in dstDlls)
+		{
+			if (!FileExists(fname))
+			{
+				exists = false;
+				break;
+			}
+		}
+
+		if (exists)
+		{
+			return;
+		}
+
+		exists = true;
+		foreach (string fname in srcDlls)
+		{
+			if (!FileExists(fname))
+			{
+				exists = false;
+				break;
+			}
+		}
+
+		if (!exists)
+		{
+			if (!RunRpcBuildScript())
+			{
+				UnityEngine.Debug.LogError("Build failed");
+				return;
+			}
+		}
+
+		// make sure the dirs exist
+		foreach (string dirname in dstDirs)
+		{
+			Directory.CreateDirectory(dirname);
+		}
+
+		// Copy dlls
+		for (int i = 0; i < dstDlls.Length; ++i)
+		{
+			FileUtil.CopyFileOrDirectory(srcDlls[i], dstDlls[i]);
+		}
+	}
+}

examples/button-clicker/Assets/Editor/BuildHelper.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: e5aecc4633e5f594b85eaa39f49bb402
+timeCreated: 1512071254
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

examples/button-clicker/Assets/Resources.meta

@@ -1,9 +0,0 @@
-fileFormatVersion: 2
-guid: 4ddcc1759a3a2394fa1fa376963639e0
-folderAsset: yes
-timeCreated: 1501697278
-licenseType: Free
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

examples/button-clicker/Assets/Resources/discord-rpc.dll.meta

@@ -1,27 +0,0 @@
-fileFormatVersion: 2
-guid: 2aadd6305b09fa94dab94261a8bb8caf
-timeCreated: 1501697340
-licenseType: Free
-PluginImporter:
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  isPreloaded: 0
-  isOverridable: 0
-  platformData:
-    data:
-      first:
-        Any: 
-      second:
-        enabled: 1
-        settings: {}
-    data:
-      first:
-        Editor: Editor
-      second:
-        enabled: 0
-        settings:
-          DefaultValueInitialized: true
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

examples/button-clicker/Assets/main.unity

@@ -271,6 +271,80 @@ CanvasRenderer:
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 359174702}
+--- !u!1 &520806049
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 520806050}
+  - component: {fileID: 520806052}
+  - component: {fileID: 520806051}
+  m_Layer: 5
+  m_Name: Text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &520806050
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 520806049}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 806911717}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &520806051
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 520806049}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 708705254, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: UnityEngine.UI.MaskableGraphic+CullStateChangedEvent, UnityEngine.UI,
+      Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 14
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 4
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: Yes
+--- !u!222 &520806052
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 520806049}
 --- !u!1 &657463235
 GameObject:
   m_ObjectHideFlags: 0
@@ -345,6 +419,128 @@ RectTransform:
   m_AnchoredPosition: {x: 16, y: -19.00003}
   m_SizeDelta: {x: 239.20001, y: 37.799988}
   m_Pivot: {x: 0, y: 1}
+--- !u!1 &806911716
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 806911717}
+  - component: {fileID: 806911720}
+  - component: {fileID: 806911719}
+  - component: {fileID: 806911718}
+  m_Layer: 5
+  m_Name: ButtonRespondYes
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &806911717
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 806911716}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 520806050}
+  m_Father: {fileID: 1766020814}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: -129.1, y: -116.3}
+  m_SizeDelta: {x: 160, y: 30}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &806911718
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 806911716}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1392445389, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_DisabledTrigger: Disabled
+  m_Interactable: 0
+  m_TargetGraphic: {fileID: 806911719}
+  m_OnClick:
+    m_PersistentCalls:
+      m_Calls:
+      - m_Target: {fileID: 1929635629}
+        m_MethodName: RequestRespondYes
+        m_Mode: 1
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: 
+          m_BoolArgument: 0
+        m_CallState: 2
+    m_TypeName: UnityEngine.UI.Button+ButtonClickedEvent, UnityEngine.UI, Version=1.0.0.0,
+      Culture=neutral, PublicKeyToken=null
+--- !u!114 &806911719
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 806911716}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: -765806418, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: UnityEngine.UI.MaskableGraphic+CullStateChangedEvent, UnityEngine.UI,
+      Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+  m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+--- !u!222 &806911720
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 806911716}
 --- !u!1 &1032248338
 GameObject:
   m_ObjectHideFlags: 0
@@ -467,6 +663,80 @@ CanvasRenderer:
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1032248338}
+--- !u!1 &1238162986
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1238162987}
+  - component: {fileID: 1238162989}
+  - component: {fileID: 1238162988}
+  m_Layer: 5
+  m_Name: JoinRequestInfo
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1238162987
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1238162986}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1766020814}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: -0.0000085831, y: -66.9}
+  m_SizeDelta: {x: 323.38, y: 55.29}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1238162988
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1238162986}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 708705254, guid: f70555f144d8491a825f0804e09c671c, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 0.88965523, b: 0, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: UnityEngine.UI.MaskableGraphic+CullStateChangedEvent, UnityEngine.UI,
+      Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 14
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 1
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: No requests yet
+--- !u!222 &1238162989
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1238162986}
 --- !u!1 &1470895131
 GameObject:
   m_ObjectHideFlags: 0
@@ -616,6 +886,9 @@ RectTransform:
   m_Children:
   - {fileID: 1032248339}
   - {fileID: 657463238}
+  - {fileID: 806911717}
+  - {fileID: 1858885002}
+  - {fileID: 1238162987}
   m_Father: {fileID: 0}
   m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
@@ -624,6 +897,128 @@ RectTransform:
   m_AnchoredPosition: {x: 0, y: 0}
   m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0, y: 0}
+--- !u!1 &1858885001
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1858885002}
+  - component: {fileID: 1858885005}
+  - component: {fileID: 1858885004}
+  - component: {fileID: 1858885003}
+  m_Layer: 5
+  m_Name: ButtonRespondNo
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1858885002
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1858885001}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 1958982062}
+  m_Father: {fileID: 1766020814}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: 128.7, y: -116.3}
+  m_SizeDelta: {x: 160, y: 30}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1858885003
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1858885001}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1392445389, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Navigation:
+    m_Mode: 3
+    m_SelectOnUp: {fileID: 0}
+    m_SelectOnDown: {fileID: 0}
+    m_SelectOnLeft: {fileID: 0}
+    m_SelectOnRight: {fileID: 0}
+  m_Transition: 1
+  m_Colors:
+    m_NormalColor: {r: 1, g: 1, b: 1, a: 1}
+    m_HighlightedColor: {r: 0.9607843, g: 0.9607843, b: 0.9607843, a: 1}
+    m_PressedColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 1}
+    m_DisabledColor: {r: 0.78431374, g: 0.78431374, b: 0.78431374, a: 0.5019608}
+    m_ColorMultiplier: 1
+    m_FadeDuration: 0.1
+  m_SpriteState:
+    m_HighlightedSprite: {fileID: 0}
+    m_PressedSprite: {fileID: 0}
+    m_DisabledSprite: {fileID: 0}
+  m_AnimationTriggers:
+    m_NormalTrigger: Normal
+    m_HighlightedTrigger: Highlighted
+    m_PressedTrigger: Pressed
+    m_DisabledTrigger: Disabled
+  m_Interactable: 0
+  m_TargetGraphic: {fileID: 1858885004}
+  m_OnClick:
+    m_PersistentCalls:
+      m_Calls:
+      - m_Target: {fileID: 1929635629}
+        m_MethodName: RequestRespondNo
+        m_Mode: 1
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: 
+          m_BoolArgument: 0
+        m_CallState: 2
+    m_TypeName: UnityEngine.UI.Button+ButtonClickedEvent, UnityEngine.UI, Version=1.0.0.0,
+      Culture=neutral, PublicKeyToken=null
+--- !u!114 &1858885004
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1858885001}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: -765806418, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: UnityEngine.UI.MaskableGraphic+CullStateChangedEvent, UnityEngine.UI,
+      Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+  m_Sprite: {fileID: 10905, guid: 0000000000000000f000000000000000, type: 0}
+  m_Type: 1
+  m_PreserveAspect: 0
+  m_FillCenter: 1
+  m_FillMethod: 4
+  m_FillAmount: 1
+  m_FillClockwise: 1
+  m_FillOrigin: 0
+--- !u!222 &1858885005
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1858885001}
 --- !u!1 &1929635628
 GameObject:
   m_ObjectHideFlags: 0
@@ -653,7 +1048,7 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   presence:
     state: Button clicking
-    details: 
+    details: Best game ever
     startTimestamp: 0
     endTimestamp: 0
     largeImageKey: stable-large
@@ -663,14 +1058,19 @@ MonoBehaviour:
     partyId: abcdefg
     partySize: 1
     partyMax: 10
-    matchSecret: 
-    joinSecret: 
-    spectateSecret: 
-    instance: 0
+    matchSecret: match_secret
+    joinSecret: join_secret
+    spectateSecret: spectate_secret
+    instance: 1
   applicationId: 345229890980937739
   optionalSteamId: 
   callbackCalls: 0
   clickCounter: 0
+  joinRequest:
+    userId: 
+    username: 
+    discriminator: 
+    avatar: 
   onConnect:
     m_PersistentCalls:
       m_Calls:
@@ -703,6 +1103,92 @@ MonoBehaviour:
         m_CallState: 2
     m_TypeName: UnityEngine.Events.UnityEvent, UnityEngine, Version=0.0.0.0, Culture=neutral,
       PublicKeyToken=null
+  hasResponded:
+    m_PersistentCalls:
+      m_Calls:
+      - m_Target: {fileID: 1238162988}
+        m_MethodName: set_text
+        m_Mode: 5
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: No requests yet
+          m_BoolArgument: 0
+        m_CallState: 2
+      - m_Target: {fileID: 806911718}
+        m_MethodName: set_interactable
+        m_Mode: 6
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: 
+          m_BoolArgument: 0
+        m_CallState: 2
+      - m_Target: {fileID: 1858885003}
+        m_MethodName: set_interactable
+        m_Mode: 6
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: 
+          m_BoolArgument: 0
+        m_CallState: 2
+    m_TypeName: UnityEngine.Events.UnityEvent, UnityEngine, Version=0.0.0.0, Culture=neutral,
+      PublicKeyToken=null
+  onJoin:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: DiscordJoinEvent, Assembly-CSharp, Version=0.0.0.0, Culture=neutral,
+      PublicKeyToken=null
+  onSpectate:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: DiscordJoinEvent, Assembly-CSharp, Version=0.0.0.0, Culture=neutral,
+      PublicKeyToken=null
+  onJoinRequest:
+    m_PersistentCalls:
+      m_Calls:
+      - m_Target: {fileID: 1238162988}
+        m_MethodName: set_text
+        m_Mode: 5
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: Someone asked to join!
+          m_BoolArgument: 0
+        m_CallState: 2
+      - m_Target: {fileID: 806911718}
+        m_MethodName: set_interactable
+        m_Mode: 6
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: 
+          m_BoolArgument: 1
+        m_CallState: 2
+      - m_Target: {fileID: 1858885003}
+        m_MethodName: set_interactable
+        m_Mode: 6
+        m_Arguments:
+          m_ObjectArgument: {fileID: 0}
+          m_ObjectArgumentAssemblyTypeName: UnityEngine.Object, UnityEngine
+          m_IntArgument: 0
+          m_FloatArgument: 0
+          m_StringArgument: 
+          m_BoolArgument: 1
+        m_CallState: 2
+    m_TypeName: DiscordJoinRequestEvent, Assembly-CSharp, Version=0.0.0.0, Culture=neutral,
+      PublicKeyToken=null
 --- !u!4 &1929635630
 Transform:
   m_ObjectHideFlags: 0
@@ -716,3 +1202,77 @@ Transform:
   m_Father: {fileID: 0}
   m_RootOrder: 3
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1958982061
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1958982062}
+  - component: {fileID: 1958982064}
+  - component: {fileID: 1958982063}
+  m_Layer: 5
+  m_Name: Text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1958982062
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1958982061}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 1858885002}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1958982063
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1958982061}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 708705254, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 0.19607843, g: 0.19607843, b: 0.19607843, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: UnityEngine.UI.MaskableGraphic+CullStateChangedEvent, UnityEngine.UI,
+      Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 14
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 4
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: No
+--- !u!222 &1958982064
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1958982061}

examples/button-clicker/ProjectSettings/DynamicsManager.asset

@@ -17,3 +17,4 @@ PhysicsManager:
   m_EnablePCM: 1
   m_LayerCollisionMatrix: ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
   m_AutoSimulation: 1
+  m_AutoSyncTransforms: 1

examples/button-clicker/ProjectSettings/EditorBuildSettings.asset

@@ -4,4 +4,7 @@
 EditorBuildSettings:
   m_ObjectHideFlags: 0
   serializedVersion: 2
-  m_Scenes: []
+  m_Scenes:
+  - enabled: 1
+    path: Assets/main.unity
+    guid: 3b03d21bb25fa494e8694cd6e4b6d769

examples/button-clicker/ProjectSettings/Physics2DSettings.asset

@@ -24,6 +24,7 @@ Physics2DSettings:
   m_QueriesStartInColliders: 1
   m_ChangeStopsCallbacks: 0
   m_CallbacksOnDisable: 1
+  m_AutoSyncTransforms: 1
   m_AlwaysShowColliders: 0
   m_ShowColliderSleep: 1
   m_ShowColliderContacts: 0

examples/button-clicker/ProjectSettings/ProjectSettings.asset

@@ -3,14 +3,15 @@
 --- !u!129 &1
 PlayerSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 12
+  serializedVersion: 13
   productGUID: 5eccc60d3e382a346a65f512d6b81b84
   AndroidProfiler: 0
+  AndroidFilterTouchesWhenObscured: 0
   defaultScreenOrientation: 4
   targetDevice: 2
   useOnDemandResources: 0
   accelerometerFrequency: 60
-  companyName: DefaultCompany
+  companyName: Discord Inc.
   productName: button-clicker
   defaultCursor: {fileID: 0}
   cursorHotspot: {x: 0, y: 0}
@@ -38,8 +39,6 @@ PlayerSettings:
     width: 1
     height: 1
   m_SplashScreenLogos: []
-  m_SplashScreenBackgroundLandscape: {fileID: 0}
-  m_SplashScreenBackgroundPortrait: {fileID: 0}
   m_VirtualRealitySplashScreen: {fileID: 0}
   m_HolographicTrackingLossScreen: {fileID: 0}
   defaultScreenWidth: 1024
@@ -49,7 +48,6 @@ PlayerSettings:
   m_StereoRenderingPath: 0
   m_ActiveColorSpace: 0
   m_MTRendering: 1
-  m_MobileMTRendering: 0
   m_StackTraceTypes: 010000000100000001000000010000000100000001000000
   iosShowActivityIndicatorOnLoading: -1
   androidShowActivityIndicatorOnLoading: -1
@@ -64,8 +62,10 @@ PlayerSettings:
   useOSAutorotation: 1
   use32BitDisplayBuffer: 1
   disableDepthAndStencilBuffers: 0
+  androidBlitType: 0
   defaultIsFullScreen: 1
   defaultIsNativeResolution: 1
+  macRetinaSupport: 1
   runInBackground: 0
   captureSingleScreen: 0
   muteOtherAudioSources: 0
@@ -95,6 +95,7 @@ PlayerSettings:
   xboxEnableHeadOrientation: 0
   xboxEnableGuest: 0
   xboxEnablePIXSampling: 0
+  metalFramebufferOnly: 0
   n3dsDisableStereoscopicView: 0
   n3dsEnableSharedListOpt: 1
   n3dsEnableVSync: 0
@@ -103,6 +104,7 @@ PlayerSettings:
   xboxOneMonoLoggingLevel: 0
   xboxOneLoggingLevel: 1
   xboxOneDisableEsram: 0
+  xboxOnePresentImmediateThreshold: 0
   videoMemoryForVertexBuffers: 0
   psp2PowerMode: 0
   psp2AcquireBGM: 1
@@ -134,12 +136,17 @@ PlayerSettings:
     daydream:
       depthFormat: 0
       useSustainedPerformanceMode: 0
+      enableVideoLayer: 0
+      useProtectedVideoMemory: 0
     hololens:
       depthFormat: 1
   protectGraphicsMemory: 0
   useHDRDisplay: 0
+  m_ColorGamuts: 00000000
   targetPixelDensity: 0
   resolutionScalingMode: 0
+  androidSupportedAspectRatio: 1
+  androidMaxAspectRatio: 2.1
   applicationIdentifier: {}
   buildNumber: {}
   AndroidBundleVersionCode: 1
@@ -160,10 +167,10 @@ PlayerSettings:
     serializedVersion: 2
     m_Bits: 238
   iPhoneSdkVersion: 988
-  iOSTargetOSVersionString: 
+  iOSTargetOSVersionString: 7.0
   tvOSSdkVersion: 0
   tvOSRequireExtendedGameController: 0
-  tvOSTargetOSVersionString: 
+  tvOSTargetOSVersionString: 9.0
   uIPrerenderedIcon: 0
   uIRequiresPersistentWiFi: 0
   uIRequiresFullScreen: 1
@@ -220,7 +227,9 @@ PlayerSettings:
   AndroidKeyaliasName: 
   AndroidTVCompatibility: 1
   AndroidIsGame: 1
+  AndroidEnableTango: 0
   androidEnableBanner: 1
+  androidUseLowAccuracyLocation: 0
   m_AndroidBanners:
   - width: 320
     height: 180
@@ -231,10 +240,14 @@ PlayerSettings:
   m_BuildTargetBatching: []
   m_BuildTargetGraphicsAPIs: []
   m_BuildTargetVRSettings: []
+  m_BuildTargetEnableVuforiaSettings: []
   openGLRequireES31: 0
   openGLRequireES31AEP: 0
-  webPlayerTemplate: APPLICATION:Default
   m_TemplateCustomTags: {}
+  mobileMTRendering:
+    Android: 1
+    iPhone: 1
+    tvOS: 1
   wiiUTitleID: 0005000011000000
   wiiUGroupID: 00010000
   wiiUCommonSaveSize: 4096
@@ -368,6 +381,9 @@ PlayerSettings:
   switchUdpSendBufferSize: 9
   switchUdpReceiveBufferSize: 42
   switchSocketBufferEfficiency: 4
+  switchSocketInitializeEnabled: 1
+  switchNetworkInterfaceManagerInitializeEnabled: 1
+  switchPlayerConnectionEnabled: 1
   ps4NPAgeRating: 12
   ps4NPTitleSecret: 
   ps4NPTrophyPackPath: 

examples/button-clicker/ProjectSettings/ProjectVersion.txt

@@ -1 +1 @@
-m_EditorVersion: 2017.1.0f3
+m_EditorVersion: 2017.2.0f3

examples/button-clicker/UnityPackageManager/manifest.json

@@ -0,0 +1,4 @@
+{
+	"dependencies": {
+	}
+}

examples/send-presence/CMakeLists.txt

@@ -1,5 +1,13 @@
 include_directories(${PROJECT_SOURCE_DIR}/include)
-add_executable(send-presence send-presence.c)
+add_executable(
+    send-presence
+    MACOSX_BUNDLE
+    send-presence.c
+)
+set_target_properties(send-presence PROPERTIES
+    MACOSX_BUNDLE_BUNDLE_NAME "Send Presence"
+    MACOSX_BUNDLE_GUI_IDENTIFIER "com.discordapp.examples.send-presence"
+)
 target_link_libraries(send-presence discord-rpc)
 
 install(
@@ -7,4 +15,7 @@ install(
     RUNTIME
         DESTINATION "bin"
         CONFIGURATIONS Release
+    BUNDLE
+        DESTINATION "bin"
+        CONFIGURATIONS Release
 )

examples/send-presence/send-presence.c

@@ -9,35 +9,55 @@
 #include <string.h>
 #include <time.h>
 
-#include "discord-rpc.h"
+#include "discord_rpc.h"
 
 static const char* APPLICATION_ID = "345229890980937739";
 static int FrustrationLevel = 0;
 static int64_t StartTime;
+static int SendPresence = 1;
+
+static int prompt(char* line, size_t size)
+{
+    int res;
+    char* nl;
+    printf("\n> ");
+    fflush(stdout);
+    res = fgets(line, (int)size, stdin) ? 1 : 0;
+    line[size - 1] = 0;
+    nl = strchr(line, '\n');
+    if (nl) {
+        *nl = 0;
+    }
+    return res;
+}
 
 static void updateDiscordPresence()
 {
-    char buffer[256];
-    DiscordRichPresence discordPresence;
-    memset(&discordPresence, 0, sizeof(discordPresence));
-    discordPresence.state = "West of House";
-    sprintf(buffer, "Frustration level: %d", FrustrationLevel);
-    discordPresence.details = buffer;
-    discordPresence.startTimestamp = StartTime;
-    discordPresence.endTimestamp = time(0) + 5 * 60;
-    discordPresence.largeImageKey = "canary-large";
-    discordPresence.smallImageKey = "ptb-small";
-    discordPresence.partyId = "party1234";
-    discordPresence.partySize = 1;
-    discordPresence.partyMax = 6;
-    discordPresence.matchSecret = "xyzzy";
-    discordPresence.joinSecret = "join";
-    discordPresence.spectateSecret = "look";
-    discordPresence.instance = 0;
-    Discord_UpdatePresence(&discordPresence);
+    if (SendPresence) {
+        char buffer[256];
+        DiscordRichPresence discordPresence;
+        memset(&discordPresence, 0, sizeof(discordPresence));
+        discordPresence.state = "West of House";
+        sprintf(buffer, "Frustration level: %d", FrustrationLevel);
+        discordPresence.details = buffer;
+        discordPresence.startTimestamp = StartTime;
+        discordPresence.endTimestamp = time(0) + 5 * 60;
+        discordPresence.largeImageKey = "canary-large";
+        discordPresence.smallImageKey = "ptb-small";
+        discordPresence.partyId = "party1234";
+        discordPresence.partySize = 1;
+        discordPresence.partyMax = 6;
+        discordPresence.matchSecret = "xyzzy";
+        discordPresence.joinSecret = "join";
+        discordPresence.spectateSecret = "look";
+        discordPresence.instance = 0;
+        Discord_UpdatePresence(&discordPresence);
+    } else {
+        Discord_ClearPresence();
+    }
 }
 
-static void handleDiscordReady()
+static void handleDiscordReady(void)
 {
     printf("\nDiscord: ready\n");
 }
@@ -62,19 +82,37 @@ static void handleDiscordSpectate(const char* secret)
     printf("\nDiscord: spectate (%s)\n", secret);
 }
 
-static int prompt(char* line, size_t size)
+static void handleDiscordJoinRequest(const DiscordJoinRequest* request)
 {
-    int res;
-    char* nl;
-    printf("\n> ");
-    fflush(stdout);
-    res = fgets(line, (int)size, stdin) ? 1 : 0;
-    line[size - 1] = 0;
-    nl = strchr(line, '\n');
-    if (nl) {
-        *nl = 0;
+    int response = -1;
+    char yn[4];
+    printf("\nDiscord: join request from %s - %s - %s\n",
+           request->username,
+           request->avatar,
+           request->userId);
+    do {
+        printf("Accept? (y/n)");
+        if (!prompt(yn, sizeof(yn))) {
+            break;
+        }
+
+        if (!yn[0]) {
+            continue;
+        }
+
+        if (yn[0] == 'y') {
+            response = DISCORD_REPLY_YES;
+            break;
+        }
+
+        if (yn[0] == 'n') {
+            response = DISCORD_REPLY_NO;
+            break;
+        }
+    } while (1);
+    if (response != -1) {
+        Discord_Respond(request->userId, response);
     }
-    return res;
 }
 
 static void discordInit()
@@ -86,6 +124,7 @@ static void discordInit()
     handlers.errored = handleDiscordError;
     handlers.joinGame = handleDiscordJoin;
     handlers.spectateGame = handleDiscordSpectate;
+    handlers.joinRequest = handleDiscordJoinRequest;
     Discord_Initialize(APPLICATION_ID, &handlers, 1, NULL);
 }
 
@@ -109,6 +148,18 @@ static void gameLoop()
                 continue;
             }
 
+            if (line[0] == 'c') {
+                if (SendPresence) {
+                    printf("Clearing presence information.\n");
+                    SendPresence = 0;
+                } else {
+                    printf("Restoring presence information.\n");
+                    SendPresence = 1;
+                }
+                updateDiscordPresence();
+                continue;
+            }
+
             if (line[0] == 'y') {
                 printf("Reinit Discord.\n");
                 discordInit();

examples/unrealstatus/.gitignore

@@ -73,3 +73,6 @@ Intermediate/
 
 # Cache files for the editor to use
 DerivedDataCache/
+
+# Library headers must be copied automatically by the build script (build.py unreal)
+Plugins/DiscordRpc/Source/ThirdParty/DiscordRpcLibrary/Include

examples/unrealstatus/Plugins/discordrpc/DiscordRpc.uplugin

@@ -15,9 +15,15 @@
 	"Installed": false,
 	"Modules": [
 		{
-			"Name": "discordrpc",
-			"Type": "Developer",
-			"LoadingPhase": "Default"
+			"Name": "DiscordRpc",
+			"Type": "Runtime",
+			"LoadingPhase": "PreDefault",
+			"WhitelistPlatforms" :
+			[
+				"Win64",
+				"Linux",
+				"Mac"
+			]
 		}
 	]
 }

examples/unrealstatus/Plugins/discordrpc/Source/DiscordRpc/DiscordRpc.Build.cs

@@ -0,0 +1,57 @@
+// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
+
+using UnrealBuildTool;
+using System.IO;
+
+public class DiscordRpc : ModuleRules
+{
+#if WITH_FORWARDED_MODULE_RULES_CTOR
+    public DiscordRpc(ReadOnlyTargetRules Target) : base(Target)
+#else
+    public DiscordRpc(TargetInfo Target)
+#endif
+    {
+        Definitions.Add("DISCORD_DYNAMIC_LIB=1");
+
+        PublicIncludePaths.AddRange(
+            new string[] {
+                "DiscordRpc/Public"
+            }
+            );
+
+        PrivateIncludePaths.AddRange(
+            new string[] {
+                "DiscordRpc/Private"
+            }
+            );
+
+        PublicDependencyModuleNames.AddRange(
+            new string[]
+            {
+                "Core",
+                "DiscordRpcLibrary"
+            }
+            );
+
+        PrivateDependencyModuleNames.AddRange(
+            new string[]
+            {
+                "CoreUObject",
+                "Engine",
+                "Slate",
+                "SlateCore",
+                "Projects"
+            }
+            );
+
+        DynamicallyLoadedModuleNames.AddRange(
+            new string[]
+            {
+                // ... add any modules that your module loads dynamically here ...
+            }
+            );
+
+        string BaseDirectory = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "Source", "ThirdParty", "DiscordRpcLibrary"));
+        PublicIncludePaths.Add(Path.Combine(BaseDirectory, "Include"));
+    }
+}

examples/unrealstatus/Plugins/discordrpc/Source/DiscordRpc/Private/DiscordRpc.cpp

@@ -0,0 +1,71 @@
+// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
+
+#include "DiscordRpcPrivatePCH.h"
+#include "IPluginManager.h"
+#include "ModuleManager.h"
+
+#define LOCTEXT_NAMESPACE "FDiscordRpcModule"
+
+void FDiscordRpcModule::StartupModule()
+{
+#if !PLATFORM_LINUX
+#if defined(DISCORD_DYNAMIC_LIB)
+    // Get the base directory of this plugin
+    FString BaseDir = IPluginManager::Get().FindPlugin("DiscordRpc")->GetBaseDir();
+    const FString SDKDir = FPaths::Combine(*BaseDir, TEXT("Source"), TEXT("ThirdParty"), TEXT("DiscordRpcLibrary"));
+#if PLATFORM_WINDOWS
+    const FString LibName = TEXT("discord-rpc");
+    const FString LibDir = FPaths::Combine(*SDKDir, TEXT("Win64"));
+    if (!LoadDependency(LibDir, LibName, DiscordRpcLibraryHandle)) {
+        FMessageDialog::Open(EAppMsgType::Ok, LOCTEXT(LOCTEXT_NAMESPACE, "Failed to load DiscordRpc plugin. Plug-in will not be functional."));
+        FreeDependency(DiscordRpcLibraryHandle);
+    }
+#elif PLATFORM_MAC
+    const FString LibName = TEXT("libdiscord-rpc");
+    const FString LibDir = FPaths::Combine(*SDKDir, TEXT("Mac"));
+    if (!LoadDependency(LibDir, LibName, DiscordRpcLibraryHandle)) {
+        FMessageDialog::Open(EAppMsgType::Ok, LOCTEXT(LOCTEXT_NAMESPACE, "Failed to load DiscordRpc plugin. Plug-in will not be functional."));
+        FreeDependency(DiscordRpcLibraryHandle);
+    }
+#endif
+#endif
+#endif
+}
+
+void FDiscordRpcModule::ShutdownModule()
+{
+    // Free the dll handle
+#if !PLATFORM_LINUX
+#if defined(DISCORD_DYNAMIC_LIB)
+    FreeDependency(DiscordRpcLibraryHandle);
+#endif
+#endif
+}
+
+bool FDiscordRpcModule::LoadDependency(const FString& Dir, const FString& Name, void*& Handle)
+{
+    FString Lib = Name + TEXT(".") + FPlatformProcess::GetModuleExtension();
+    FString Path = Dir.IsEmpty() ? *Lib : FPaths::Combine(*Dir, *Lib);
+
+    Handle = FPlatformProcess::GetDllHandle(*Path);
+
+    if (Handle == nullptr)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+void FDiscordRpcModule::FreeDependency(void*& Handle)
+{
+    if (Handle != nullptr)
+    {
+        FPlatformProcess::FreeDllHandle(Handle);
+        Handle = nullptr;
+    }
+}
+
+#undef LOCTEXT_NAMESPACE
+
+IMPLEMENT_MODULE(FDiscordRpcModule, DiscordRpc)

examples/unrealstatus/Plugins/discordrpc/Source/DiscordRpc/Private/DiscordRpcBlueprint.cpp

@@ -1,12 +1,11 @@
-
-
+#include "DiscordRpcPrivatePCH.h"
 #include "DiscordRpcBlueprint.h"
-
-#include "discord-rpc.h"
+#include "discord_rpc.h"
 
 DEFINE_LOG_CATEGORY(Discord)
 
 static UDiscordRpc* self = nullptr;
+
 static void ReadyHandler()
 {
     UE_LOG(Discord, Log, TEXT("Discord connected"));
@@ -53,9 +52,22 @@ static void SpectateGameHandler(const char* spectateSecret)
     }
 }
 
+static void JoinRequestHandler(const DiscordJoinRequest* request)
+{
+    FDiscordJoinRequestData jr;
+    jr.userId = ANSI_TO_TCHAR(request->userId);
+    jr.username = ANSI_TO_TCHAR(request->username);
+    jr.discriminator = ANSI_TO_TCHAR(request->discriminator);
+    jr.avatar = ANSI_TO_TCHAR(request->avatar);
+    UE_LOG(Discord, Log, TEXT("Discord join request from %s - %s#%s"), *jr.userId, *jr.username, *jr.discriminator);
+    if (self) {
+        self->OnJoinRequest.Broadcast(jr);
+    }
+}
+
 void UDiscordRpc::Initialize(const FString& applicationId,
-                             bool autoRegister,
-                             const FString& optionalSteamId)
+    bool autoRegister,
+    const FString& optionalSteamId)
 {
     self = this;
     IsConnected = false;
@@ -69,10 +81,13 @@ void UDiscordRpc::Initialize(const FString& applicationId,
     if (OnSpectate.IsBound()) {
         handlers.spectateGame = SpectateGameHandler;
     }
+    if (OnJoinRequest.IsBound()) {
+        handlers.joinRequest = JoinRequestHandler;
+    }
     auto appId = StringCast<ANSICHAR>(*applicationId);
     auto steamId = StringCast<ANSICHAR>(*optionalSteamId);
     Discord_Initialize(
-      (const char*)appId.Get(), &handlers, autoRegister, (const char*)steamId.Get());
+        (const char*)appId.Get(), &handlers, autoRegister, (const char*)steamId.Get());
 }
 
 void UDiscordRpc::Shutdown()
@@ -119,12 +134,21 @@ void UDiscordRpc::UpdatePresence()
 
     auto spectateSecret = StringCast<ANSICHAR>(*RichPresence.spectateSecret);
     rp.spectateSecret = spectateSecret.Get();
-
-    rp.startTimestamp = RichPresence.startTimestamp;
-    rp.endTimestamp = RichPresence.endTimestamp;
     rp.partySize = RichPresence.partySize;
     rp.partyMax = RichPresence.partyMax;
     rp.instance = RichPresence.instance;
 
     Discord_UpdatePresence(&rp);
 }
+
+void UDiscordRpc::ClearPresence()
+{
+    Discord_ClearPresence();
+}
+
+void UDiscordRpc::Respond(const FString& userId, int reply)
+{
+    UE_LOG(Discord, Log, TEXT("Responding %d to join request from %s"), reply, *userId);
+    FTCHARToUTF8 utf8_userid(*userId);
+    Discord_Respond(utf8_userid.Get(), reply);
+}

examples/unrealstatus/Plugins/discordrpc/Source/DiscordRpc/Private/DiscordRpcPrivatePCH.h

@@ -0,0 +1,2 @@
+#include "Core.h"
+#include "DiscordRpc.h"

examples/unrealstatus/Plugins/discordrpc/Source/DiscordRpc/Public/DiscordRpc.h

@@ -0,0 +1,20 @@
+// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include "ModuleManager.h"
+
+class FDiscordRpcModule : public IModuleInterface {
+public:
+    /** IModuleInterface implementation */
+    virtual void StartupModule() override;
+    virtual void ShutdownModule() override;
+
+private:
+    /** Handle to the test dll we will load */
+    void* DiscordRpcLibraryHandle;
+
+    /** StartupModule is covered with defines, these functions are the place to put breakpoints */
+    static bool LoadDependency(const FString& Dir, const FString& Name, void*& Handle);
+    static void FreeDependency(void*& Handle);
+};

examples/unrealstatus/Plugins/discordrpc/Source/DiscordRpc/Public/DiscordRpcBlueprint.h

@@ -1,14 +1,30 @@
-
-
 #pragma once
 
-#include "Engine.h"
 #include "CoreMinimal.h"
+#include "Engine.h"
 #include "DiscordRpcBlueprint.generated.h"
 
 // unreal's header tool hates clang-format
 // clang-format off
 
+/**
+* Ask to join callback data
+*/
+USTRUCT(BlueprintType)
+struct FDiscordJoinRequestData {
+    GENERATED_USTRUCT_BODY()
+
+    UPROPERTY(BlueprintReadOnly)
+    FString userId;
+    UPROPERTY(BlueprintReadOnly)
+    FString username;
+    UPROPERTY(BlueprintReadOnly)
+    FString discriminator;
+    UPROPERTY(BlueprintReadOnly)
+    FString avatar;
+};
+
+
 DECLARE_LOG_CATEGORY_EXTERN(Discord, Log, All);
 
 DECLARE_DYNAMIC_MULTICAST_DELEGATE(FDiscordConnected);
@@ -16,6 +32,7 @@ DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FDiscordDisconnected, int, errorCod
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FDiscordErrored, int, errorCode, const FString&, errorMessage);
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDiscordJoin, const FString&, joinSecret);
 DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDiscordSpectate, const FString&, spectateSecret);
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDiscordJoinRequest, const FDiscordJoinRequestData&, joinRequest);
 
 // clang-format on
 
@@ -89,6 +106,16 @@ public:
               Category = "Discord")
     void UpdatePresence();
 
+    UFUNCTION(BlueprintCallable,
+              meta = (DisplayName = "Clear presence", Keywords = "Discord rpc"),
+              Category = "Discord")
+    void ClearPresence();
+
+    UFUNCTION(BlueprintCallable,
+              meta = (DisplayName = "Respond to join request", Keywords = "Discord rpc"),
+              Category = "Discord")
+    void Respond(const FString& userId, int reply);
+
     UPROPERTY(BlueprintReadOnly,
               meta = (DisplayName = "Is Discord connected", Keywords = "Discord rpc"),
               Category = "Discord")
@@ -119,6 +146,12 @@ public:
               Category = "Discord")
     FDiscordSpectate OnSpectate;
 
+    UPROPERTY(BlueprintAssignable,
+              meta = (DisplayName = "When Discord another user sends a join request",
+                      Keywords = "Discord rpc"),
+              Category = "Discord")
+    FDiscordJoinRequest OnJoinRequest;
+
     UPROPERTY(BlueprintReadWrite,
               meta = (DisplayName = "Rich presence info", Keywords = "Discord rpc"),
               Category = "Discord")

examples/unrealstatus/Plugins/discordrpc/Source/ThirdParty/DiscordRpcLibrary/DiscordRpcLibrary.Build.cs

@@ -0,0 +1,59 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+using System.IO;
+using UnrealBuildTool;
+
+public class DiscordRpcLibrary : ModuleRules
+{
+#if WITH_FORWARDED_MODULE_RULES_CTOR
+    public DiscordRpcLibrary(ReadOnlyTargetRules Target) : base(Target)
+#else
+    public DiscordRpcLibrary(TargetInfo Target)
+#endif
+    {
+        Type = ModuleType.External;
+        Definitions.Add("DISCORD_DYNAMIC_LIB=1");
+
+        string BaseDirectory = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty", "DiscordRpcLibrary"));
+
+        if (Target.Platform == UnrealTargetPlatform.Win64)
+        {
+            string lib = Path.Combine(BaseDirectory, "Win64");
+
+            // Include headers
+            PublicIncludePaths.Add(Path.Combine(BaseDirectory, "Include"));
+
+            // Add the import library
+            PublicLibraryPaths.Add(lib);
+            PublicAdditionalLibraries.Add(Path.Combine(lib, "discord-rpc.lib"));
+
+            // Dynamic
+            RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(lib, "discord-rpc.dll")));
+            PublicDelayLoadDLLs.Add("discord-rpc.dll");
+        }
+        else if (Target.Platform == UnrealTargetPlatform.Linux)
+        {
+            string lib = Path.Combine(BaseDirectory, "Linux", "x86_64-unknown-linux-gnu");
+
+            // Include headers
+            PublicIncludePaths.Add(Path.Combine(BaseDirectory, "Include"));
+
+            // Add the import library
+            PublicLibraryPaths.Add(lib);
+            PublicAdditionalLibraries.Add(Path.Combine(lib, "libdiscord-rpc.so"));
+            RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(lib, "libdiscord-rpc.so")));
+        }
+        else if (Target.Platform == UnrealTargetPlatform.Mac)
+        {
+            string lib = Path.Combine(BaseDirectory, "Mac");
+
+            // Include headers
+            PublicIncludePaths.Add(Path.Combine(BaseDirectory, "Include"));
+
+            // Add the import library
+            PublicLibraryPaths.Add(lib);
+            PublicAdditionalLibraries.Add(Path.Combine(lib, "libdiscord-rpc.dylib"));
+            RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(lib, "libdiscord-rpc.dylib")));
+        }
+    }
+}

examples/unrealstatus/Plugins/discordrpc/Source/ThirdParty/discordrpcLibrary/discordrpcLibrary.Build.cs

@@ -1,26 +0,0 @@
-// Fill out your copyright notice in the Description page of Project Settings.
-
-using System.IO;
-using UnrealBuildTool;
-
-public class discordrpcLibrary : ModuleRules
-{
-	public discordrpcLibrary(ReadOnlyTargetRules Target) : base(Target)
-	{
-		Type = ModuleType.External;
-
-		if (Target.Platform == UnrealTargetPlatform.Win64)
-		{
-			// Add the import library
-			PublicLibraryPaths.Add(Path.Combine(ModuleDirectory, "x64", "Release"));
-			PublicAdditionalLibraries.Add("discord-rpc.lib");
-
-			// Delay-load the DLL, so we can load it from the right place first
-			PublicDelayLoadDLLs.Add("discord-rpc.dll");
-		}
-        else if (Target.Platform == UnrealTargetPlatform.Mac)
-        {
-            PublicDelayLoadDLLs.Add(Path.Combine(ModuleDirectory, "Mac", "Release", "libdiscord-rpc.dylib"));
-        }
-	}
-}

examples/unrealstatus/Plugins/discordrpc/Source/discordrpc/Private/discordrpc.cpp

@@ -1,50 +0,0 @@
-// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
-
-#include "discordrpc.h"
-#include "Core.h"
-#include "ModuleManager.h"
-#include "IPluginManager.h"
-
-#define LOCTEXT_NAMESPACE "FdiscordrpcModule"
-
-void FdiscordrpcModule::StartupModule()
-{
-    // This code will execute after your module is loaded into memory; the exact timing is specified
-    // in the .uplugin file per-module
-
-    // Get the base directory of this plugin
-    FString BaseDir = IPluginManager::Get().FindPlugin("discordrpc")->GetBaseDir();
-
-    // Add on the relative location of the third party dll and load it
-    FString LibraryPath;
-#if PLATFORM_WINDOWS
-    LibraryPath = FPaths::Combine(
-      *BaseDir, TEXT("Binaries/ThirdParty/discordrpcLibrary/Win64/discord-rpc.dll"));
-#elif PLATFORM_MAC
-    LibraryPath = FPaths::Combine(
-      *BaseDir, TEXT("Source/ThirdParty/discordrpcLibrary/Mac/Release/libdiscord-rpc.dylib"));
-#endif // PLATFORM_WINDOWS
-
-    DiscordLibraryHandle =
-      !LibraryPath.IsEmpty() ? FPlatformProcess::GetDllHandle(*LibraryPath) : nullptr;
-
-    if (!DiscordLibraryHandle) {
-        FMessageDialog::Open(
-          EAppMsgType::Ok, LOCTEXT("ThirdPartyLibraryError", "Failed to load discord-rpc library"));
-    }
-}
-
-void FdiscordrpcModule::ShutdownModule()
-{
-    // This function may be called during shutdown to clean up your module.  For modules that
-    // support dynamic reloading,
-    // we call this function before unloading the module.
-
-    // Free the dll handle
-    FPlatformProcess::FreeDllHandle(DiscordLibraryHandle);
-    DiscordLibraryHandle = nullptr;
-}
-
-#undef LOCTEXT_NAMESPACE
-
-IMPLEMENT_MODULE(FdiscordrpcModule, discordrpc)

examples/unrealstatus/Plugins/discordrpc/Source/discordrpc/Public/discordrpc.h

@@ -1,16 +0,0 @@
-// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
-
-#pragma once
-
-#include "ModuleManager.h"
-
-class FdiscordrpcModule : public IModuleInterface {
-public:
-    /** IModuleInterface implementation */
-    virtual void StartupModule() override;
-    virtual void ShutdownModule() override;
-
-private:
-    /** Handle to the test dll we will load */
-    void* DiscordLibraryHandle;
-};

examples/unrealstatus/Plugins/discordrpc/Source/discordrpc/discordrpc.Build.cs

@@ -1,65 +0,0 @@
-// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
-
-using UnrealBuildTool;
-
-public class discordrpc : ModuleRules
-{
-	public discordrpc(ReadOnlyTargetRules Target) : base(Target)
-	{
-        Definitions.Add("DISCORD_DYNAMIC_LIB=1");
-        PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
-
-		PublicIncludePaths.AddRange(
-			new string[] {
-				"discordrpc/Public"
-				// ... add public include paths required here ...
-			}
-			);
-				
-		
-		PrivateIncludePaths.AddRange(
-			new string[] {
-				"discordrpc/Private",
-                "../../../../../include"
-				// ... add other private include paths required here ...
-			}
-			);
-
-        PublicLibraryPaths.AddRange(
-            new string[] {
-                System.IO.Path.Combine(ModuleDirectory, "../../Binaries/ThirdParty/discordrpcLibrary/", Target.Platform.ToString()),
-			}
-            );
-
-
-        PublicDependencyModuleNames.AddRange(
-			new string[]
-			{
-                "CoreUObject",
-                "Engine",
-                "Slate",
-                "SlateCore",
-                "Core",
-				"discordrpcLibrary",
-				"Projects"
-				// ... add other public dependencies that you statically link with here ...
-			}
-			);
-			
-		
-		PrivateDependencyModuleNames.AddRange(
-			new string[]
-			{
-				// ... add private dependencies that you statically link with here ...	
-			}
-			);
-		
-		
-		DynamicallyLoadedModuleNames.AddRange(
-			new string[]
-			{
-				// ... add any modules that your module loads dynamically here ...
-			}
-			);
-	}
-}

examples/unrealstatus/unrealstatus.uproject

@@ -1,6 +1,6 @@
 {
 	"FileVersion": 3,
-	"EngineAssociation": "4.16",
+	"EngineAssociation": "4.18",
 	"Category": "",
 	"Description": "",
 	"Modules": [

include/discord_register.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#if defined(DISCORD_DYNAMIC_LIB)
+#  if defined(_WIN32)
+#    if defined(DISCORD_BUILDING_SDK)
+#      define DISCORD_EXPORT __declspec(dllexport)
+#    else
+#      define DISCORD_EXPORT __declspec(dllimport)
+#    endif
+#  else
+#    define DISCORD_EXPORT __attribute__((visibility("default")))
+#  endif
+#else
+#  define DISCORD_EXPORT
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DISCORD_EXPORT void Discord_Register(const char* applicationId, const char* command);
+DISCORD_EXPORT void Discord_RegisterSteamGame(const char* applicationId, const char* steamId);
+
+#ifdef __cplusplus
+}
+#endif

include/discord_rpc.h

@@ -41,29 +41,44 @@ typedef struct DiscordRichPresence {
     int8_t instance;
 } DiscordRichPresence;
 
+typedef struct DiscordJoinRequest {
+    const char* userId;
+    const char* username;
+    const char* discriminator;
+    const char* avatar;
+} DiscordJoinRequest;
+
 typedef struct DiscordEventHandlers {
-    void (*ready)();
+    void (*ready)(void);
     void (*disconnected)(int errorCode, const char* message);
     void (*errored)(int errorCode, const char* message);
     void (*joinGame)(const char* joinSecret);
     void (*spectateGame)(const char* spectateSecret);
+    void (*joinRequest)(const DiscordJoinRequest* request);
 } DiscordEventHandlers;
 
+#define DISCORD_REPLY_NO 0
+#define DISCORD_REPLY_YES 1
+#define DISCORD_REPLY_IGNORE 2
+
 DISCORD_EXPORT void Discord_Initialize(const char* applicationId,
                                        DiscordEventHandlers* handlers,
                                        int autoRegister,
                                        const char* optionalSteamId);
-DISCORD_EXPORT void Discord_Shutdown();
+DISCORD_EXPORT void Discord_Shutdown(void);
 
 /* checks for incoming messages, dispatches callbacks */
-DISCORD_EXPORT void Discord_RunCallbacks();
+DISCORD_EXPORT void Discord_RunCallbacks(void);
 
 /* If you disable the lib starting its own io thread, you'll need to call this from your own */
 #ifdef DISCORD_DISABLE_IO_THREAD
-DISCORD_EXPORT void Discord_UpdateConnection();
+DISCORD_EXPORT void Discord_UpdateConnection(void);
 #endif
 
 DISCORD_EXPORT void Discord_UpdatePresence(const DiscordRichPresence* presence);
+DISCORD_EXPORT void Discord_ClearPresence(void);
+
+DISCORD_EXPORT void Discord_Respond(const char* userid, /* DISCORD_REPLY_ */ int reply);
 
 #ifdef __cplusplus
 } /* extern "C" */

src/CMakeLists.txt

@@ -1,51 +1,116 @@
 include_directories(${PROJECT_SOURCE_DIR}/include)
 
 option(ENABLE_IO_THREAD "Start up a separate I/O thread, otherwise I'd need to call an update function" ON)
-option(BUILD_DYNAMIC_LIB "Build library as a DLL" OFF)
+option(USE_STATIC_CRT "Use /MT[d] for dynamic library" OFF)
+
+set(CMAKE_CXX_STANDARD 14)
 
 set(BASE_RPC_SRC
-    ${PROJECT_SOURCE_DIR}/include/discord-rpc.h
-    discord-rpc.cpp
-    discord-register.h
-    discord-register.cpp
+    ${PROJECT_SOURCE_DIR}/include/discord_rpc.h
+    discord_rpc.cpp
+    ${PROJECT_SOURCE_DIR}/include/discord_register.h
     rpc_connection.h
     rpc_connection.cpp
     serialization.h
     serialization.cpp
     connection.h
     backoff.h
+    msg_queue.h
 )
 
-if (${BUILD_DYNAMIC_LIB})
-    set(RPC_LIBRARY_TYPE SHARED)
-    set(BASE_RPC_SRC ${BASE_RPC_SRC} dllmain.cpp)
-else(${BUILD_DYNAMIC_LIB})
-    set(RPC_LIBRARY_TYPE STATIC)
-endif(${BUILD_DYNAMIC_LIB})
+if (${BUILD_SHARED_LIBS})
+    if(WIN32)
+        set(BASE_RPC_SRC ${BASE_RPC_SRC} dllmain.cpp)
+    endif(WIN32)
+endif(${BUILD_SHARED_LIBS})
 
 if(WIN32)
-    add_library(discord-rpc ${RPC_LIBRARY_TYPE} ${BASE_RPC_SRC} connection_win.cpp)
-    target_compile_options(discord-rpc PRIVATE /W4)
+    add_definitions(-DDISCORD_WINDOWS)
+    set(BASE_RPC_SRC ${BASE_RPC_SRC} connection_win.cpp discord_register_win.cpp)
+    add_library(discord-rpc ${BASE_RPC_SRC})
+    if (MSVC)
+        if(USE_STATIC_CRT)
+            foreach(CompilerFlag
+                    CMAKE_CXX_FLAGS
+                    CMAKE_CXX_FLAGS_DEBUG
+                    CMAKE_CXX_FLAGS_RELEASE
+                    CMAKE_C_FLAGS
+                    CMAKE_C_FLAGS_DEBUG
+                    CMAKE_C_FLAGS_RELEASE)
+                string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
+            endforeach()
+        endif(USE_STATIC_CRT)
+        target_compile_options(discord-rpc PRIVATE /EHsc
+            /Wall
+            /wd4100 # unreferenced formal parameter
+            /wd4514 # unreferenced inline
+            /wd4625 # copy constructor deleted
+            /wd5026 # move constructor deleted
+            /wd4626 # move assignment operator deleted
+            /wd4668 # not defined preprocessor macro
+            /wd4710 # function not inlined
+            /wd4711 # function was inlined
+            /wd4820 # structure padding
+            /wd4946 # reinterpret_cast used between related classes
+            /wd5027 # move assignment operator was implicitly defined as deleted
+        )
+    endif(MSVC)
+    target_link_libraries(discord-rpc PRIVATE psapi)
 endif(WIN32)
 
 if(UNIX)
-    add_library(discord-rpc ${RPC_LIBRARY_TYPE} ${BASE_RPC_SRC} connection_unix.cpp)
+    set(BASE_RPC_SRC ${BASE_RPC_SRC} connection_unix.cpp)
+
+    if (APPLE)
+        add_definitions(-DDISCORD_OSX)
+        set(BASE_RPC_SRC ${BASE_RPC_SRC} discord_register_osx.m)
+    else (APPLE)
+        add_definitions(-DDISCORD_LINUX)
+        set(BASE_RPC_SRC ${BASE_RPC_SRC} discord_register_linux.cpp)
+    endif(APPLE)
+
+    add_library(discord-rpc ${BASE_RPC_SRC})
     target_link_libraries(discord-rpc PUBLIC pthread)
-    target_compile_options(discord-rpc PRIVATE -g -Wall -std=c++14)
+    target_compile_options(discord-rpc PRIVATE
+        -g
+        -Wall
+        -Wextra
+        -Wpedantic
+        -Werror
+        -Wno-unknown-pragmas # pragma push thing doesn't work on clang
+        -Wno-old-style-cast # it's fine
+        -Wno-c++98-compat # that was almost 2 decades ago
+        -Wno-c++98-compat-pedantic
+        -Wno-missing-noreturn
+        -Wno-padded # structure padding
+        -Wno-covered-switch-default
+        -Wno-exit-time-destructors # not sure about these
+        -Wno-global-constructors
+    )
+
+    if (${BUILD_SHARED_LIBS})
+        target_compile_options(discord-rpc PRIVATE -fPIC)
+    endif (${BUILD_SHARED_LIBS})
+
+    if (APPLE)
+        target_link_libraries(discord-rpc PRIVATE "-framework AppKit")
+    endif (APPLE)
 endif(UNIX)
 
 target_include_directories(discord-rpc PRIVATE ${RAPIDJSON}/include)
 
 if (NOT ${ENABLE_IO_THREAD})
-    add_definitions(discord-rpc PUBLIC -DDISCORD_DISABLE_IO_THREAD)
+    target_compile_definitions(discord-rpc PUBLIC -DDISCORD_DISABLE_IO_THREAD)
 endif (NOT ${ENABLE_IO_THREAD})
 
-if (${BUILD_DYNAMIC_LIB})
+if (${BUILD_SHARED_LIBS})
     target_compile_definitions(discord-rpc PUBLIC -DDISCORD_DYNAMIC_LIB)
     target_compile_definitions(discord-rpc PRIVATE -DDISCORD_BUILDING_SDK)
-endif(${BUILD_DYNAMIC_LIB})
+endif(${BUILD_SHARED_LIBS})
 
-add_dependencies(discord-rpc clangformat)
+if (CLANG_FORMAT_CMD)
+    add_dependencies(discord-rpc clangformat)
+endif(CLANG_FORMAT_CMD)
 
 # install
 
@@ -53,20 +118,18 @@ install(
     TARGETS discord-rpc
     EXPORT "discord-rpc"
     RUNTIME
-        DESTINATION "bin"
-        CONFIGURATIONS Release
+        DESTINATION "${CMAKE_INSTALL_BINDIR}"
     LIBRARY
-        DESTINATION "lib"
-        CONFIGURATIONS Release
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}"
     ARCHIVE
-        DESTINATION "lib"
-        CONFIGURATIONS Release
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}"
     INCLUDES
-        DESTINATION "include"
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
 )
 
 install(
     FILES
-        "../include/discord-rpc.h"
+        "../include/discord_rpc.h"
+		"../include/discord_register.h"
     DESTINATION "include"
 )

src/backoff.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <stdint.h>
 #include <algorithm>
 #include <random>
+#include <stdint.h>
 #include <time.h>
 
 struct Backoff {
@@ -20,7 +20,7 @@ struct Backoff {
       , maxAmount(max)
       , current(min)
       , fails(0)
-      , randGenerator(time(0))
+      , randGenerator((uint64_t)time(0))
     {
     }
 

src/connection_unix.cpp

@@ -111,7 +111,7 @@ bool BaseConnection::Read(void* data, size_t length)
         return false;
     }
 
-    int res = recv(self->sock, data, length, MsgFlags);
+    int res = (int)recv(self->sock, data, length, MsgFlags);
     if (res < 0) {
         if (errno == EAGAIN) {
             return false;

src/connection_win.cpp

@@ -4,12 +4,12 @@
 #define NOMCX
 #define NOSERVICE
 #define NOIME
-#include <windows.h>
 #include <assert.h>
+#include <windows.h>
 
 int GetProcessId()
 {
-    return ::GetCurrentProcessId();
+    return (int)::GetCurrentProcessId();
 }
 
 struct BaseConnectionWin : public BaseConnection {

src/discord-register.h

@@ -1,4 +0,0 @@
-#pragma once
-
-void Discord_Register(const char* applicationId, const char* command);
-void Discord_RegisterSteamGame(const char* applicationId, const char* steamId);

src/discord_register_linux.cpp

@@ -0,0 +1,99 @@
+#include "discord_rpc.h"
+#include "discord_register.h"
+#include <stdio.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+static bool Mkdir(const char* path)
+{
+    int result = mkdir(path, 0755);
+    if (result == 0) {
+        return true;
+    }
+    if (errno == EEXIST) {
+        return true;
+    }
+    return false;
+}
+
+// we want to register games so we can run them from Discord client as discord-<appid>://
+extern "C" DISCORD_EXPORT void Discord_Register(const char* applicationId, const char* command)
+{
+    // Add a desktop file and update some mime handlers so that xdg-open does the right thing.
+
+    const char* home = getenv("HOME");
+    if (!home) {
+        return;
+    }
+
+    char exePath[1024];
+    if (!command || !command[0]) {
+        if (readlink("/proc/self/exe", exePath, sizeof(exePath)) <= 0) {
+            return;
+        }
+        command = exePath;
+    }
+
+    const char* destopFileFormat = "[Desktop Entry]\n"
+                                   "Name=Game %s\n"
+                                   "Exec=%s %%u\n" // note: it really wants that %u in there
+                                   "Type=Application\n"
+                                   "NoDisplay=true\n"
+                                   "Categories=Discord;Games;\n"
+                                   "MimeType=x-scheme-handler/discord-%s;\n";
+    char desktopFile[2048];
+    int fileLen = snprintf(
+      desktopFile, sizeof(desktopFile), destopFileFormat, applicationId, command, applicationId);
+    if (fileLen <= 0) {
+        return;
+    }
+
+    char desktopFilename[256];
+    snprintf(desktopFilename, sizeof(desktopFilename), "/discord-%s.desktop", applicationId);
+
+    char desktopFilePath[1024];
+    snprintf(desktopFilePath, sizeof(desktopFilePath), "%s/.local", home);
+    if (!Mkdir(desktopFilePath)) {
+        return;
+    }
+    strcat(desktopFilePath, "/share");
+    if (!Mkdir(desktopFilePath)) {
+        return;
+    }
+    strcat(desktopFilePath, "/applications");
+    if (!Mkdir(desktopFilePath)) {
+        return;
+    }
+    strcat(desktopFilePath, desktopFilename);
+
+    FILE* fp = fopen(desktopFilePath, "w");
+    if (fp) {
+        fwrite(desktopFile, 1, fileLen, fp);
+        fclose(fp);
+    }
+    else {
+        return;
+    }
+
+    char xdgMimeCommand[1024];
+    snprintf(xdgMimeCommand,
+             sizeof(xdgMimeCommand),
+             "xdg-mime default discord-%s.desktop x-scheme-handler/discord-%s",
+             applicationId,
+             applicationId);
+    if (system(xdgMimeCommand) < 0) {
+        fprintf(stderr, "Failed to register mime handler\n");
+    }
+}
+
+extern "C" DISCORD_EXPORT void Discord_RegisterSteamGame(const char* applicationId, const char* steamId)
+{
+    char command[256];
+    sprintf(command, "xdg-open steam://rungameid/%s", steamId);
+    Discord_Register(applicationId, command);
+}

src/discord_register_osx.m

@@ -0,0 +1,80 @@
+#include <stdio.h>
+#include <sys/stat.h>
+
+#import <AppKit/AppKit.h>
+
+#include "discord_register.h"
+
+static void RegisterCommand(const char* applicationId, const char* command)
+{
+    // There does not appear to be a way to register arbitrary commands on OSX, so instead we'll save the command
+    // to a file in the Discord config path, and when it is needed, Discord can try to load the file there, open
+    // the command therein (will pass to js's window.open, so requires a url-like thing)
+
+    // Note: will not work for sandboxed apps
+  	NSString *home = NSHomeDirectory();
+    if (!home) {
+        return;
+    }
+
+    NSString *path = [[[[[[home stringByAppendingPathComponent:@"Library"]
+                                stringByAppendingPathComponent:@"Application Support"]
+                                stringByAppendingPathComponent:@"discord"]
+                                stringByAppendingPathComponent:@"games"]
+                                stringByAppendingPathComponent:[NSString stringWithUTF8String:applicationId]]
+                                stringByAppendingPathExtension:@"json"];
+    [[NSFileManager defaultManager] createDirectoryAtPath:[path stringByDeletingLastPathComponent] withIntermediateDirectories:YES attributes:nil error:nil];
+
+    NSString *jsonBuffer = [NSString stringWithFormat:@"{\"command\": \"%s\"}", command];
+    [jsonBuffer writeToFile:path atomically:NO encoding:NSUTF8StringEncoding error:nil];
+}
+
+static void RegisterURL(const char* applicationId)
+{
+    char url[256];
+    snprintf(url, sizeof(url), "discord-%s", applicationId);
+    CFStringRef cfURL = CFStringCreateWithCString(NULL, url, kCFStringEncodingUTF8);
+
+    NSString* myBundleId = [[NSBundle mainBundle] bundleIdentifier];
+    if (!myBundleId) {
+        fprintf(stderr, "No bundle id found\n");
+        return;
+    }
+
+    NSURL* myURL = [[NSBundle mainBundle] bundleURL];
+    if (!myURL) {
+        fprintf(stderr, "No bundle url found\n");
+        return;
+    }
+
+    OSStatus status = LSSetDefaultHandlerForURLScheme(cfURL, (__bridge CFStringRef)myBundleId);
+    if (status != noErr) {
+        fprintf(stderr, "Error in LSSetDefaultHandlerForURLScheme: %d\n", (int)status);
+        return;
+    }
+
+    status = LSRegisterURL((__bridge CFURLRef)myURL, true);
+    if (status != noErr) {
+        fprintf(stderr, "Error in LSRegisterURL: %d\n", (int)status);
+    }
+}
+
+void Discord_Register(const char* applicationId, const char* command)
+{
+    if (command) {
+        RegisterCommand(applicationId, command);
+    }
+    else {
+        // raii lite
+        @autoreleasepool {
+            RegisterURL(applicationId);
+        }
+    }
+}
+
+void Discord_RegisterSteamGame(const char* applicationId, const char* steamId)
+{
+    char command[256];
+    snprintf(command, 256, "steam://rungameid/%s", steamId);
+    Discord_Register(applicationId, command);
+}

src/discord_register_win.cpp

@@ -1,34 +1,79 @@
-#include "discord-rpc.h"
-#include <stdio.h>
+#include "discord_rpc.h"
+#include "discord_register.h"
 
-#ifdef _WIN32
 #define WIN32_LEAN_AND_MEAN
 #define NOMCX
 #define NOSERVICE
 #define NOIME
 #include <windows.h>
-#include <Psapi.h>
-#include <Strsafe.h>
-#pragma comment(lib, "Psapi.lib")
-#endif
+#include <psapi.h>
+#include <cwchar>
+#include <cstdio>
 
-#ifdef _WIN32
-void Discord_RegisterW(const wchar_t* applicationId, const wchar_t* command)
+/**
+ * Updated fixes for MinGW and WinXP
+ * This block is written the way it does not involve changing the rest of the code
+ * Checked to be compiling
+ * 1) strsafe.h belongs to Windows SDK and cannot be added to MinGW
+ * #include guarded, functions redirected to <string.h> substitutes
+ * 2) RegSetKeyValueW and LSTATUS are not declared in <winreg.h>
+ * The entire function is rewritten
+ */
+#ifdef __MINGW32__
+/// strsafe.h fixes
+static HRESULT StringCbPrintfW(LPWSTR pszDest, size_t cbDest, LPCWSTR pszFormat, ...)
+{
+    HRESULT ret;
+    va_list va;
+    va_start(va, pszFormat);
+    cbDest /= 2; // Size is divided by 2 to convert from bytes to wide characters - causes segfault othervise
+    ret = vsnwprintf(pszDest, cbDest, pszFormat, va);
+    pszDest[cbDest - 1] = 0; // Terminate the string in case a buffer overflow; -1 will be returned
+    va_end(va);
+    return ret;
+}
+#else
+#include <strsafe.h>
+#endif // __MINGW32__
+
+/// winreg.h fixes
+#ifndef LSTATUS
+#define LSTATUS LONG
+#endif
+#ifdef RegSetKeyValueW
+#undefine RegSetKeyValueW
+#endif
+#define RegSetKeyValueW regset
+static LSTATUS regset(HKEY hkey, LPCWSTR subkey, LPCWSTR name, DWORD type, const void *data, DWORD len)
+{
+    HKEY htkey = hkey, hsubkey = nullptr;
+    LSTATUS ret;
+    if (subkey && subkey[0])
+    {
+        if((ret = RegCreateKeyExW(hkey, subkey, 0, 0, 0, KEY_ALL_ACCESS, 0, &hsubkey, 0)) != ERROR_SUCCESS) return ret;
+        htkey = hsubkey;
+    }
+    ret = RegSetValueExW(htkey, name, 0, type, (const BYTE*)data, len);
+    if (hsubkey && hsubkey != hkey) RegCloseKey(hsubkey);
+    return ret;
+}
+
+static void Discord_RegisterW(const wchar_t* applicationId, const wchar_t* command)
 {
     // https://msdn.microsoft.com/en-us/library/aa767914(v=vs.85).aspx
     // we want to register games so we can run them as discord-<appid>://
     // Update the HKEY_CURRENT_USER, because it doesn't seem to require special permissions.
 
     wchar_t exeFilePath[MAX_PATH];
-    int exeLen = GetModuleFileNameExW(GetCurrentProcess(), nullptr, exeFilePath, MAX_PATH);
+    DWORD exeLen = GetModuleFileNameW(nullptr, exeFilePath, MAX_PATH);
     wchar_t openCommand[1024];
-    const auto commandBufferLen = sizeof(openCommand) / sizeof(*openCommand);
 
     if (command && command[0]) {
         StringCbPrintfW(openCommand, sizeof(openCommand), L"%s", command);
     }
     else {
-        lstrcpyW(openCommand, exeFilePath);
+        //StringCbCopyW(openCommand, sizeof(openCommand), exeFilePath);
+        StringCbPrintfW(openCommand, sizeof(openCommand), L"%s", exeFilePath);
     }
 
     wchar_t protocolName[64];
@@ -49,14 +94,14 @@ void Discord_RegisterW(const wchar_t* applicationId, const wchar_t* command)
     }
     DWORD len;
     LSTATUS result;
-    len = lstrlenW(protocolDescription) + 1;
+    len = (DWORD)lstrlenW(protocolDescription) + 1;
     result =
       RegSetKeyValueW(key, nullptr, nullptr, REG_SZ, protocolDescription, len * sizeof(wchar_t));
     if (FAILED(result)) {
         fprintf(stderr, "Error writing description\n");
     }
 
-    len = lstrlenW(protocolDescription) + 1;
+    len = (DWORD)lstrlenW(protocolDescription) + 1;
     result = RegSetKeyValueW(key, nullptr, L"URL Protocol", REG_SZ, &urlProtocol, sizeof(wchar_t));
     if (FAILED(result)) {
         fprintf(stderr, "Error writing description\n");
@@ -68,7 +113,7 @@ void Discord_RegisterW(const wchar_t* applicationId, const wchar_t* command)
         fprintf(stderr, "Error writing icon\n");
     }
 
-    len = lstrlenW(openCommand) + 1;
+    len = (DWORD)lstrlenW(openCommand) + 1;
     result = RegSetKeyValueW(
       key, L"shell\\open\\command", nullptr, REG_SZ, openCommand, len * sizeof(wchar_t));
     if (FAILED(result)) {
@@ -76,12 +121,9 @@ void Discord_RegisterW(const wchar_t* applicationId, const wchar_t* command)
     }
     RegCloseKey(key);
 }
-#endif
 
-void Discord_Register(const char* applicationId, const char* command)
+extern "C" DISCORD_EXPORT void Discord_Register(const char* applicationId, const char* command)
 {
-#ifdef _WIN32
-
     wchar_t appId[32];
     MultiByteToWideChar(CP_UTF8, 0, applicationId, -1, appId, 32);
 
@@ -94,12 +136,10 @@ void Discord_Register(const char* applicationId, const char* command)
     }
 
     Discord_RegisterW(appId, wcommand);
-#endif
 }
 
-void Discord_RegisterSteamGame(const char* applicationId, const char* steamId)
+extern "C" DISCORD_EXPORT void Discord_RegisterSteamGame(const char* applicationId, const char* steamId)
 {
-#ifdef _WIN32
     wchar_t appId[32];
     MultiByteToWideChar(CP_UTF8, 0, applicationId, -1, appId, 32);
 
@@ -130,8 +170,7 @@ void Discord_RegisterSteamGame(const char* applicationId, const char* steamId)
     }
 
     wchar_t command[1024];
-    StringCbPrintfW(command, sizeof(command), L"\"%s\" steam://run/%s", steamPath, wSteamId);
+    StringCbPrintfW(command, sizeof(command), L"\"%s\" steam://rungameid/%s", steamPath, wSteamId);
 
     Discord_RegisterW(appId, command);
-#endif
 }

src/discord_rpc.cpp

@@ -1,7 +1,8 @@
-#include "discord-rpc.h"
+#include "discord_rpc.h"
 
 #include "backoff.h"
-#include "discord-register.h"
+#include "discord_register.h"
+#include "msg_queue.h"
 #include "rpc_connection.h"
 #include "serialization.h"
 
@@ -16,6 +17,7 @@
 
 constexpr size_t MaxMessageSize{16 * 1024};
 constexpr size_t MessageQueueSize{8};
+constexpr size_t JoinQueueSize{8};
 
 struct QueuedMessage {
     size_t length;
@@ -30,6 +32,20 @@ struct QueuedMessage {
     }
 };
 
+struct JoinRequest {
+    // snowflake (64bit int), turned into a ascii decimal string, at most 20 chars +1 null
+    // terminator = 21
+    char userId[32];
+    // 32 unicode glyphs is max name size => 4 bytes per glyph in the worst case, +1 for null
+    // terminator = 129
+    char username[344];
+    // 4 decimal digits + 1 null terminator = 5
+    char discriminator[8];
+    // optional 'a_' + md5 hex digest (32 bytes) + null terminator = 35
+    char avatar[128];
+    // Rounded way up because I'm paranoid about games breaking from future changes in these sizes
+};
+
 static RpcConnection* Connection{nullptr};
 static DiscordEventHandlers Handlers{};
 static std::atomic_bool WasJustConnected{false};
@@ -45,23 +61,61 @@ static int LastDisconnectErrorCode{0};
 static char LastDisconnectErrorMessage[256];
 static std::mutex PresenceMutex;
 static QueuedMessage QueuedPresence{};
-static QueuedMessage SendQueue[MessageQueueSize]{};
-static std::atomic_uint SendQueueNextAdd{0};
-static std::atomic_uint SendQueueNextSend{0};
-static std::atomic_uint SendQueuePendingSends{0};
+static MsgQueue<QueuedMessage, MessageQueueSize> SendQueue;
+static MsgQueue<JoinRequest, JoinQueueSize> JoinAskQueue;
+
 // We want to auto connect, and retry on failure, but not as fast as possible. This does expoential
 // backoff from 0.5 seconds to 1 minute
 static Backoff ReconnectTimeMs(500, 60 * 1000);
-static auto NextConnect{std::chrono::system_clock::now()};
+static auto NextConnect = std::chrono::system_clock::now();
 static int Pid{0};
 static int Nonce{1};
 
 #ifndef DISCORD_DISABLE_IO_THREAD
-static std::atomic_bool KeepRunning{true};
-static std::mutex WaitForIOMutex;
-static std::condition_variable WaitForIOActivity;
-static std::thread IoThread;
+static void Discord_UpdateConnection(void);
+class IoThreadHolder {
+private:
+    std::atomic_bool keepRunning{true};
+    std::mutex waitForIOMutex;
+    std::condition_variable waitForIOActivity;
+    std::thread ioThread;
+
+public:
+    void Start()
+    {
+        keepRunning.store(true);
+        ioThread = std::thread([&]() {
+            const std::chrono::duration<int64_t, std::milli> maxWait{500LL};
+            while (keepRunning.load()) {
+                Discord_UpdateConnection();
+                std::unique_lock<std::mutex> lock(waitForIOMutex);
+                waitForIOActivity.wait_for(lock, maxWait);
+            }
+        });
+    }
+
+    void Notify() { waitForIOActivity.notify_all(); }
+
+    void Stop()
+    {
+        keepRunning.exchange(false);
+        Notify();
+        if (ioThread.joinable()) {
+            ioThread.join();
+        }
+    }
+
+    ~IoThreadHolder() { Stop(); }
+};
+#else
+class IoThreadHolder {
+public:
+    void Start() {}
+    void Stop() {}
+    void Notify() {}
+};
 #endif // DISCORD_DISABLE_IO_THREAD
+static IoThreadHolder IoThread;
 
 static void UpdateReconnectTime()
 {
@@ -69,31 +123,11 @@ static void UpdateReconnectTime()
       std::chrono::duration<int64_t, std::milli>{ReconnectTimeMs.nextDelay()};
 }
 
-static QueuedMessage* SendQueueGetNextAddMessage()
-{
-    // if we are not connected, let's not batch up stale messages for later
-    if (!Connection || !Connection->IsOpen()) {
-        return nullptr;
-    }
-
-    // if we are falling behind, bail
-    if (SendQueuePendingSends.load() >= MessageQueueSize) {
-        return nullptr;
-    }
-    auto index = (SendQueueNextAdd++) % MessageQueueSize;
-    return &SendQueue[index];
-}
-static QueuedMessage* SendQueueGetNextSendMessage()
-{
-    auto index = (SendQueueNextSend++) % MessageQueueSize;
-    return &SendQueue[index];
-}
-static void SendQueueCommitMessage()
-{
-    SendQueuePendingSends++;
-}
-
-extern "C" void Discord_UpdateConnection()
+#ifdef DISCORD_DISABLE_IO_THREAD
+extern "C" DISCORD_EXPORT void Discord_UpdateConnection(void)
+#else
+static void Discord_UpdateConnection(void)
+#endif
 {
     if (!Connection) {
         return;
@@ -134,22 +168,44 @@ extern "C" void Discord_UpdateConnection()
                     continue;
                 }
 
-                if (strcmp(evtName, "GAME_JOIN") == 0) {
-                    auto data = GetObjMember(&message, "data");
+                auto data = GetObjMember(&message, "data");
+
+                if (strcmp(evtName, "ACTIVITY_JOIN") == 0) {
                     auto secret = GetStrMember(data, "secret");
                     if (secret) {
                         StringCopy(JoinGameSecret, secret);
                         WasJoinGame.store(true);
                     }
                 }
-                else if (strcmp(evtName, "GAME_SPECTATE") == 0) {
-                    auto data = GetObjMember(&message, "data");
+                else if (strcmp(evtName, "ACTIVITY_SPECTATE") == 0) {
                     auto secret = GetStrMember(data, "secret");
                     if (secret) {
                         StringCopy(SpectateGameSecret, secret);
                         WasSpectateGame.store(true);
                     }
                 }
+                else if (strcmp(evtName, "ACTIVITY_JOIN_REQUEST") == 0) {
+                    auto user = GetObjMember(data, "user");
+                    auto userId = GetStrMember(user, "id");
+                    auto username = GetStrMember(user, "username");
+                    auto avatar = GetStrMember(user, "avatar");
+                    auto joinReq = JoinAskQueue.GetNextAddMessage();
+                    if (userId && username && joinReq) {
+                        StringCopy(joinReq->userId, userId);
+                        StringCopy(joinReq->username, username);
+                        auto discriminator = GetStrMember(user, "discriminator");
+                        if (discriminator) {
+                            StringCopy(joinReq->discriminator, discriminator);
+                        }
+                        if (avatar) {
+                            StringCopy(joinReq->avatar, avatar);
+                        }
+                        else {
+                            joinReq->avatar[0] = 0;
+                        }
+                        JoinAskQueue.CommitAdd();
+                    }
+                }
             }
         }
 
@@ -168,52 +224,36 @@ extern "C" void Discord_UpdateConnection()
             }
         }
 
-        while (SendQueuePendingSends.load()) {
-            auto qmessage = SendQueueGetNextSendMessage();
+        while (SendQueue.HavePendingSends()) {
+            auto qmessage = SendQueue.GetNextSendMessage();
             Connection->Write(qmessage->buffer, qmessage->length);
-            --SendQueuePendingSends;
+            SendQueue.CommitSend();
         }
     }
 }
 
-#ifndef DISCORD_DISABLE_IO_THREAD
-void DiscordRpcIo()
+static void SignalIOActivity()
 {
-    const std::chrono::duration<int64_t, std::milli> maxWait{500LL};
-
-    while (KeepRunning.load()) {
-        Discord_UpdateConnection();
-
-        std::unique_lock<std::mutex> lock(WaitForIOMutex);
-        WaitForIOActivity.wait_for(lock, maxWait);
-    }
-}
-#endif
-
-void SignalIOActivity()
-{
-#ifndef DISCORD_DISABLE_IO_THREAD
-    WaitForIOActivity.notify_all();
-#endif
+    IoThread.Notify();
 }
 
-bool RegisterForEvent(const char* evtName)
+static bool RegisterForEvent(const char* evtName)
 {
-    auto qmessage = SendQueueGetNextAddMessage();
+    auto qmessage = SendQueue.GetNextAddMessage();
     if (qmessage) {
         qmessage->length =
           JsonWriteSubscribeCommand(qmessage->buffer, sizeof(qmessage->buffer), Nonce++, evtName);
-        SendQueueCommitMessage();
+        SendQueue.CommitAdd();
         SignalIOActivity();
         return true;
     }
     return false;
 }
 
-extern "C" void Discord_Initialize(const char* applicationId,
-                                   DiscordEventHandlers* handlers,
-                                   int autoRegister,
-                                   const char* optionalSteamId)
+extern "C" DISCORD_EXPORT void Discord_Initialize(const char* applicationId,
+                                                  DiscordEventHandlers* handlers,
+                                                  int autoRegister,
+                                                  const char* optionalSteamId)
 {
     if (autoRegister) {
         if (optionalSteamId && optionalSteamId[0]) {
@@ -243,11 +283,15 @@ extern "C" void Discord_Initialize(const char* applicationId,
         ReconnectTimeMs.reset();
 
         if (Handlers.joinGame) {
-            RegisterForEvent("GAME_JOIN");
+            RegisterForEvent("ACTIVITY_JOIN");
         }
 
         if (Handlers.spectateGame) {
-            RegisterForEvent("GAME_SPECTATE");
+            RegisterForEvent("ACTIVITY_SPECTATE");
+        }
+
+        if (Handlers.joinRequest) {
+            RegisterForEvent("ACTIVITY_JOIN_REQUEST");
         }
     };
     Connection->onDisconnect = [](int err, const char* message) {
@@ -257,13 +301,10 @@ extern "C" void Discord_Initialize(const char* applicationId,
         UpdateReconnectTime();
     };
 
-#ifndef DISCORD_DISABLE_IO_THREAD
-    KeepRunning.store(true);
-    IoThread = std::thread(DiscordRpcIo);
-#endif
+    IoThread.Start();
 }
 
-extern "C" void Discord_Shutdown()
+extern "C" DISCORD_EXPORT void Discord_Shutdown(void)
 {
     if (!Connection) {
         return;
@@ -271,17 +312,11 @@ extern "C" void Discord_Shutdown()
     Connection->onConnect = nullptr;
     Connection->onDisconnect = nullptr;
     Handlers = {};
-#ifndef DISCORD_DISABLE_IO_THREAD
-    KeepRunning.exchange(false);
-    SignalIOActivity();
-    if (IoThread.joinable()) {
-        IoThread.join();
-    }
-#endif
+    IoThread.Stop();
     RpcConnection::Destroy(Connection);
 }
 
-extern "C" void Discord_UpdatePresence(const DiscordRichPresence* presence)
+extern "C" DISCORD_EXPORT void Discord_UpdatePresence(const DiscordRichPresence* presence)
 {
     PresenceMutex.lock();
     QueuedPresence.length = JsonWriteRichPresenceObj(
@@ -290,7 +325,27 @@ extern "C" void Discord_UpdatePresence(const DiscordRichPresence* presence)
     SignalIOActivity();
 }
 
-extern "C" void Discord_RunCallbacks()
+extern "C" DISCORD_EXPORT void Discord_ClearPresence(void)
+{
+    Discord_UpdatePresence(nullptr);
+}
+
+extern "C" DISCORD_EXPORT void Discord_Respond(const char* userId, /* DISCORD_REPLY_ */ int reply)
+{
+    // if we are not connected, let's not batch up stale messages for later
+    if (!Connection || !Connection->IsOpen()) {
+        return;
+    }
+    auto qmessage = SendQueue.GetNextAddMessage();
+    if (qmessage) {
+        qmessage->length =
+          JsonWriteJoinReply(qmessage->buffer, sizeof(qmessage->buffer), userId, reply, Nonce++);
+        SendQueue.CommitAdd();
+        SignalIOActivity();
+    }
+}
+
+extern "C" DISCORD_EXPORT void Discord_RunCallbacks(void)
 {
     // Note on some weirdness: internally we might connect, get other signals, disconnect any number
     // of times inbetween calls here. Externally, we want the sequence to seem sane, so any other
@@ -326,6 +381,20 @@ extern "C" void Discord_RunCallbacks()
         Handlers.spectateGame(SpectateGameSecret);
     }
 
+    // Right now this batches up any requests and sends them all in a burst; I could imagine a world
+    // where the implementer would rather sequentially accept/reject each one before the next invite
+    // is sent. I left it this way because I could also imagine wanting to process these all and
+    // maybe show them in one common dialog and/or start fetching the avatars in parallel, and if
+    // not it should be trivial for the implementer to make a queue themselves.
+    while (JoinAskQueue.HavePendingSends()) {
+        auto req = JoinAskQueue.GetNextSendMessage();
+        if (Handlers.joinRequest) {
+            DiscordJoinRequest djr{req->userId, req->username, req->discriminator, req->avatar};
+            Handlers.joinRequest(&djr);
+        }
+        JoinAskQueue.CommitSend();
+    }
+
     if (!isConnected) {
         // if we are not connected, disconnect message last
         if (wasDisconnected && Handlers.disconnected) {

src/dllmain.cpp

@@ -1,5 +1,7 @@
 #include <windows.h>
 
+// outsmart GCC's missing-declarations warning
+BOOL WINAPI DllMain(HMODULE, DWORD, LPVOID);
 BOOL WINAPI DllMain(HMODULE, DWORD, LPVOID)
 {
     return TRUE;

src/msg_queue.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <atomic>
+
+// A simple queue. No locks, but only works with a single thread as producer and a single thread as
+// a consumer. Mutex up as needed.
+
+template <typename ElementType, size_t QueueSize>
+class MsgQueue {
+    ElementType queue_[QueueSize]{};
+    std::atomic_uint nextAdd_{0};
+    std::atomic_uint nextSend_{0};
+    std::atomic_uint pendingSends_{0};
+
+public:
+    MsgQueue() {}
+
+    ElementType* GetNextAddMessage()
+    {
+        // if we are falling behind, bail
+        if (pendingSends_.load() >= QueueSize) {
+            return nullptr;
+        }
+        auto index = (nextAdd_++) % QueueSize;
+        return &queue_[index];
+    }
+    void CommitAdd() { ++pendingSends_; }
+
+    bool HavePendingSends() const { return pendingSends_.load() != 0; }
+    ElementType* GetNextSendMessage()
+    {
+        auto index = (nextSend_++) % QueueSize;
+        return &queue_[index];
+    }
+    void CommitSend() { --pendingSends_; }
+};

src/rpc_connection.cpp

@@ -129,6 +129,7 @@ bool RpcConnection::Read(JsonDocument& message)
             break;
         case Opcode::Pong:
             break;
+        case Opcode::Handshake:
         default:
             // something bad happened
             lastErrorCode = (int)ErrorCode::ReadCorrupt;

src/serialization.cpp

@@ -1,6 +1,6 @@
 #include "serialization.h"
 #include "connection.h"
-#include "discord-rpc.h"
+#include "discord_rpc.h"
 
 template <typename T>
 void NumberToString(char* dest, T number)
@@ -72,7 +72,7 @@ void WriteOptionalString(JsonWriter& w, T& k, const char* value)
     }
 }
 
-void JsonWriteNonce(JsonWriter& writer, int nonce)
+static void JsonWriteNonce(JsonWriter& writer, int nonce)
 {
     WriteKey(writer, "nonce");
     char nonceBuffer[32];
@@ -102,6 +102,7 @@ size_t JsonWriteRichPresenceObj(char* dest,
             WriteKey(writer, "pid");
             writer.Int(pid);
 
+            if (presence != nullptr)
             {
                 WriteObject activity(writer, "activity");
 
@@ -137,12 +138,10 @@ size_t JsonWriteRichPresenceObj(char* dest,
                     presence->partyMax) {
                     WriteObject party(writer, "party");
                     WriteOptionalString(writer, "id", presence->partyId);
-                    if (presence->partySize) {
+                    if (presence->partySize && presence->partyMax) {
                         WriteArray size(writer, "size");
                         writer.Int(presence->partySize);
-                        if (0 < presence->partyMax) {
-                            writer.Int(presence->partyMax);
-                        }
+                        writer.Int(presence->partyMax);
                     }
                 }
 
@@ -197,3 +196,32 @@ size_t JsonWriteSubscribeCommand(char* dest, size_t maxLen, int nonce, const cha
 
     return writer.Size();
 }
+
+size_t JsonWriteJoinReply(char* dest, size_t maxLen, const char* userId, int reply, int nonce)
+{
+    JsonWriter writer(dest, maxLen);
+
+    {
+        WriteObject obj(writer);
+
+        WriteKey(writer, "cmd");
+        if (reply == DISCORD_REPLY_YES) {
+            writer.String("SEND_ACTIVITY_JOIN_INVITE");
+        }
+        else {
+            writer.String("CLOSE_ACTIVITY_JOIN_REQUEST");
+        }
+
+        WriteKey(writer, "args");
+        {
+            WriteObject args(writer);
+
+            WriteKey(writer, "user_id");
+            writer.String(userId);
+        }
+
+        JsonWriteNonce(writer, nonce);
+    }
+
+    return writer.Size();
+}

src/serialization.h

@@ -2,9 +2,23 @@
 
 #include <stdint.h>
 
+#ifndef __MINGW32__
+#pragma warning(push)
+
+#pragma warning(disable : 4061) // enum is not explicitly handled by a case label
+#pragma warning(disable : 4365) // signed/unsigned mismatch
+#pragma warning(disable : 4464) // relative include path contains
+#pragma warning(disable : 4668) // is not defined as a preprocessor macro
+#pragma warning(disable : 6313) // Incorrect operator
+#endif // __MINGW32__
+
 #include "rapidjson/document.h"
-#include "rapidjson/writer.h"
 #include "rapidjson/stringbuffer.h"
+#include "rapidjson/writer.h"
+
+#ifndef __MINGW32__
+#pragma warning(pop)
+#endif // __MINGW32__
 
 // if only there was a standard library function for this
 template <size_t Len>
@@ -33,6 +47,8 @@ size_t JsonWriteRichPresenceObj(char* dest,
                                 const DiscordRichPresence* presence);
 size_t JsonWriteSubscribeCommand(char* dest, size_t maxLen, int nonce, const char* evtName);
 
+size_t JsonWriteJoinReply(char* dest, size_t maxLen, const char* userId, int reply, int nonce);
+
 // I want to use as few allocations as I can get away with, and to do that with RapidJson, you need
 // to supply some of your own allocators for stuff rather than use the defaults
 
@@ -67,6 +83,9 @@ public:
         }
         // allocate how much you need in the first place
         assert(!originalPtr && !originalSize);
+        // unused parameter warning
+        (void)(originalPtr);
+        (void)(originalSize);
         return Malloc(newSize);
     }
     static void Free(void* ptr)
@@ -109,7 +128,7 @@ public:
         }
     }
     void Flush() {}
-    size_t GetSize() const { return current_ - buffer_; }
+    size_t GetSize() const { return (size_t)(current_ - buffer_); }
 };
 
 using MallocAllocator = rapidjson::CrtAllocator;