Also only build release in for_unity build

As per
https://msdn.microsoft.com/en-us/library/windows/desktop/ms683198(v=vs.85).aspx,
the advised use for getting the file name of a module from `<current
process>` is to use the simplified version. Additionally, this clears
the confusion introduced in Win7's PSAPI which moved
`GetModuleFileNameExW` into the kernel, changing its signature to
`K32GetModuleFileNameExW`, effectively breaking pre-Win7 uses unless
actively mitigated with `#define PSAPI_VERSION 1`

.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
 ...

.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)!
 
-## 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,50 @@ 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.
+
+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.
 
 ## 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.
+
+## 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 |
+|------|----------|
+| Be the first! | |

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,185 @@ 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()
+def unity():
+    """ todo: build unity project """
+    pass
+
+
+@cli.command()
+@click.pass_context
+def for_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
+    )
+
+
+@cli.command()
+def unreal():
+    """ todo: build unreal project """
+    pass
+
+
+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"
+  "evnt": "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"
+  "evnt": "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"
+  },
+  "evnt": "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/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 for_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/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/DiscordController.cs

@@ -1,8 +1,16 @@
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
-public class DiscordController : MonoBehaviour {
+[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;
     public string applicationId;
     public string optionalSteamId;
@@ -10,6 +18,9 @@ public class DiscordController : MonoBehaviour {
     public int clickCounter;
     public UnityEngine.Events.UnityEvent onConnect;
     public UnityEngine.Events.UnityEvent onDisconnect;
+    public DiscordJoinEvent onJoin;
+    public DiscordJoinEvent onSpectate;
+    public DiscordJoinRequestEvent onJoinRequest;
 
     DiscordRpc.EventHandlers handlers;
 
@@ -47,18 +58,29 @@ 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));
+        onJoinRequest.Invoke(request);
     }
 
-	void Update () {
+    void Start()
+    {
+    }
+
+    void Update()
+    {
         DiscordRpc.RunCallbacks();
     }
 
@@ -73,6 +95,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

@@ -2,21 +2,24 @@
 
 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,6 +27,7 @@ public class DiscordRpc
         public ErrorCallback errorCallback;
         public JoinCallback joinCallback;
         public SpectateCallback spectateCallback;
+        public RequestCallback requestCallback;
     }
 
     [System.Serializable]
@@ -46,16 +50,35 @@ public class DiscordRpc
         public bool instance;
     }
 
-    [DllImport("discord-rpc", EntryPoint = "Discord_Initialize")]
+    [System.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")]
+    [DllImport("discord-rpc", EntryPoint = "Discord_Shutdown", CallingConvention = CallingConvention.Cdecl)]
     public static extern void Shutdown();
 
-    [DllImport("discord-rpc", EntryPoint = "Discord_RunCallbacks")]
+    [DllImport("discord-rpc", EntryPoint = "Discord_RunCallbacks", CallingConvention = CallingConvention.Cdecl)]
     public static extern void RunCallbacks();
 
-    [DllImport("discord-rpc", EntryPoint = "Discord_UpdatePresence")]
+    [DllImport("discord-rpc", EntryPoint = "Discord_UpdatePresence", CallingConvention = CallingConvention.Cdecl)]
     public static extern void UpdatePresence(ref RichPresence presence);
+
+    [DllImport("discord-rpc", EntryPoint = "Discord_Respond", CallingConvention = CallingConvention.Cdecl)]
+    public static extern void Respond(string userId, Reply reply);
 }
 

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

@@ -653,7 +653,7 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   presence:
     state: Button clicking
-    details: 
+    details: Best game ever
     startTimestamp: 0
     endTimestamp: 0
     largeImageKey: stable-large
@@ -663,10 +663,10 @@ 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
@@ -703,6 +703,21 @@ MonoBehaviour:
         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_TypeName: DiscordJoinRequestEvent, Assembly-CSharp, Version=0.0.0.0, Culture=neutral,
+      PublicKeyToken=null
 --- !u!4 &1929635630
 Transform:
   m_ObjectHideFlags: 0

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

@@ -15,6 +15,21 @@ static const char* APPLICATION_ID = "345229890980937739";
 static int FrustrationLevel = 0;
 static int64_t StartTime;
 
+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];
@@ -62,19 +77,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 +119,7 @@ static void discordInit()
     handlers.errored = handleDiscordError;
     handlers.joinGame = handleDiscordJoin;
     handlers.spectateGame = handleDiscordSpectate;
+    handlers.joinRequest = handleDiscordJoinRequest;
     Discord_Initialize(APPLICATION_ID, &handlers, 1, NULL);
 }
 

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

@@ -12,6 +12,7 @@ public class discordrpcLibrary : ModuleRules
 		if (Target.Platform == UnrealTargetPlatform.Win64)
 		{
 			// Add the import library
+			PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Include"));
 			PublicLibraryPaths.Add(Path.Combine(ModuleDirectory, "x64", "Release"));
 			PublicAdditionalLibraries.Add("discord-rpc.lib");
 

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

@@ -7,6 +7,7 @@
 DEFINE_LOG_CATEGORY(Discord)
 
 static UDiscordRpc* self = nullptr;
+
 static void ReadyHandler()
 {
     UE_LOG(Discord, Log, TEXT("Discord connected"));
@@ -53,6 +54,19 @@ 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"), *jr.username, *jr.discriminator);
+    if (self) {
+        self->OnJoinRequest.Broadcast(jr);
+    }
+}
+
 void UDiscordRpc::Initialize(const FString& applicationId,
                              bool autoRegister,
                              const FString& optionalSteamId)
@@ -69,6 +83,9 @@ 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(

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

@@ -2,8 +2,8 @@
 
 #include "discordrpc.h"
 #include "Core.h"
-#include "ModuleManager.h"
 #include "IPluginManager.h"
+#include "ModuleManager.h"
 
 #define LOCTEXT_NAMESPACE "FdiscordrpcModule"
 

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

@@ -2,13 +2,31 @@
 
 #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 +34,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
 
@@ -119,6 +138,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/unrealstatus.uproject

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

include/discord-rpc.h

@@ -41,30 +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 (*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_Respond(const char* userid, /* DISCORD_REPLY_ */ int reply);
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

src/CMakeLists.txt

@@ -1,51 +1,114 @@
 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
+    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)
+        set(CRT_FLAGS)
+        if(USE_STATIC_CRT)
+            if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+                set(CRT_FLAGS /MTd)
+            else()
+                set(CRT_FLAGS /MT)
+            endif()
+        endif(USE_STATIC_CRT)
+        target_compile_options(discord-rpc PRIVATE /EHsc
+            ${CRT_FLAGS}
+            /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,16 +116,13 @@ 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(

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-rpc.cpp

@@ -1,7 +1,8 @@
 #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()
 {
     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,22 @@ extern "C" void Discord_UpdatePresence(const DiscordRichPresence* presence)
     SignalIOActivity();
 }
 
-extern "C" void Discord_RunCallbacks()
+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()
 {
     // 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 +376,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/discord_register.h

@@ -1,4 +1,12 @@
 #pragma once
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void Discord_Register(const char* applicationId, const char* command);
 void Discord_RegisterSteamGame(const char* applicationId, const char* steamId);
+
+#ifdef __cplusplus
+}
+#endif

src/discord_register_linux.cpp

@@ -0,0 +1,98 @@
+#include "discord-rpc.h"
+#include <stdio.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+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" 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" 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,97 @@
+#include <stdio.h>
+#include <sys/stat.h>
+
+#import <AppKit/AppKit.h>
+
+#include "discord_register.h"
+
+static bool Mkdir(const char* path)
+{
+    int result = mkdir(path, 0755);
+    if (result == 0) {
+        return true;
+    }
+    if (errno == EEXIST) {
+        return true;
+    }
+    return false;
+}
+
+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)
+
+    const char* home = getenv("HOME");
+    if (!home) {
+        return;
+    }
+
+    char path[2048];
+    sprintf(path, "%s/Library/Application Support/discord", home);
+    Mkdir(path);
+    strcat(path, "/games");
+    Mkdir(path);
+    strcat(path, "/");
+    strcat(path, applicationId);
+    strcat(path, ".json");
+
+    FILE* f = fopen(path, "w");
+    if (f) {
+        char jsonBuffer[2048];
+        int len = snprintf(jsonBuffer, sizeof(jsonBuffer), "{\"command\": \"%s\"}", command);
+        fwrite(jsonBuffer, (size_t)len, 1, f);
+        fclose(f);
+    }
+}
+
+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
+        void* pool = [[NSAutoreleasePool alloc] init];
+        RegisterURL(applicationId);
+        [(id)pool drain];
+    }
+}
+
+void Discord_RegisterSteamGame(const char* applicationId, const char* steamId)
+{
+    char command[256];
+    sprintf(command, "steam://rungameid/%s", steamId);
+    Discord_Register(applicationId, command);
+}

src/discord_register_win.cpp

@@ -1,18 +1,26 @@
+/*
+ * MinGW defaults to WINNT 5.1 (aka XP), however some of functions used here
+ * require WINNT >= 6.0 APIs, which are only visible when WINVER and
+ * _WIN32_WINNT defines are set properly before including any system headers.
+ * Such API is e.g. RegSetKeyValueW.
+ */
+#ifdef __MINGW32__
+// 0x0600 == vista
+#define WINVER 0x0600
+#define _WIN32_WINNT 0x0600
+#endif // __MINGW32__
+
 #include "discord-rpc.h"
 #include <stdio.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 <strsafe.h>
 
-#ifdef _WIN32
 void Discord_RegisterW(const wchar_t* applicationId, const wchar_t* command)
 {
     // https://msdn.microsoft.com/en-us/library/aa767914(v=vs.85).aspx
@@ -20,15 +28,14 @@ void Discord_RegisterW(const wchar_t* applicationId, const wchar_t* command)
     // 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);
     }
 
     wchar_t protocolName[64];
@@ -49,14 +56,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 +75,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 +83,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" 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 +98,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" 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 +132,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/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

@@ -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];
@@ -197,3 +197,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,19 @@
 
 #include <stdint.h>
 
+#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
+
 #include "rapidjson/document.h"
-#include "rapidjson/writer.h"
 #include "rapidjson/stringbuffer.h"
+#include "rapidjson/writer.h"
+
+#pragma warning(pop)
 
 // if only there was a standard library function for this
 template <size_t Len>
@@ -33,6 +43,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 +79,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 +124,7 @@ public:
         }
     }
     void Flush() {}
-    size_t GetSize() const { return current_ - buffer_; }
+    size_t GetSize() const { return (size_t)(current_ - buffer_); }
 };
 
 using MallocAllocator = rapidjson::CrtAllocator;