Add Dropbox

2025-12-29 00:48:02 +01:00
62 changed files with 4548 additions and 37 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -81,7 +81,7 @@ jobs:
            gtest
            gmock
            sparsehash-devel
-            discord-rpc-devel
+            rapidjson-devel
      - name: Install kdsingleapplication-qt6-devel
        if: matrix.opensuse_version != 'leap:15.6'
        run: zypper -n --gpg-auto-import-keys in kdsingleapplication-qt6-devel
@@ -207,7 +207,7 @@ jobs:
            gtest-devel
            gmock-devel
            sparsehash-devel
-            discord-rpc-devel
+            rapidjson-devel
      - name: Checkout
        uses: actions/checkout@v6
        with:
@@ -303,7 +303,7 @@ jobs:
          appstream
          appstream-util
          hicolor-icon-theme
-          discord-rpc-devel
+          rapidjson
      - name: Remove files
        run: rm -rf /usr/lib64/qt6/lib/cmake/Qt6Sql/{Qt6QMYSQL*,Qt6QODBCD*,Qt6QPSQL*,Qt6QIBase*}
      - name: Checkout
@@ -399,7 +399,7 @@ jobs:
          appstream-util
          hicolor-icon-theme
          gtest
-          discord-rpc-devel
+          rapidjson
      - name: Build and install KDSingleApplication
        if: matrix.mageia_version == '9'
        run: |
@@ -520,7 +520,7 @@ jobs:
      - name: Create Build Environment
        run: cmake -E make_directory build
      - name: Configure CMake
-        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_WERROR=ON -DENABLE_DISCORD_RPC=OFF
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_WERROR=ON
      - name: Delete build directory
        run: rm -rf build
      - name: make deb
@@ -616,7 +616,7 @@ jobs:
      - name: Create Build Environment
        run: cmake -E make_directory build
      - name: Configure CMake
-        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_WERROR=ON -DENABLE_DISCORD_RPC=OFF
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_WERROR=ON
      - name: Delete build directory
        run: rm -rf build
      - name: make deb
@@ -692,6 +692,7 @@ jobs:
            gstreamer1.0-alsa
            gstreamer1.0-pulseaudio
            libkdsingleapplication-qt6-dev
+            rapidjson-dev
      - name: Install keyboxd
        if: matrix.ubuntu_version == 'noble'
        env:
@@ -711,7 +712,7 @@ jobs:
      - name: Create Build Environment
        run: cmake -E make_directory build
      - name: Configure CMake
-        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_WERROR=ON -DENABLE_DISCORD_RPC=OFF
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=/usr -DBUILD_WERROR=ON
      - name: Delete build directory
        run: rm -rf build
      - name: Import Ubuntu PPA GPG private key
@@ -755,7 +756,7 @@ jobs:
          set -e
          git config --global --add safe.directory ${GITHUB_WORKSPACE}
          cmake -E make_directory build
-          cmake -S . -B build -DCMAKE_BUILD_TYPE="Debug" -DENABLE_DISCORD_RPC=OFF
+          cmake -S . -B build -DCMAKE_BUILD_TYPE="Debug"
          cmake --build build --config Debug --parallel 4


@@ -775,7 +776,7 @@ jobs:
      with:
        usesh: true
        mem: 4096
-        prepare: pkg_add git cmake pkgconf boost glib2 qt6-qtbase qt6-qttools sqlite gstreamer1 gstreamer1-plugins-base chromaprint libebur128 taglib libcdio libmtp gdk-pixbuf libgpod fftw3 icu4c kdsingleapplication pulseaudio sparsehash
+        prepare: pkg_add git cmake pkgconf boost glib2 qt6-qtbase qt6-qttools sqlite gstreamer1 gstreamer1-plugins-base chromaprint libebur128 taglib libcdio libmtp gdk-pixbuf libgpod fftw3 icu4c kdsingleapplication pulseaudio sparsehash rapidjson
        run: |
          set -e
          export LDFLAGS="-L/usr/local/lib"
--- a/3rdparty/discord-rpc/CMakeLists.txt
+++ b/3rdparty/discord-rpc/CMakeLists.txt
@@ -0,0 +1,41 @@
+set(DISCORD_RPC_SOURCES
+  discord_rpc.h
+  discord_register.h
+  discord_rpc.cpp
+  discord_rpc_connection.h
+  discord_rpc_connection.cpp
+  discord_serialization.h
+  discord_serialization.cpp
+  discord_connection.h
+  discord_backoff.h
+  discord_msg_queue.h
+)
+
+if(UNIX)
+  list(APPEND DISCORD_RPC_SOURCES discord_connection_unix.cpp)
+  if(APPLE)
+    list(APPEND DISCORD_RPC_SOURCES discord_register_osx.m)
+    add_definitions(-DDISCORD_OSX)
+  else()
+    list(APPEND DISCORD_RPC_SOURCES discord_register_linux.cpp)
+    add_definitions(-DDISCORD_LINUX)
+  endif()
+endif()
+
+if(WIN32)
+  list(APPEND DISCORD_RPC_SOURCES discord_connection_win.cpp discord_register_win.cpp)
+  add_definitions(-DDISCORD_WINDOWS)
+endif()
+
+add_library(discord-rpc STATIC ${DISCORD_RPC_SOURCES})
+
+if(APPLE)
+  target_link_libraries(discord-rpc PRIVATE "-framework AppKit")
+endif()
+
+if(WIN32)
+  target_link_libraries(discord-rpc PRIVATE psapi advapi32)
+endif()
+
+target_include_directories(discord-rpc SYSTEM PRIVATE ${RapidJSON_INCLUDE_DIRS})
+target_include_directories(discord-rpc PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
--- a/3rdparty/discord-rpc/LICENSE
+++ b/3rdparty/discord-rpc/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.
--- a/3rdparty/discord-rpc/README.md
+++ b/3rdparty/discord-rpc/README.md
@@ -0,0 +1,162 @@
+# Discord RPC
+
+## Fork Notice
+
+This library was slightly modified for Strawberry Music Player with some extra features from the new API and shared library support/more unnecessary components removed. The original repository is [here](https://github.com/discord/discord-rpc)
+
+## Deprecation Notice
+
+This library has been deprecated in favor of Discord's GameSDK. [Learn more here](https://discordapp.com/developers/docs/game-sdk/sdk-starter-guide)
+
+---
+
+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.
+
+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 on our [developer site](https://discordapp.com/developers/docs/rich-presence/how-to)! If you're interested in rolling your own native implementation of Rich Presence via IPC sockets instead of using our SDK—hey, you've got free time, right?—check out the ["Hard Mode" documentation](https://github.com/discordapp/discord-rpc/blob/master/documentation/hard-mode.md).
+
+## 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.
+
+### Unreal Engine 4 Setup
+
+To use the Rich Presense plugin with Unreal Engine Projects:
+
+1.  Download the latest [release](https://github.com/discordapp/discord-rpc/releases) for each operating system you are targeting and the zipped source code
+2.  In the source code zip, copy the UE plugin—`examples/unrealstatus/Plugins/discordrpc`—to your project's plugin directory
+3.  At `[YOUR_UE_PROJECT]/Plugins/discordrpc/source/ThirdParty/DiscordRpcLibrary/`, create an `Include` folder and copy `discord_rpc.h` and `discord_register.h` to it from the zip
+4.  Follow the steps below for each OS
+5.  Build your UE4 project
+6.  Launch the editor, and enable the Discord plugin.
+
+#### Windows
+
+- At `[YOUR_UE_PROJECT]/Plugins/discordrpc/source/ThirdParty/DiscordRpcLibrary/`, create a `Win64` folder
+- Copy `lib/discord-rpc.lib` and `bin/discord-rpc.dll` from `[RELEASE_ZIP]/win64-dynamic` to the `Win64` folder
+
+#### Mac
+
+- At `[YOUR_UE_PROJECT]/Plugins/discordrpc/source/ThirdParty/DiscordRpcLibrary/`, create a `Mac` folder
+- Copy `libdiscord-rpc.dylib` from `[RELEASE_ZIP]/osx-dynamic/lib` to the `Mac` folder
+
+#### Linux
+
+- At `[YOUR_UE_PROJECT]/Plugins/discordrpc/source/ThirdParty/DiscordRpcLibrary/`, create a `Linux` folder
+- Inside, create another folder `x86_64-unknown-linux-gnu`
+- Copy `libdiscord-rpc.so` from `[RELEASE_ZIP]/linux-dynamic/lib` to `Linux/x86_64-unknown-linux-gnu`
+
+### Unity Setup
+
+If you're a Unity developer looking to integrate Rich Presence into your game, follow this simple guide to get started towards success:
+
+1. Download the DLLs for any platform that you need from [our releases](https://github.com/discordapp/discord-rpc/releases)
+2. In your Unity project, create a `Plugins` folder inside your `Assets` folder if you don't already have one
+3. Copy the file `DiscordRpc.cs` from [here](https://github.com/discordapp/discord-rpc/blob/master/examples/button-clicker/Assets/DiscordRpc.cs) into your `Assets` folder. This is basically your header file for the SDK
+
+We've got our `Plugins` folder ready, so let's get platform-specific!
+
+#### Windows
+
+4. Create `x86` and `x86_64` folders inside `Assets/Plugins/`
+5. Copy `discord-rpc-win/win64-dynamic/bin/discord-rpc.dll` to `Assets/Plugins/x86_64/`
+6. Copy `discord-rpc-win/win32-dynamic/bin/discord-rpc.dll` to `Assets/Plugins/x86/`
+7. Click on both DLLs and make sure they are targetting the correct architectures in the Unity editor properties pane
+8. Done!
+
+#### MacOS
+
+4. Copy `discord-rpc-osx/osx-dynamic/lib/libdiscord-rpc.dylib` to `Assets/Plugins/`
+5. Rename `libdiscord-rpc.dylib` to `discord-rpc.bundle`
+6. Done!
+
+#### Linux
+
+4. Copy `discord-rpc-linux/linux-dynamic-lib/libdiscord-rpc.so` to `Assets/Plugins/`
+5. Done!
+
+You're ready to roll! For code examples on how to interact with the SDK using the `DiscordRpc.cs` header file, check out [our example](https://github.com/discordapp/discord-rpc/blob/master/examples/button-clicker/Assets/DiscordController.cs)
+
+### From package
+
+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
+
+First-eth, you'll want `CMake`. There's a few different ways to install it on your system, and you should refer to [their website](https://cmake.org/install/). Many package managers provide ways of installing CMake as well.
+
+To make sure it's installed correctly, type `cmake --version` into your flavor of terminal/cmd. If you get a response with a version number, you're good to go!
+
+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
+    cd build
+    cmake .. -DCMAKE_INSTALL_PREFIX=<path to install discord-rpc to>
+    cmake --build . --config Release --target install
+```
+
+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.                              |
+| `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                                                                                                                                |
+| `WARNINGS_AS_ERRORS`                                                                     | `OFF`   | When enabled, compiles with `-Werror` (on \*nix platforms).                                                                                           |
+
+## 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.
+
+## 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. 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. 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 C#](https://github.com/Lachee/discord-rpc-csharp)            | C#                                |
+| [Discord RPC D](https://github.com/voidblaster/discord-rpc-d)             | [D](https://dlang.org/)           |
+| [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/) |
+| [lua-discordRPC](https://github.com/pfirsich/lua-discordRPC)              | LuaJIT (FFI)                      |
+| [pypresence](https://github.com/qwertyquerty/pypresence)                  | [Python](https://python.org/)     |
+| [SwordRPC](https://github.com/Azoy/SwordRPC)                              | [Swift](https://swift.org)        |
--- a/3rdparty/discord-rpc/discord_backoff.h
+++ b/3rdparty/discord-rpc/discord_backoff.h
@@ -0,0 +1,63 @@
+/*
+ * 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.
+ *
+ */
+
+#ifndef DISCORD_BACKOFF_H
+#define DISCORD_BACKOFF_H
+
+#include <algorithm>
+#include <random>
+#include <cstdint>
+#include <ctime>
+
+namespace discord_rpc {
+
+struct Backoff {
+  int64_t minAmount;
+  int64_t maxAmount;
+  int64_t current;
+  int fails;
+  std::mt19937_64 randGenerator;
+  std::uniform_real_distribution<> randDistribution;
+
+  double rand01() { return randDistribution(randGenerator); }
+
+  Backoff(int64_t min, int64_t max)
+      : minAmount(min), maxAmount(max), current(min), fails(0), randGenerator(static_cast<uint64_t>(time(0))) {
+  }
+
+  void reset() {
+    fails = 0;
+    current = minAmount;
+  }
+
+  int64_t nextDelay() {
+    ++fails;
+    int64_t delay = static_cast<int64_t>(static_cast<double>(current) * 2.0 * rand01());
+    current = std::min(current + delay, maxAmount);
+    return current;
+  }
+};
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_BACKOFF_H
--- a/3rdparty/discord-rpc/discord_connection.h
+++ b/3rdparty/discord-rpc/discord_connection.h
@@ -0,0 +1,48 @@
+/*
+ * 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.
+ *
+ */
+
+#ifndef DISCORD_CONNECTION_H
+#define DISCORD_CONNECTION_H
+
+// This is to wrap the platform specific kinds of connect/read/write.
+
+#include <cstdlib>
+
+namespace discord_rpc {
+
+// not really connectiony, but need per-platform
+int GetProcessId();
+
+struct BaseConnection {
+  static BaseConnection *Create();
+  static void Destroy(BaseConnection*&);
+  bool isOpen = false;
+  bool Open();
+  bool Close();
+  bool Write(const void *data, size_t length);
+  bool Read(void *data, size_t length);
+};
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_CONNECTION_H
--- a/3rdparty/discord-rpc/discord_connection_unix.cpp
+++ b/3rdparty/discord-rpc/discord_connection_unix.cpp
@@ -0,0 +1,160 @@
+/*
+ * 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.
+ *
+ */
+
+#include "discord_connection.h"
+
+#include <cerrno>
+#include <fcntl.h>
+#include <cstdio>
+#include <cstring>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+namespace discord_rpc {
+
+int GetProcessId() {
+  return ::getpid();
+}
+
+struct BaseConnectionUnix : public BaseConnection {
+  int sock{ -1 };
+};
+
+static BaseConnectionUnix Connection;
+static sockaddr_un PipeAddr{};
+#ifdef MSG_NOSIGNAL
+static int MsgFlags = MSG_NOSIGNAL;
+#else
+static int MsgFlags = 0;
+#endif
+
+static const char *GetTempPath() {
+
+  const char *temp = getenv("XDG_RUNTIME_DIR");
+  temp = temp ? temp : getenv("TMPDIR");
+  temp = temp ? temp : getenv("TMP");
+  temp = temp ? temp : getenv("TEMP");
+  temp = temp ? temp : "/tmp";
+
+  return temp;
+
+}
+
+BaseConnection *BaseConnection::Create() {
+  PipeAddr.sun_family = AF_UNIX;
+  return &Connection;
+}
+
+void BaseConnection::Destroy(BaseConnection *&c) {
+
+  auto self = reinterpret_cast<BaseConnectionUnix*>(c);
+  self->Close();
+  c = nullptr;
+
+}
+
+bool BaseConnection::Open() {
+
+  const char *tempPath = GetTempPath();
+  auto self = reinterpret_cast<BaseConnectionUnix*>(this);
+  self->sock = socket(AF_UNIX, SOCK_STREAM, 0);
+  if (self->sock == -1) {
+    return false;
+  }
+  fcntl(self->sock, F_SETFL, O_NONBLOCK);
+#ifdef SO_NOSIGPIPE
+  int optval = 1;
+  setsockopt(self->sock, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval));
+#endif
+
+  for (int pipeNum = 0; pipeNum < 10; ++pipeNum) {
+    snprintf(PipeAddr.sun_path, sizeof(PipeAddr.sun_path), "%s/discord-ipc-%d", tempPath, pipeNum);
+    int err = connect(self->sock, reinterpret_cast<const sockaddr*>(&PipeAddr), sizeof(PipeAddr));
+    if (err == 0) {
+      self->isOpen = true;
+      return true;
+    }
+  }
+  self->Close();
+
+  return false;
+
+}
+
+bool BaseConnection::Close() {
+
+  auto self = reinterpret_cast<BaseConnectionUnix*>(this);
+  if (self->sock == -1) {
+    return false;
+  }
+  close(self->sock);
+  self->sock = -1;
+  self->isOpen = false;
+
+  return true;
+
+}
+
+bool BaseConnection::Write(const void *data, size_t length) {
+
+  auto self = reinterpret_cast<BaseConnectionUnix*>(this);
+
+  if (self->sock == -1) {
+    return false;
+  }
+
+  ssize_t sentBytes = send(self->sock, data, length, MsgFlags);
+  if (sentBytes < 0) {
+    Close();
+  }
+
+  return sentBytes == static_cast<ssize_t>(length);
+
+}
+
+bool BaseConnection::Read(void *data, size_t length) {
+
+  auto self = reinterpret_cast<BaseConnectionUnix*>(this);
+
+  if (self->sock == -1) {
+    return false;
+  }
+
+  long res = recv(self->sock, data, length, MsgFlags);
+  if (res < 0) {
+    if (errno == EAGAIN) {
+      return false;
+    }
+    Close();
+  }
+  else if (res == 0) {
+    Close();
+  }
+
+  return static_cast<size_t>(res) == length;
+
+}
+
+}  // namespace discord_rpc
--- a/3rdparty/discord-rpc/discord_connection_win.cpp
+++ b/3rdparty/discord-rpc/discord_connection_win.cpp
@@ -0,0 +1,160 @@
+/*
+ * 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.
+ *
+ */
+
+#include "discord_connection.h"
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMCX
+#define NOSERVICE
+#define NOIME
+
+#include <cassert>
+#include <windows.h>
+
+namespace discord_rpc {
+
+int GetProcessId() {
+  return static_cast<int>(::GetCurrentProcessId());
+}
+
+struct BaseConnectionWin : public BaseConnection {
+  HANDLE pipe{ INVALID_HANDLE_VALUE };
+};
+
+static BaseConnectionWin Connection;
+
+BaseConnection *BaseConnection::Create() {
+  return &Connection;
+}
+
+void BaseConnection::Destroy(BaseConnection *&c) {
+
+  auto self = reinterpret_cast<BaseConnectionWin*>(c);
+  self->Close();
+  c = nullptr;
+
+}
+
+bool BaseConnection::Open() {
+
+  wchar_t pipeName[]{ L"\\\\?\\pipe\\discord-ipc-0" };
+  const size_t pipeDigit = sizeof(pipeName) / sizeof(wchar_t) - 2;
+  pipeName[pipeDigit] = L'0';
+  auto self = reinterpret_cast<BaseConnectionWin*>(this);
+  for (;;) {
+    self->pipe = ::CreateFileW(pipeName, GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
+    if (self->pipe != INVALID_HANDLE_VALUE) {
+      self->isOpen = true;
+      return true;
+    }
+
+    auto lastError = GetLastError();
+    if (lastError == ERROR_FILE_NOT_FOUND) {
+      if (pipeName[pipeDigit] < L'9') {
+        pipeName[pipeDigit]++;
+        continue;
+      }
+    }
+    else if (lastError == ERROR_PIPE_BUSY) {
+      if (!WaitNamedPipeW(pipeName, 10000)) {
+        return false;
+      }
+      continue;
+    }
+    return false;
+  }
+
+}
+
+bool BaseConnection::Close() {
+
+  auto self = reinterpret_cast<BaseConnectionWin*>(this);
+  ::CloseHandle(self->pipe);
+  self->pipe = INVALID_HANDLE_VALUE;
+  self->isOpen = false;
+
+  return true;
+
+}
+
+bool BaseConnection::Write(const void *data, size_t length) {
+
+  if (length == 0) {
+    return true;
+  }
+  auto self = reinterpret_cast<BaseConnectionWin*>(this);
+  assert(self);
+  if (!self) {
+    return false;
+  }
+  if (self->pipe == INVALID_HANDLE_VALUE) {
+    return false;
+  }
+  assert(data);
+  if (!data) {
+    return false;
+  }
+  const DWORD bytesLength = static_cast<DWORD>(length);
+  DWORD bytesWritten = 0;
+
+  return ::WriteFile(self->pipe, data, bytesLength, &bytesWritten, nullptr) == TRUE && bytesWritten == bytesLength;
+
+}
+
+bool BaseConnection::Read(void *data, size_t length) {
+
+  assert(data);
+  if (!data) {
+    return false;
+  }
+  auto self = reinterpret_cast<BaseConnectionWin*>(this);
+  assert(self);
+  if (!self) {
+    return false;
+  }
+  if (self->pipe == INVALID_HANDLE_VALUE) {
+    return false;
+  }
+  DWORD bytesAvailable = 0;
+  if (::PeekNamedPipe(self->pipe, nullptr, 0, nullptr, &bytesAvailable, nullptr)) {
+    if (bytesAvailable >= length) {
+      DWORD bytesToRead = static_cast<DWORD>(length);
+      DWORD bytesRead = 0;
+      if (::ReadFile(self->pipe, data, bytesToRead, &bytesRead, nullptr) == TRUE) {
+        assert(bytesToRead == bytesRead);
+        return true;
+      }
+      else {
+        Close();
+      }
+    }
+  }
+  else {
+    Close();
+  }
+
+  return false;
+
+}
+
+}  // namespace discord_rpc
--- a/3rdparty/discord-rpc/discord_msg_queue.h
+++ b/3rdparty/discord-rpc/discord_msg_queue.h
@@ -0,0 +1,64 @@
+/*
+ * 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.
+ *
+ */
+
+#ifndef DISCORD_MSG_QUEUE_H
+#define DISCORD_MSG_QUEUE_H
+
+#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.
+
+namespace discord_rpc {
+
+template<typename ElementType, std::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_; }
+};
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_MSG_QUEUE_H
--- a/3rdparty/discord-rpc/discord_register.h
+++ b/3rdparty/discord-rpc/discord_register.h
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ *
+ */
+
+#ifndef DISCORD_REGISTER_H
+#define DISCORD_REGISTER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void Discord_Register(const char *applicationId, const char *command);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // DISCORD_REGISTER_H
--- a/3rdparty/discord-rpc/discord_register_linux.cpp
+++ b/3rdparty/discord-rpc/discord_register_linux.cpp
@@ -0,0 +1,120 @@
+/*
+ * 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.
+ *
+ */
+
+#include "discord_rpc.h"
+#include "discord_register.h"
+
+#include <cstdio>
+#include <errno.h>
+#include <cstdlib>
+#include <cstring>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+namespace {
+
+static bool Mkdir(const char *path) {
+  int result = mkdir(path, 0755);
+  if (result == 0) {
+    return true;
+  }
+  if (errno == EEXIST) {
+    return true;
+  }
+  return false;
+}
+
+}  // namespace
+
+// 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]) {
+    const ssize_t size = readlink("/proc/self/exe", exePath, sizeof(exePath));
+    if (size <= 0 || size >= static_cast<ssize_t>(sizeof(exePath))) {
+      return;
+    }
+    exePath[size] = '\0';
+    command = exePath;
+  }
+
+  constexpr char desktopFileFormat[] = "[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), desktopFileFormat, applicationId, command, applicationId);
+  if (fileLen <= 0) {
+    return;
+  }
+
+  char desktopFilename[256]{};
+  (void)snprintf(desktopFilename, sizeof(desktopFilename), "/discord-%s.desktop", applicationId);
+
+  char desktopFilePath[1024]{};
+  (void)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");
+  }
+
+}
--- a/3rdparty/discord-rpc/discord_register_osx.m
+++ b/3rdparty/discord-rpc/discord_register_osx.m
@@ -0,0 +1,99 @@
+/*
+ * 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.
+ *
+ */
+
+#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);
+    }
+  }
+
+}
--- a/3rdparty/discord-rpc/discord_register_win.cpp
+++ b/3rdparty/discord-rpc/discord_register_win.cpp
@@ -0,0 +1,165 @@
+/*
+ * 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.
+ *
+ */
+
+#include "discord_rpc.h"
+#include "discord_register.h"
+
+#define WIN32_LEAN_AND_MEAN
+#define NOMCX
+#define NOSERVICE
+#define NOIME
+
+#include <windows.h>
+#include <psapi.h>
+#include <cstdio>
+
+/**
+ * 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__
+#  include <wchar.h>
+/// 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 <cwchar>
+#  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, static_cast<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]{};
+  DWORD exeLen = GetModuleFileNameW(nullptr, exeFilePath, MAX_PATH);
+  wchar_t openCommand[1024]{};
+
+  if (command && command[0]) {
+    StringCbPrintfW(openCommand, sizeof(openCommand), L"%s", command);
+  }
+  else {
+    // StringCbCopyW(openCommand, sizeof(openCommand), exeFilePath);
+    StringCbPrintfW(openCommand, sizeof(openCommand), L"%s", exeFilePath);
+  }
+
+  wchar_t protocolName[64]{};
+  StringCbPrintfW(protocolName, sizeof(protocolName), L"discord-%s", applicationId);
+  wchar_t protocolDescription[128]{};
+  StringCbPrintfW(protocolDescription, sizeof(protocolDescription), L"URL:Run game %s protocol", applicationId);
+  wchar_t urlProtocol = 0;
+
+  wchar_t keyName[256]{};
+  StringCbPrintfW(keyName, sizeof(keyName), L"Software\\Classes\\%s", protocolName);
+  HKEY key;
+  auto status = RegCreateKeyExW(HKEY_CURRENT_USER, keyName, 0, nullptr, 0, KEY_WRITE, nullptr, &key, nullptr);
+  if (status != ERROR_SUCCESS) {
+    fprintf(stderr, "Error creating key\n");
+    return;
+  }
+  DWORD len;
+  LSTATUS result;
+  len = static_cast<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 = static_cast<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");
+  }
+
+  result = RegSetKeyValueW(key, L"DefaultIcon", nullptr, REG_SZ, exeFilePath, (exeLen + 1) * sizeof(wchar_t));
+  if (FAILED(result)) {
+    fprintf(stderr, "Error writing icon\n");
+  }
+
+  len = static_cast<DWORD>(lstrlenW(openCommand) + 1);
+  result = RegSetKeyValueW(key, L"shell\\open\\command", nullptr, REG_SZ, openCommand, len * sizeof(wchar_t));
+  if (FAILED(result)) {
+    fprintf(stderr, "Error writing command\n");
+  }
+  RegCloseKey(key);
+
+}
+
+extern "C" void Discord_Register(const char *applicationId, const char *command) {
+
+  wchar_t appId[32]{};
+  MultiByteToWideChar(CP_UTF8, 0, applicationId, -1, appId, 32);
+
+  wchar_t openCommand[1024]{};
+  const wchar_t *wcommand = nullptr;
+  if (command && command[0]) {
+    const auto commandBufferLen = sizeof(openCommand) / sizeof(*openCommand);
+    MultiByteToWideChar(CP_UTF8, 0, command, -1, openCommand, commandBufferLen);
+    wcommand = openCommand;
+  }
+
+  Discord_RegisterW(appId, wcommand);
+
+}
--- a/3rdparty/discord-rpc/discord_rpc.cpp
+++ b/3rdparty/discord-rpc/discord_rpc.cpp
@@ -0,0 +1,510 @@
+/*
+ * 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.
+ *
+ */
+
+#include <atomic>
+#include <chrono>
+#include <mutex>
+#include <condition_variable>
+#include <thread>
+
+#include "discord_rpc.h"
+#include "discord_backoff.h"
+#include "discord_register.h"
+#include "discord_msg_queue.h"
+#include "discord_rpc_connection.h"
+#include "discord_serialization.h"
+
+using namespace discord_rpc;
+
+static void Discord_UpdateConnection();
+
+namespace {
+
+constexpr size_t MaxMessageSize{ 16 * 1024 };
+constexpr size_t MessageQueueSize{ 8 };
+constexpr size_t JoinQueueSize{ 8 };
+
+struct QueuedMessage {
+  size_t length;
+  char buffer[MaxMessageSize];
+
+  void Copy(const QueuedMessage &other) {
+    length = other.length;
+    if (length) {
+      memcpy(buffer, other.buffer, length);
+    }
+  }
+};
+
+struct User {
+  // 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 QueuedHandlers{};
+static DiscordEventHandlers Handlers{};
+static std::atomic_bool WasJustConnected{ false };
+static std::atomic_bool WasJustDisconnected{ false };
+static std::atomic_bool GotErrorMessage{ false };
+static std::atomic_bool WasJoinGame{ false };
+static std::atomic_bool WasSpectateGame{ false };
+static std::atomic_bool UpdatePresence{ false };
+static char JoinGameSecret[256];
+static char SpectateGameSecret[256];
+static int LastErrorCode{ 0 };
+static char LastErrorMessage[256];
+static int LastDisconnectErrorCode{ 0 };
+static char LastDisconnectErrorMessage[256];
+static std::mutex PresenceMutex;
+static std::mutex HandlerMutex;
+static QueuedMessage QueuedPresence{};
+static MsgQueue<QueuedMessage, MessageQueueSize> SendQueue;
+static MsgQueue<User, JoinQueueSize> JoinAskQueue;
+static User connectedUser;
+
+// 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 int Pid{ 0 };
+static int Nonce{ 1 };
+
+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 };
+        Discord_UpdateConnection();
+        while (keepRunning.load()) {
+          std::unique_lock<std::mutex> lock(waitForIOMutex);
+          waitForIOActivity.wait_for(lock, maxWait);
+          Discord_UpdateConnection();
+        }
+      });
+  }
+
+  void Notify() { waitForIOActivity.notify_all(); }
+
+  void Stop() {
+    keepRunning.exchange(false);
+    Notify();
+    if (ioThread.joinable()) {
+      ioThread.join();
+    }
+  }
+
+  ~IoThreadHolder() { Stop(); }
+};
+
+static IoThreadHolder *IoThread{ nullptr };
+
+static void UpdateReconnectTime() {
+
+  NextConnect = std::chrono::system_clock::now() + std::chrono::duration<int64_t, std::milli> { ReconnectTimeMs.nextDelay() };
+
+}
+
+static void SignalIOActivity() {
+
+  if (IoThread != nullptr) {
+    IoThread->Notify();
+  }
+
+}
+
+static bool RegisterForEvent(const char *evtName) {
+
+  auto qmessage = SendQueue.GetNextAddMessage();
+  if (qmessage) {
+    qmessage->length = JsonWriteSubscribeCommand(qmessage->buffer, sizeof(qmessage->buffer), Nonce++, evtName);
+    SendQueue.CommitAdd();
+    SignalIOActivity();
+    return true;
+  }
+
+  return false;
+
+}
+
+static bool DeregisterForEvent(const char *evtName) {
+
+  auto qmessage = SendQueue.GetNextAddMessage();
+  if (qmessage) {
+    qmessage->length = JsonWriteUnsubscribeCommand(qmessage->buffer, sizeof(qmessage->buffer), Nonce++, evtName);
+    SendQueue.CommitAdd();
+    SignalIOActivity();
+    return true;
+  }
+
+  return false;
+
+}
+
+} // namespace
+
+static void Discord_UpdateConnection() {
+
+  if (!Connection) {
+    return;
+  }
+
+  if (!Connection->IsOpen()) {
+    if (std::chrono::system_clock::now() >= NextConnect) {
+      UpdateReconnectTime();
+      Connection->Open();
+    }
+  }
+  else {
+    // reads
+
+    for (;;) {
+      JsonDocument message;
+
+      if (!Connection->Read(message)) {
+        break;
+      }
+
+      const char *evtName = GetStrMember(&message, "evt");
+      const char *nonce = GetStrMember(&message, "nonce");
+
+      if (nonce) {
+        // in responses only -- should use to match up response when needed.
+
+        if (evtName && strcmp(evtName, "ERROR") == 0) {
+          auto data = GetObjMember(&message, "data");
+          LastErrorCode = GetIntMember(data, "code");
+          StringCopy(LastErrorMessage, GetStrMember(data, "message", ""));
+          GotErrorMessage.store(true);
+        }
+      }
+      else {
+        // should have evt == name of event, optional data
+        if (evtName == nullptr) {
+          continue;
+        }
+
+        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, "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();
+          }
+        }
+      }
+    }
+
+    // writes
+    if (UpdatePresence.exchange(false) && QueuedPresence.length) {
+      QueuedMessage local;
+      {
+        std::lock_guard<std::mutex> guard(PresenceMutex);
+        local.Copy(QueuedPresence);
+      }
+      if (!Connection->Write(local.buffer, local.length)) {
+        // if we fail to send, requeue
+        std::lock_guard<std::mutex> guard(PresenceMutex);
+        QueuedPresence.Copy(local);
+        UpdatePresence.exchange(true);
+      }
+    }
+
+    while (SendQueue.HavePendingSends()) {
+      auto qmessage = SendQueue.GetNextSendMessage();
+      Connection->Write(qmessage->buffer, qmessage->length);
+      SendQueue.CommitSend();
+    }
+  }
+
+}
+
+extern "C" void Discord_Initialize(const char *applicationId, DiscordEventHandlers *handlers, const int autoRegister) {
+
+  IoThread = new (std::nothrow) IoThreadHolder();
+  if (IoThread == nullptr) {
+    return;
+  }
+
+  if (autoRegister) {
+    Discord_Register(applicationId, nullptr);
+  }
+
+  Pid = GetProcessId();
+
+  {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+
+    if (handlers) {
+      QueuedHandlers = *handlers;
+    }
+    else {
+      QueuedHandlers = {};
+    }
+
+    Handlers = {};
+  }
+
+  if (Connection) {
+    return;
+  }
+
+  Connection = RpcConnection::Create(applicationId);
+  Connection->onConnect = [](JsonDocument &readyMessage) {
+    Discord_UpdateHandlers(&QueuedHandlers);
+    if (QueuedPresence.length > 0) {
+      UpdatePresence.exchange(true);
+      SignalIOActivity();
+    }
+    auto data = GetObjMember(&readyMessage, "data");
+    auto user = GetObjMember(data, "user");
+    auto userId = GetStrMember(user, "id");
+    auto username = GetStrMember(user, "username");
+    auto avatar = GetStrMember(user, "avatar");
+    if (userId && username) {
+      StringCopy(connectedUser.userId, userId);
+      StringCopy(connectedUser.username, username);
+      auto discriminator = GetStrMember(user, "discriminator");
+      if (discriminator) {
+        StringCopy(connectedUser.discriminator, discriminator);
+      }
+      if (avatar) {
+        StringCopy(connectedUser.avatar, avatar);
+      }
+      else {
+        connectedUser.avatar[0] = 0;
+      }
+    }
+    WasJustConnected.exchange(true);
+    ReconnectTimeMs.reset();
+  };
+  Connection->onDisconnect = [](int err, const char *message) {
+    LastDisconnectErrorCode = err;
+    StringCopy(LastDisconnectErrorMessage, message);
+    WasJustDisconnected.exchange(true);
+    UpdateReconnectTime();
+  };
+
+  IoThread->Start();
+
+}
+
+extern "C" void Discord_Shutdown() {
+
+  if (!Connection) {
+    return;
+  }
+  Connection->onConnect = nullptr;
+  Connection->onDisconnect = nullptr;
+  Handlers = {};
+  QueuedPresence.length = 0;
+  UpdatePresence.exchange(false);
+  if (IoThread != nullptr) {
+    IoThread->Stop();
+    delete IoThread;
+    IoThread = nullptr;
+  }
+
+  RpcConnection::Destroy(Connection);
+
+}
+
+extern "C" void Discord_UpdatePresence(const DiscordRichPresence *presence) {
+
+  {
+    std::lock_guard<std::mutex> guard(PresenceMutex);
+    QueuedPresence.length = JsonWriteRichPresenceObj(QueuedPresence.buffer, sizeof(QueuedPresence.buffer), Nonce++, Pid, presence);
+    UpdatePresence.exchange(true);
+  }
+
+  SignalIOActivity();
+
+}
+
+extern "C" void Discord_ClearPresence(void) {
+  Discord_UpdatePresence(nullptr);
+}
+
+extern "C" 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" 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
+  // signals are book-ended by calls to ready and disconnect.
+
+  if (!Connection) {
+    return;
+  }
+
+  const bool wasDisconnected = WasJustDisconnected.exchange(false);
+  const bool isConnected = Connection->IsOpen();
+
+  if (isConnected) {
+    // if we are connected, disconnect cb first
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (wasDisconnected && Handlers.disconnected) {
+      Handlers.disconnected(LastDisconnectErrorCode, LastDisconnectErrorMessage);
+    }
+  }
+
+  if (WasJustConnected.exchange(false)) {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (Handlers.ready) {
+      DiscordUser du{ connectedUser.userId, connectedUser.username, connectedUser.discriminator, connectedUser.avatar };
+      Handlers.ready(&du);
+    }
+  }
+
+  if (GotErrorMessage.exchange(false)) {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (Handlers.errored) {
+      Handlers.errored(LastErrorCode, LastErrorMessage);
+    }
+  }
+
+  if (WasJoinGame.exchange(false)) {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (Handlers.joinGame) {
+      Handlers.joinGame(JoinGameSecret);
+    }
+  }
+
+  if (WasSpectateGame.exchange(false)) {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (Handlers.spectateGame) {
+      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()) {
+    const auto req = JoinAskQueue.GetNextSendMessage();
+    {
+      std::lock_guard<std::mutex> guard(HandlerMutex);
+      if (Handlers.joinRequest) {
+        DiscordUser du{ req->userId, req->username, req->discriminator, req->avatar };
+        Handlers.joinRequest(&du);
+      }
+    }
+    JoinAskQueue.CommitSend();
+  }
+
+  if (!isConnected) {
+    // if we are not connected, disconnect message last
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    if (wasDisconnected && Handlers.disconnected) {
+      Handlers.disconnected(LastDisconnectErrorCode, LastDisconnectErrorMessage);
+    }
+  }
+
+}
+
+extern "C" void Discord_UpdateHandlers(DiscordEventHandlers *newHandlers) {
+
+  if (newHandlers) {
+#define HANDLE_EVENT_REGISTRATION(handler_name, event)            \
+        if (!Handlers.handler_name && newHandlers->handler_name) {      \
+          RegisterForEvent(event);                                      \
+        }                                                               \
+        else if (Handlers.handler_name && !newHandlers->handler_name) { \
+          DeregisterForEvent(event);                                    \
+        }
+
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    HANDLE_EVENT_REGISTRATION(joinGame, "ACTIVITY_JOIN")
+    HANDLE_EVENT_REGISTRATION(spectateGame, "ACTIVITY_SPECTATE")
+    HANDLE_EVENT_REGISTRATION(joinRequest, "ACTIVITY_JOIN_REQUEST")
+
+#undef HANDLE_EVENT_REGISTRATION
+
+    Handlers = *newHandlers;
+  }
+  else {
+    std::lock_guard<std::mutex> guard(HandlerMutex);
+    Handlers = {};
+  }
+
+}
--- a/3rdparty/discord-rpc/discord_rpc.h
+++ b/3rdparty/discord-rpc/discord_rpc.h
@@ -0,0 +1,94 @@
+/*
+ * 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.
+ *
+ */
+
+#ifndef DISCORD_RPC_H
+#define DISCORD_RPC_H
+
+#include <cstdint>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct DiscordRichPresence {
+  int type;
+  int status_display_type;
+  const char *name;    /* max 128 bytes */
+  const char *state;   /* max 128 bytes */
+  const char *details; /* max 128 bytes */
+  int64_t startTimestamp;
+  int64_t endTimestamp;
+  const char *largeImageKey;  /* max 32 bytes */
+  const char *largeImageText; /* max 128 bytes */
+  const char *smallImageKey;  /* max 32 bytes */
+  const char *smallImageText; /* max 128 bytes */
+  const char *partyId;        /* max 128 bytes */
+  int partySize;
+  int partyMax;
+  int partyPrivacy;
+  const char *matchSecret;    /* max 128 bytes */
+  const char *joinSecret;     /* max 128 bytes */
+  const char *spectateSecret; /* max 128 bytes */
+  int8_t instance;
+} DiscordRichPresence;
+
+typedef struct DiscordUser {
+  const char *userId;
+  const char *username;
+  const char *discriminator;
+  const char *avatar;
+} DiscordUser;
+
+typedef struct DiscordEventHandlers {
+  void (*ready)(const DiscordUser *request);
+  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 DiscordUser *request);
+} DiscordEventHandlers;
+
+#define DISCORD_REPLY_NO      0
+#define DISCORD_REPLY_YES     1
+#define DISCORD_REPLY_IGNORE  2
+#define DISCORD_PARTY_PRIVATE 0
+#define DISCORD_PARTY_PUBLIC  1
+
+void Discord_Initialize(const char *applicationId, DiscordEventHandlers *handlers, const int autoRegister);
+void Discord_Shutdown(void);
+
+// checks for incoming messages, dispatches callbacks
+void Discord_RunCallbacks(void);
+
+void Discord_UpdatePresence(const DiscordRichPresence *presence);
+void Discord_ClearPresence(void);
+
+void Discord_Respond(const char *userid, /* DISCORD_REPLY_ */ int reply);
+
+void Discord_UpdateHandlers(DiscordEventHandlers *handlers);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif  // DISCORD_RPC_H
--- a/3rdparty/discord-rpc/discord_rpc_connection.cpp
+++ b/3rdparty/discord-rpc/discord_rpc_connection.cpp
@@ -0,0 +1,168 @@
+/*
+ * 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.
+ *
+ */
+
+#include "discord_rpc_connection.h"
+#include "discord_serialization.h"
+
+namespace discord_rpc {
+
+static const int RpcVersion = 1;
+static RpcConnection Instance;
+
+RpcConnection *RpcConnection::Create(const char *applicationId) {
+
+  Instance.connection = BaseConnection::Create();
+  StringCopy(Instance.appId, applicationId);
+  return &Instance;
+
+}
+
+void RpcConnection::Destroy(RpcConnection *&c) {
+
+  c->Close();
+  BaseConnection::Destroy(c->connection);
+  c = nullptr;
+
+}
+
+void RpcConnection::Open() {
+
+  if (state == State::Connected) {
+    return;
+  }
+
+  if (state == State::Disconnected && !connection->Open()) {
+    return;
+  }
+
+  if (state == State::SentHandshake) {
+    JsonDocument message;
+    if (Read(message)) {
+      auto cmd = GetStrMember(&message, "cmd");
+      auto evt = GetStrMember(&message, "evt");
+      if (cmd && evt && !strcmp(cmd, "DISPATCH") && !strcmp(evt, "READY")) {
+        state = State::Connected;
+        if (onConnect) {
+          onConnect(message);
+        }
+      }
+    }
+  }
+  else {
+    sendFrame.opcode = Opcode::Handshake;
+    sendFrame.length = static_cast<uint32_t>(JsonWriteHandshakeObj(sendFrame.message, sizeof(sendFrame.message), RpcVersion, appId));
+
+    if (connection->Write(&sendFrame, sizeof(MessageFrameHeader) + sendFrame.length)) {
+      state = State::SentHandshake;
+    }
+    else {
+      Close();
+    }
+  }
+
+}
+
+void RpcConnection::Close() {
+
+  if (onDisconnect && (state == State::Connected || state == State::SentHandshake)) {
+    onDisconnect(lastErrorCode, lastErrorMessage);
+  }
+  connection->Close();
+  state = State::Disconnected;
+
+}
+
+bool RpcConnection::Write(const void *data, size_t length) {
+
+  sendFrame.opcode = Opcode::Frame;
+  memcpy(sendFrame.message, data, length);
+  sendFrame.length = static_cast<uint32_t>(length);
+  if (!connection->Write(&sendFrame, sizeof(MessageFrameHeader) + length)) {
+    Close();
+    return false;
+  }
+
+  return true;
+
+}
+
+bool RpcConnection::Read(JsonDocument &message) {
+
+  if (state != State::Connected && state != State::SentHandshake) {
+    return false;
+  }
+  MessageFrame readFrame{};
+  for (;;) {
+    bool didRead = connection->Read(&readFrame, sizeof(MessageFrameHeader));
+    if (!didRead) {
+      if (!connection->isOpen) {
+        lastErrorCode = static_cast<int>(ErrorCode::PipeClosed);
+        StringCopy(lastErrorMessage, "Pipe closed");
+        Close();
+      }
+      return false;
+    }
+
+    if (readFrame.length > 0) {
+      didRead = connection->Read(readFrame.message, readFrame.length);
+      if (!didRead) {
+        lastErrorCode = static_cast<int>(ErrorCode::ReadCorrupt);
+        StringCopy(lastErrorMessage, "Partial data in frame");
+        Close();
+        return false;
+      }
+      readFrame.message[readFrame.length] = 0;
+    }
+
+    switch (readFrame.opcode) {
+      case Opcode::Close: {
+        message.ParseInsitu(readFrame.message);
+        lastErrorCode = GetIntMember(&message, "code");
+        StringCopy(lastErrorMessage, GetStrMember(&message, "message", ""));
+        Close();
+        return false;
+      }
+      case Opcode::Frame:
+        message.ParseInsitu(readFrame.message);
+        return true;
+      case Opcode::Ping:
+        readFrame.opcode = Opcode::Pong;
+        if (!connection->Write(&readFrame, sizeof(MessageFrameHeader) + readFrame.length)) {
+          Close();
+        }
+        break;
+      case Opcode::Pong:
+        break;
+      case Opcode::Handshake:
+      default:
+        // something bad happened
+        lastErrorCode = static_cast<int>(ErrorCode::ReadCorrupt);
+        StringCopy(lastErrorMessage, "Bad ipc frame");
+        Close();
+        return false;
+    }
+  }
+
+}
+
+}  // namespace discord_rpc
--- a/3rdparty/discord-rpc/discord_rpc_connection.h
+++ b/3rdparty/discord-rpc/discord_rpc_connection.h
@@ -0,0 +1,88 @@
+/*
+ * 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.
+ *
+ */
+
+#ifndef DISCORD_RPC_CONNECTION_H
+#define DISCORD_RPC_CONNECTION_H
+
+#include "discord_connection.h"
+#include "discord_serialization.h"
+
+namespace discord_rpc {
+
+// I took this from the buffer size libuv uses for named pipes; I suspect ours would usually be much smaller.
+constexpr size_t MaxRpcFrameSize = 64 * 1024;
+
+struct RpcConnection {
+  enum class ErrorCode : int {
+    Success = 0,
+    PipeClosed = 1,
+    ReadCorrupt = 2,
+  };
+
+  enum class Opcode : uint32_t {
+    Handshake = 0,
+    Frame = 1,
+    Close = 2,
+    Ping = 3,
+    Pong = 4,
+  };
+
+  struct MessageFrameHeader {
+    Opcode opcode;
+    uint32_t length;
+  };
+
+  struct MessageFrame : public MessageFrameHeader {
+    char message[MaxRpcFrameSize - sizeof(MessageFrameHeader)];
+  };
+
+  enum class State : uint32_t {
+    Disconnected,
+    SentHandshake,
+    AwaitingResponse,
+    Connected,
+  };
+
+  BaseConnection *connection{ nullptr };
+  State state{ State::Disconnected };
+  void (*onConnect)(JsonDocument &message) { nullptr };
+  void (*onDisconnect)(int errorCode, const char *message) { nullptr };
+  char appId[64]{};
+  int lastErrorCode{ 0 };
+  char lastErrorMessage[256]{};
+  RpcConnection::MessageFrame sendFrame;
+
+  static RpcConnection *Create(const char *applicationId);
+  static void Destroy(RpcConnection*&);
+
+  inline bool IsOpen() const { return state == State::Connected; }
+
+  void Open();
+  void Close();
+  bool Write(const void *data, size_t length);
+  bool Read(JsonDocument &message);
+};
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_RPC_CONNECTION_H
--- a/3rdparty/discord-rpc/discord_serialization.cpp
+++ b/3rdparty/discord-rpc/discord_serialization.cpp
@@ -0,0 +1,285 @@
+/*
+ * 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.
+ *
+ */
+
+#include "discord_serialization.h"
+#include "discord_connection.h"
+#include "discord_rpc.h"
+
+namespace discord_rpc {
+
+template<typename T>
+void NumberToString(char *dest, T number) {
+
+  if (!number) {
+    *dest++ = '0';
+    *dest++ = 0;
+    return;
+  }
+  if (number < 0) {
+    *dest++ = '-';
+    number = -number;
+  }
+  char temp[32];
+  int place = 0;
+  while (number) {
+    auto digit = number % 10;
+    number = number / 10;
+    temp[place++] = '0' + static_cast<char>(digit);
+  }
+  for (--place; place >= 0; --place) {
+    *dest++ = temp[place];
+  }
+  *dest = 0;
+
+}
+
+// it's ever so slightly faster to not have to strlen the key
+template<typename T>
+void WriteKey(JsonWriter &w, T &k) {
+  w.Key(k, sizeof(T) - 1);
+}
+
+struct WriteObject {
+  JsonWriter &writer;
+  WriteObject(JsonWriter &w)
+      : writer(w) {
+    writer.StartObject();
+  }
+  template<typename T>
+  WriteObject(JsonWriter &w, T &name)
+      : writer(w) {
+    WriteKey(writer, name);
+    writer.StartObject();
+  }
+  ~WriteObject() { writer.EndObject(); }
+};
+
+struct WriteArray {
+  JsonWriter &writer;
+  template<typename T>
+  WriteArray(JsonWriter &w, T &name)
+      : writer(w) {
+    WriteKey(writer, name);
+    writer.StartArray();
+  }
+  ~WriteArray() { writer.EndArray(); }
+};
+
+template<typename T>
+void WriteOptionalString(JsonWriter &w, T &k, const char *value) {
+
+  if (value && value[0]) {
+    w.Key(k, sizeof(T) - 1);
+    w.String(value);
+  }
+
+}
+
+static void JsonWriteNonce(JsonWriter &writer, const int nonce) {
+
+  WriteKey(writer, "nonce");
+  char nonceBuffer[32];
+  NumberToString(nonceBuffer, nonce);
+  writer.String(nonceBuffer);
+
+}
+
+size_t JsonWriteRichPresenceObj(char *dest, const size_t maxLen, const int nonce, const int pid, const DiscordRichPresence *presence) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject top(writer);
+
+    JsonWriteNonce(writer, nonce);
+
+    WriteKey(writer, "cmd");
+    writer.String("SET_ACTIVITY");
+
+    {
+      WriteObject args(writer, "args");
+
+      WriteKey(writer, "pid");
+      writer.Int(pid);
+
+      if (presence != nullptr) {
+        WriteObject activity(writer, "activity");
+
+        if (presence->type >= 0 && presence->type <= 5) {
+          WriteKey(writer, "type");
+          writer.Int(presence->type);
+
+          WriteKey(writer, "status_display_type");
+          writer.Int(presence->status_display_type);
+        }
+
+        WriteOptionalString(writer, "name", presence->name);
+        WriteOptionalString(writer, "state", presence->state);
+        WriteOptionalString(writer, "details", presence->details);
+
+        if (presence->startTimestamp || presence->endTimestamp) {
+          WriteObject timestamps(writer, "timestamps");
+
+          if (presence->startTimestamp) {
+            WriteKey(writer, "start");
+            writer.Int64(presence->startTimestamp);
+          }
+
+          if (presence->endTimestamp) {
+            WriteKey(writer, "end");
+            writer.Int64(presence->endTimestamp);
+          }
+        }
+
+        if ((presence->largeImageKey && presence->largeImageKey[0]) ||
+            (presence->largeImageText && presence->largeImageText[0]) ||
+            (presence->smallImageKey && presence->smallImageKey[0]) ||
+            (presence->smallImageText && presence->smallImageText[0])) {
+          WriteObject assets(writer, "assets");
+          WriteOptionalString(writer, "large_image", presence->largeImageKey);
+          WriteOptionalString(writer, "large_text", presence->largeImageText);
+          WriteOptionalString(writer, "small_image", presence->smallImageKey);
+          WriteOptionalString(writer, "small_text", presence->smallImageText);
+        }
+
+        if ((presence->partyId && presence->partyId[0]) || presence->partySize ||
+            presence->partyMax || presence->partyPrivacy) {
+          WriteObject party(writer, "party");
+          WriteOptionalString(writer, "id", presence->partyId);
+          if (presence->partySize && presence->partyMax) {
+            WriteArray size(writer, "size");
+            writer.Int(presence->partySize);
+            writer.Int(presence->partyMax);
+          }
+
+          if (presence->partyPrivacy) {
+            WriteKey(writer, "privacy");
+            writer.Int(presence->partyPrivacy);
+          }
+        }
+
+        if ((presence->matchSecret && presence->matchSecret[0]) ||
+            (presence->joinSecret && presence->joinSecret[0]) ||
+            (presence->spectateSecret && presence->spectateSecret[0])) {
+          WriteObject secrets(writer, "secrets");
+          WriteOptionalString(writer, "match", presence->matchSecret);
+          WriteOptionalString(writer, "join", presence->joinSecret);
+          WriteOptionalString(writer, "spectate", presence->spectateSecret);
+        }
+
+        writer.Key("instance");
+        writer.Bool(presence->instance != 0);
+      }
+    }
+  }
+
+  return writer.Size();
+}
+
+size_t JsonWriteHandshakeObj(char *dest, size_t maxLen, int version, const char *applicationId) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject obj(writer);
+    WriteKey(writer, "v");
+    writer.Int(version);
+    WriteKey(writer, "client_id");
+    writer.String(applicationId);
+  }
+
+  return writer.Size();
+
+}
+
+size_t JsonWriteSubscribeCommand(char *dest, size_t maxLen, int nonce, const char *evtName) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject obj(writer);
+
+    JsonWriteNonce(writer, nonce);
+
+    WriteKey(writer, "cmd");
+    writer.String("SUBSCRIBE");
+
+    WriteKey(writer, "evt");
+    writer.String(evtName);
+  }
+
+  return writer.Size();
+
+}
+
+size_t JsonWriteUnsubscribeCommand(char *dest, size_t maxLen, int nonce, const char *evtName) {
+
+  JsonWriter writer(dest, maxLen);
+
+  {
+    WriteObject obj(writer);
+
+    JsonWriteNonce(writer, nonce);
+
+    WriteKey(writer, "cmd");
+    writer.String("UNSUBSCRIBE");
+
+    WriteKey(writer, "evt");
+    writer.String(evtName);
+  }
+
+  return writer.Size();
+
+}
+
+size_t JsonWriteJoinReply(char *dest, size_t maxLen, const char *userId, const int reply, const 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();
+
+}
+
+}  // namespace discord_rpc
--- a/3rdparty/discord-rpc/discord_serialization.h
+++ b/3rdparty/discord-rpc/discord_serialization.h
@@ -0,0 +1,213 @@
+/*
+ * 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.
+ *
+ */
+
+#ifndef DISCORD_SERIALIZATION_H
+#define DISCORD_SERIALIZATION_H
+
+#include <rapidjson/document.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+
+struct DiscordRichPresence;
+
+namespace discord_rpc {
+
+// if only there was a standard library function for this
+template<size_t Len>
+inline size_t StringCopy(char (&dest)[Len], const char *src) {
+  if (!src || !Len) {
+    return 0;
+  }
+  size_t copied;
+  char *out = dest;
+  for (copied = 1; *src && copied < Len; ++copied) {
+    *out++ = *src++;
+  }
+  *out = 0;
+  return copied - 1;
+}
+
+size_t JsonWriteHandshakeObj(char *dest, size_t maxLen, int version, const char *applicationId);
+
+// Commands
+size_t JsonWriteRichPresenceObj(char *dest, const size_t maxLen, const int nonce, const int pid, const DiscordRichPresence *presence);
+size_t JsonWriteSubscribeCommand(char *dest, size_t maxLen, int nonce, const char *evtName);
+
+size_t JsonWriteUnsubscribeCommand(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
+
+class LinearAllocator {
+ public:
+  char *buffer_;
+  char *end_;
+  LinearAllocator() {
+    assert(0);  // needed for some default case in rapidjson, should not use
+  }
+  LinearAllocator(char *buffer, size_t size)
+      : buffer_(buffer), end_(buffer + size) {
+  }
+  static const bool kNeedFree = false;
+  void *Malloc(size_t size) {
+    char *res = buffer_;
+    buffer_ += size;
+    if (buffer_ > end_) {
+      buffer_ = res;
+      return nullptr;
+    }
+    return res;
+  }
+  void *Realloc(void *originalPtr, size_t originalSize, size_t newSize) {
+    if (newSize == 0) {
+      return nullptr;
+    }
+    // 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) {
+    /* shrug */
+    (void)ptr;
+  }
+};
+
+template<size_t Size>
+class FixedLinearAllocator : public LinearAllocator {
+ public:
+  char fixedBuffer_[Size];
+  FixedLinearAllocator()
+      : LinearAllocator(fixedBuffer_, Size) {
+  }
+  static const bool kNeedFree = false;
+};
+
+// wonder why this isn't a thing already, maybe I missed it
+class DirectStringBuffer {
+ public:
+  using Ch = char;
+  char *buffer_;
+  char *end_;
+  char *current_;
+
+  DirectStringBuffer(char *buffer, size_t maxLen)
+      : buffer_(buffer), end_(buffer + maxLen), current_(buffer) {
+  }
+
+  void Put(char c) {
+    if (current_ < end_) {
+      *current_++ = c;
+    }
+  }
+  void Flush() {}
+  size_t GetSize() const { return static_cast<size_t>(current_ - buffer_); }
+};
+
+using MallocAllocator = rapidjson::CrtAllocator;
+using PoolAllocator = rapidjson::MemoryPoolAllocator<MallocAllocator>;
+using UTF8 = rapidjson::UTF8<char>;
+// Writer appears to need about 16 bytes per nested object level (with 64bit size_t)
+using StackAllocator = FixedLinearAllocator<2048>;
+constexpr size_t WriterNestingLevels = 2048 / (2 * sizeof(size_t));
+using JsonWriterBase =
+  rapidjson::Writer<DirectStringBuffer, UTF8, UTF8, StackAllocator, rapidjson::kWriteNoFlags>;
+class JsonWriter : public JsonWriterBase {
+ public:
+  DirectStringBuffer stringBuffer_;
+  StackAllocator stackAlloc_;
+
+  JsonWriter(char *dest, size_t maxLen)
+      : JsonWriterBase(stringBuffer_, &stackAlloc_, WriterNestingLevels), stringBuffer_(dest, maxLen), stackAlloc_() {
+  }
+
+  size_t Size() const { return stringBuffer_.GetSize(); }
+};
+
+using JsonDocumentBase = rapidjson::GenericDocument<UTF8, PoolAllocator, StackAllocator>;
+class JsonDocument : public JsonDocumentBase {
+ public:
+  static const int kDefaultChunkCapacity = 32 * 1024;
+  // json parser will use this buffer first, then allocate more if needed; I seriously doubt we
+  // send any messages that would use all of this, though.
+  char parseBuffer_[32 * 1024];
+  MallocAllocator mallocAllocator_;
+  PoolAllocator poolAllocator_;
+  StackAllocator stackAllocator_;
+  JsonDocument()
+      : JsonDocumentBase(rapidjson::kObjectType,
+                         &poolAllocator_,
+                         sizeof(stackAllocator_.fixedBuffer_),
+                         &stackAllocator_),
+        poolAllocator_(parseBuffer_, sizeof(parseBuffer_), kDefaultChunkCapacity, &mallocAllocator_), stackAllocator_() {
+  }
+};
+
+using JsonValue = rapidjson::GenericValue<UTF8, PoolAllocator>;
+
+inline JsonValue *GetObjMember(JsonValue *obj, const char *name) {
+
+  if (obj) {
+    auto member = obj->FindMember(name);
+    if (member != obj->MemberEnd() && member->value.IsObject()) {
+      return &member->value;
+    }
+  }
+
+  return nullptr;
+
+}
+
+inline int GetIntMember(JsonValue *obj, const char *name, int notFoundDefault = 0) {
+
+  if (obj) {
+    auto member = obj->FindMember(name);
+    if (member != obj->MemberEnd() && member->value.IsInt()) {
+      return member->value.GetInt();
+    }
+  }
+
+  return notFoundDefault;
+
+}
+
+inline const char *GetStrMember(JsonValue *obj, const char *name, const char *notFoundDefault = nullptr) {
+
+  if (obj) {
+    auto member = obj->FindMember(name);
+    if (member != obj->MemberEnd() && member->value.IsString()) {
+      return member->value.GetString();
+    }
+  }
+
+  return notFoundDefault;
+
+}
+
+}  // namespace discord_rpc
+
+#endif  // DISCORD_SERIALIZATION_H
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -212,18 +212,7 @@ find_package(GTest)

 pkg_check_modules(LIBSPARSEHASH IMPORTED_TARGET libsparsehash)

-find_package(discord-rpc)
-if(TARGET discord-rpc::discord-rpc)
-  set(DISCORD_RPC_FOUND ON)
-  set(DISCORD_RPC_LIBRARIES "discord-rpc::discord-rpc")
-else()
-  find_library(DISCORD_RPC_LIBRARY discord-rpc)
-  find_path(DISCORD_RPC_INCLUDE_DIRS NAMES discord-rpc.h)
-  if(DISCORD_RPC_LIBRARY)
-    set(DISCORD_RPC_FOUND ON)
-    set(DISCORD_RPC_LIBRARIES ${DISCORD_RPC_LIBRARY})
-  endif()
-endif()
+find_package(RapidJSON)

 set(QT_VERSION_MAJOR 6)
 set(QT_MIN_VERSION 6.4.0)
@@ -389,7 +378,14 @@ optional_component(STREAMTAGREADER ON "Stream tagreader"
 )

 optional_component(DISCORD_RPC ON "Discord Rich Presence"
-  DEPENDS "discord-rpc" DISCORD_RPC_FOUND
+  DEPENDS "RapidJSON" RapidJSON_FOUND
+
+optional_component(DROPBOX ON "Streaming: Dropbox"
+  DEPENDS "Stream tagreader" HAVE_STREAMTAGREADER
+)
+
+optional_component(ONEDRIVE ON "Streaming: OneDrive"
+  DEPENDS "Stream tagreader" HAVE_STREAMTAGREADER
 )

 if(HAVE_SONGFINGERPRINTING OR HAVE_MUSICBRAINZ)
@@ -787,6 +783,7 @@ set(SOURCES
  src/streaming/streamingcollectionviewcontainer.cpp
  src/streaming/streamingsearchview.cpp
  src/streaming/streamsongmimedata.cpp
+  src/streaming/cloudstoragestreamingservice.cpp

  src/radios/radioservices.cpp
  src/radios/radiobackend.cpp
@@ -1083,6 +1080,7 @@ set(HEADERS
  src/streaming/streamingtabsview.h
  src/streaming/streamingcollectionview.h
  src/streaming/streamingcollectionviewcontainer.h
+  src/streaming/cloudstoragestreamingservice.h

  src/radios/radioservices.h
  src/radios/radiobackend.h
@@ -1491,6 +1489,25 @@ optional_source(HAVE_QOBUZ
    src/settings/qobuzsettingspage.ui
 )

+optional_source(HAVE_DROPBOX
+  SOURCES
+    src/dropbox/dropboxservice.cpp
+    src/dropbox/dropboxurlhandler.cpp
+    src/dropbox/dropboxbaserequest.cpp
+    src/dropbox/dropboxsongsrequest.cpp
+    src/dropbox/dropboxstreamurlrequest.cpp
+    src/settings/dropboxsettingspage.cpp
+  HEADERS
+    src/dropbox/dropboxservice.h
+    src/dropbox/dropboxurlhandler.h
+    src/dropbox/dropboxbaserequest.h
+    src/dropbox/dropboxsongsrequest.h
+    src/dropbox/dropboxstreamurlrequest.h
+    src/settings/dropboxsettingspage.h
+  UI
+    src/settings/dropboxsettingspage.ui
+)
+
 qt_wrap_cpp(SOURCES ${HEADERS})
 qt_wrap_ui(SOURCES ${UI})
 qt_add_resources(SOURCES data/data.qrc data/icons.qrc)
@@ -1514,6 +1531,11 @@ if(LINUX AND LSB_RELEASE_EXEC AND DPKG_BUILDPACKAGE)
  add_subdirectory(debian)
 endif()

+if(HAVE_DISCORD_RPC)
+  add_subdirectory(3rdparty/discord-rpc)
+  target_include_directories(strawberry_lib PUBLIC 3rdparty/discord-rpc)
+endif()
+
 if(HAVE_TRANSLATIONS)
  qt_add_lupdate(strawberry_lib TS_FILES "${CMAKE_SOURCE_DIR}/src/translations/strawberry_en_US.ts" OPTIONS -locations none -no-ui-lines -no-obsolete)
  file(GLOB_RECURSE ts_files ${CMAKE_SOURCE_DIR}/src/translations/*.ts)
@@ -1535,10 +1557,6 @@ if(SINGLEAPPLICATION_INCLUDE_DIRS)
  target_include_directories(strawberry_lib SYSTEM PUBLIC ${SINGLEAPPLICATION_INCLUDE_DIRS})
 endif()

-if(DISCORD_RPC_INCLUDE_DIRS)
-  target_include_directories(strawberry_lib SYSTEM PUBLIC ${DISCORD_RPC_INCLUDE_DIRS})
-endif()
-
 target_link_libraries(strawberry_lib PUBLIC
  ${CMAKE_THREAD_LIBS_INIT}
  $<$<BOOL:${HAVE_BACKTRACE}>:${Backtrace_LIBRARIES}>
@@ -1578,7 +1596,7 @@ target_link_libraries(strawberry_lib PUBLIC
  $<$<BOOL:${WIN32}>:dsound dwmapi ${GETOPT_LIBRARIES}>
  $<$<BOOL:${MSVC}>:WindowsApp>
  KDAB::kdsingleapplication
-  $<$<BOOL:${HAVE_DISCORD_RPC}>:${DISCORD_RPC_LIBRARIES}>
+  $<$<BOOL:${HAVE_DISCORD_RPC}>:discord-rpc>
 )

 if(APPLE)
--- a/data/icons.qrc
+++ b/data/icons.qrc
@@ -98,6 +98,7 @@
        <file>icons/128x128/somafm.png</file>
        <file>icons/128x128/radioparadise.png</file>
        <file>icons/128x128/musicbrainz.png</file>
+        <file>icons/128x128/dropbox.png</file>
        <file>icons/64x64/albums.png</file>
        <file>icons/64x64/alsa.png</file>
        <file>icons/64x64/application-exit.png</file>
@@ -197,6 +198,7 @@
        <file>icons/64x64/somafm.png</file>
        <file>icons/64x64/radioparadise.png</file>
        <file>icons/64x64/musicbrainz.png</file>
+        <file>icons/64x64/dropbox.png</file>
        <file>icons/48x48/albums.png</file>
        <file>icons/48x48/alsa.png</file>
        <file>icons/48x48/application-exit.png</file>
@@ -300,6 +302,7 @@
        <file>icons/48x48/somafm.png</file>
        <file>icons/48x48/radioparadise.png</file>
        <file>icons/48x48/musicbrainz.png</file>
+        <file>icons/48x48/dropbox.png</file>
        <file>icons/32x32/albums.png</file>
        <file>icons/32x32/alsa.png</file>
        <file>icons/32x32/application-exit.png</file>
@@ -403,6 +406,7 @@
        <file>icons/32x32/somafm.png</file>
        <file>icons/32x32/radioparadise.png</file>
        <file>icons/32x32/musicbrainz.png</file>
+        <file>icons/32x32/dropbox.png</file>
        <file>icons/22x22/albums.png</file>
        <file>icons/22x22/alsa.png</file>
        <file>icons/22x22/application-exit.png</file>
@@ -506,5 +510,6 @@
        <file>icons/22x22/somafm.png</file>
        <file>icons/22x22/radioparadise.png</file>
        <file>icons/22x22/musicbrainz.png</file>
+        <file>icons/22x22/dropbox.png</file>
    </qresource>
 </RCC>
--- a/data/icons/128x128/dropbox.png
+++ b/data/icons/128x128/dropbox.png
--- a/data/icons/22x22/dropbox.png
+++ b/data/icons/22x22/dropbox.png
--- a/data/icons/32x32/dropbox.png
+++ b/data/icons/32x32/dropbox.png
--- a/data/icons/48x48/dropbox.png
+++ b/data/icons/48x48/dropbox.png
--- a/data/icons/64x64/dropbox.png
+++ b/data/icons/64x64/dropbox.png
--- a/data/icons/full/dropbox.png
+++ b/data/icons/full/dropbox.png
--- a/data/schema/schema-22.sql
+++ b/data/schema/schema-22.sql
@@ -0,0 +1,82 @@
+CREATE TABLE IF NOT EXISTS dropbox_songs (
+
+  title TEXT,
+  album TEXT,
+  artist TEXT,
+  albumartist TEXT,
+  track INTEGER NOT NULL DEFAULT -1,
+  disc INTEGER NOT NULL DEFAULT -1,
+  year INTEGER NOT NULL DEFAULT -1,
+  originalyear INTEGER NOT NULL DEFAULT -1,
+  genre TEXT,
+  compilation INTEGER NOT NULL DEFAULT 0,
+  composer TEXT,
+  performer TEXT,
+  grouping TEXT,
+  comment TEXT,
+  lyrics TEXT,
+
+  artist_id TEXT,
+  album_id TEXT,
+  song_id TEXT,
+
+  beginning INTEGER NOT NULL DEFAULT 0,
+  length INTEGER NOT NULL DEFAULT 0,
+
+  bitrate INTEGER NOT NULL DEFAULT -1,
+  samplerate INTEGER NOT NULL DEFAULT -1,
+  bitdepth INTEGER NOT NULL DEFAULT -1,
+
+  source INTEGER NOT NULL DEFAULT 0,
+  directory_id INTEGER NOT NULL DEFAULT -1,
+  url TEXT NOT NULL,
+  filetype INTEGER NOT NULL DEFAULT 0,
+  filesize INTEGER NOT NULL DEFAULT -1,
+  mtime INTEGER NOT NULL DEFAULT -1,
+  ctime INTEGER NOT NULL DEFAULT -1,
+  unavailable INTEGER DEFAULT 0,
+
+  fingerprint TEXT,
+
+  playcount INTEGER NOT NULL DEFAULT 0,
+  skipcount INTEGER NOT NULL DEFAULT 0,
+  lastplayed INTEGER NOT NULL DEFAULT -1,
+  lastseen INTEGER NOT NULL DEFAULT -1,
+
+  compilation_detected INTEGER DEFAULT 0,
+  compilation_on INTEGER NOT NULL DEFAULT 0,
+  compilation_off INTEGER NOT NULL DEFAULT 0,
+  compilation_effective INTEGER NOT NULL DEFAULT 0,
+
+  art_embedded INTEGER DEFAULT 0,
+  art_automatic TEXT,
+  art_manual TEXT,
+  art_unset INTEGER DEFAULT 0,
+
+  effective_albumartist TEXT,
+  effective_originalyear INTEGER NOT NULL DEFAULT 0,
+
+  cue_path TEXT,
+
+  rating INTEGER DEFAULT -1,
+
+  acoustid_id TEXT,
+  acoustid_fingerprint TEXT,
+
+  musicbrainz_album_artist_id TEXT,
+  musicbrainz_artist_id TEXT,
+  musicbrainz_original_artist_id TEXT,
+  musicbrainz_album_id TEXT,
+  musicbrainz_original_album_id TEXT,
+  musicbrainz_recording_id TEXT,
+  musicbrainz_track_id TEXT,
+  musicbrainz_disc_id TEXT,
+  musicbrainz_release_group_id TEXT,
+  musicbrainz_work_id TEXT,
+
+  ebur128_integrated_loudness_lufs REAL,
+  ebur128_loudness_range_lu REAL
+
+);
+
+UPDATE schema_version SET version=22;
--- a/data/schema/schema.sql
+++ b/data/schema/schema.sql
@@ -1018,6 +1018,87 @@ CREATE TABLE IF NOT EXISTS qobuz_songs (

 );

+CREATE TABLE IF NOT EXISTS dropbox_songs (
+
+  title TEXT,
+  album TEXT,
+  artist TEXT,
+  albumartist TEXT,
+  track INTEGER NOT NULL DEFAULT -1,
+  disc INTEGER NOT NULL DEFAULT -1,
+  year INTEGER NOT NULL DEFAULT -1,
+  originalyear INTEGER NOT NULL DEFAULT -1,
+  genre TEXT,
+  compilation INTEGER NOT NULL DEFAULT 0,
+  composer TEXT,
+  performer TEXT,
+  grouping TEXT,
+  comment TEXT,
+  lyrics TEXT,
+
+  artist_id TEXT,
+  album_id TEXT,
+  song_id TEXT,
+
+  beginning INTEGER NOT NULL DEFAULT 0,
+  length INTEGER NOT NULL DEFAULT 0,
+
+  bitrate INTEGER NOT NULL DEFAULT -1,
+  samplerate INTEGER NOT NULL DEFAULT -1,
+  bitdepth INTEGER NOT NULL DEFAULT -1,
+
+  source INTEGER NOT NULL DEFAULT 0,
+  directory_id INTEGER NOT NULL DEFAULT -1,
+  url TEXT NOT NULL,
+  filetype INTEGER NOT NULL DEFAULT 0,
+  filesize INTEGER NOT NULL DEFAULT -1,
+  mtime INTEGER NOT NULL DEFAULT -1,
+  ctime INTEGER NOT NULL DEFAULT -1,
+  unavailable INTEGER DEFAULT 0,
+
+  fingerprint TEXT,
+
+  playcount INTEGER NOT NULL DEFAULT 0,
+  skipcount INTEGER NOT NULL DEFAULT 0,
+  lastplayed INTEGER NOT NULL DEFAULT -1,
+  lastseen INTEGER NOT NULL DEFAULT -1,
+
+  compilation_detected INTEGER DEFAULT 0,
+  compilation_on INTEGER NOT NULL DEFAULT 0,
+  compilation_off INTEGER NOT NULL DEFAULT 0,
+  compilation_effective INTEGER NOT NULL DEFAULT 0,
+
+  art_embedded INTEGER DEFAULT 0,
+  art_automatic TEXT,
+  art_manual TEXT,
+  art_unset INTEGER DEFAULT 0,
+
+  effective_albumartist TEXT,
+  effective_originalyear INTEGER NOT NULL DEFAULT 0,
+
+  cue_path TEXT,
+
+  rating INTEGER DEFAULT -1,
+
+  acoustid_id TEXT,
+  acoustid_fingerprint TEXT,
+
+  musicbrainz_album_artist_id TEXT,
+  musicbrainz_artist_id TEXT,
+  musicbrainz_original_artist_id TEXT,
+  musicbrainz_album_id TEXT,
+  musicbrainz_original_album_id TEXT,
+  musicbrainz_recording_id TEXT,
+  musicbrainz_track_id TEXT,
+  musicbrainz_disc_id TEXT,
+  musicbrainz_release_group_id TEXT,
+  musicbrainz_work_id TEXT,
+
+  ebur128_integrated_loudness_lufs REAL,
+  ebur128_loudness_range_lu REAL
+
+);
+
 CREATE TABLE IF NOT EXISTS playlists (

  name TEXT NOT NULL,
--- a/src/collection/collectionplaylistitem.cpp
+++ b/src/collection/collectionplaylistitem.cpp
@@ -41,9 +41,12 @@ bool CollectionPlaylistItem::InitFromQuery(const SqlRow &query) {
    case Song::Source::Collection:
      col = 0;
      break;
-    default:
+    case Song::Source::Dropbox:
      col = static_cast<int>(Song::kRowIdColumns.count());
      break;
+    default:
+      col = static_cast<int>(Song::kRowIdColumns.count() * 2);
+      break;
  }

  song_.InitFromQuery(query, true, col);
--- a/src/config.h.in
+++ b/src/config.h.in
@@ -33,6 +33,8 @@
 #cmakedefine HAVE_SPOTIFY
 #cmakedefine HAVE_QOBUZ
 #cmakedefine HAVE_DISCORD_RPC
+#cmakedefine HAVE_DROPBOX
+#cmakedefine HAVE_ONEDRIVE

 #cmakedefine HAVE_TAGLIB_DSFFILE
 #cmakedefine HAVE_TAGLIB_DSDIFFFILE
--- a/src/constants/dropboxconstants.h
+++ b/src/constants/dropboxconstants.h
@@ -0,0 +1,30 @@
+/*
+* Strawberry Music Player
+* Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+*
+* Strawberry is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* Strawberry is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+#ifndef DROPBOXCONSTANTS_H
+#define DROPBOXCONSTANTS_H
+
+namespace DropboxConstants {
+
+constexpr char kApiUrl[] = "https://api.dropboxapi.com";
+constexpr char kNotifyApiUrl[] = "https://notify.dropboxapi.com";
+
+}  // namespace
+
+#endif  // DROPBOXCONSTANTS_H
--- a/src/constants/dropboxsettings.h
+++ b/src/constants/dropboxsettings.h
@@ -0,0 +1,46 @@
+/*
+* Strawberry Music Player
+* Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+*
+* Strawberry is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* Strawberry is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+#ifndef DROPBOXSETTINGS_H
+#define DROPBOXSETTINGS_H
+
+namespace DropboxSettings {
+
+constexpr char kSettingsGroup[] = "Dropbox";
+
+constexpr char kEnabled[] = "enabled";
+constexpr char kSearchDelay[] = "searchdelay";
+constexpr char kArtistsSearchLimit[] = "artistssearchlimit";
+constexpr char kAlbumsSearchLimit[] = "albumssearchlimit";
+constexpr char kSongsSearchLimit[] = "songssearchlimit";
+constexpr char kFetchAlbums[] = "fetchalbums";
+constexpr char kDownloadAlbumCovers[] = "downloadalbumcovers";
+
+constexpr char kTokenType[] = "token_type";
+constexpr char kAccessToken[] = "access_token";
+constexpr char kRefreshToken[] = "refresh_token";
+constexpr char kExpiresIn[] = "expires_in";
+constexpr char kLoginTime[] = "login_time";
+
+constexpr char kApiUrl[] = "https://api.dropboxapi.com";
+constexpr char kNotifyApiUrl[] = "https://notify.dropboxapi.com";
+
+}  // namespace
+
+#endif  // DROPBOXSETTINGS_H
--- a/src/core/application.cpp
+++ b/src/core/application.cpp
@@ -105,6 +105,10 @@
 #  include "covermanager/qobuzcoverprovider.h"
 #endif

+#ifdef HAVE_DROPBOX
+#  include "dropbox/dropboxservice.h"
+#endif
+
 #ifdef HAVE_MOODBAR
 #  include "moodbar/moodbarcontroller.h"
 #  include "moodbar/moodbarloader.h"
@@ -200,6 +204,9 @@ class ApplicationImpl {
 #endif
 #ifdef HAVE_QOBUZ
          streaming_services->AddService(make_shared<QobuzService>(app->task_manager(), app->database(), app->network(), app->url_handlers(), app->albumcover_loader()));
+#endif
+#ifdef HAVE_DROPBOX
+          streaming_services->AddService(make_shared<DropboxService>(app->task_manager(), app->database(), app->network(), app->url_handlers(), app->tagreader_client(), app->albumcover_loader()));
 #endif
          return streaming_services;
        }),
--- a/src/core/mainwindow.cpp
+++ b/src/core/mainwindow.cpp
@@ -178,6 +178,9 @@
 #ifdef HAVE_QOBUZ
 #  include "constants/qobuzsettings.h"
 #endif
+#ifdef HAVE_DROPBOX
+#  include "constants/dropboxsettings.h"
+#endif

 #include "streaming/streamingservices.h"
 #include "streaming/streamingservice.h"
@@ -355,6 +358,9 @@ MainWindow::MainWindow(Application *app,
 #endif
 #ifdef HAVE_QOBUZ
      qobuz_view_(new StreamingTabsView(app->streaming_services()->ServiceBySource(Song::Source::Qobuz), app->albumcover_loader(), QLatin1String(QobuzSettings::kSettingsGroup), this)),
+#endif
+#ifdef HAVE_DROPBOX
+      dropbox_view_(new StreamingSongsView(app->streaming_services()->ServiceBySource(Song::Source::Dropbox), QLatin1String(DropboxSettings::kSettingsGroup), this)),
 #endif
      radio_view_(new RadioViewContainer(this)),
      lastfm_import_dialog_(new LastFMImportDialog(app_->lastfm_import(), this)),
@@ -441,6 +447,9 @@ MainWindow::MainWindow(Application *app,
 #ifdef HAVE_QOBUZ
  ui_->tabs->AddTab(qobuz_view_, u"qobuz"_s, IconLoader::Load(u"qobuz"_s, true, 0, 32), tr("Qobuz"));
 #endif
+#ifdef HAVE_DROPBOX
+  ui_->tabs->AddTab(dropbox_view_, u"dropbox"_s, IconLoader::Load(u"dropbox"_s, true, 0, 32), tr("Dropbox"));
+#endif

  // Add the playing widget to the fancy tab widget
  ui_->tabs->AddBottomWidget(ui_->widget_playing);
@@ -782,6 +791,12 @@ MainWindow::MainWindow(Application *app,
  }
 #endif

+#ifdef HAVE_DROPBOX
+  QObject::connect(dropbox_view_, &StreamingSongsView::ShowErrorDialog, this, &MainWindow::ShowErrorDialog);
+  QObject::connect(dropbox_view_, &StreamingSongsView::OpenSettingsDialog, this, &MainWindow::OpenServiceSettingsDialog);
+  QObject::connect(dropbox_view_->view(), &StreamingCollectionView::AddToPlaylistSignal, this, &MainWindow::AddToPlaylist);
+#endif
+
  QObject::connect(radio_view_, &RadioViewContainer::Refresh, &*app_->radio_services(), &RadioServices::RefreshChannels);
  QObject::connect(radio_view_->view(), &RadioView::GetChannels, &*app_->radio_services(), &RadioServices::GetChannels);
  QObject::connect(radio_view_->view(), &RadioView::AddToPlaylistSignal, this, &MainWindow::AddToPlaylist);
@@ -1280,6 +1295,18 @@ void MainWindow::ReloadSettings() {
  }
 #endif

+#ifdef HAVE_DROPBOX
+  s.beginGroup(DropboxSettings::kSettingsGroup);
+  const bool enable_dropbox = s.value(DropboxSettings::kEnabled, false).toBool();
+  s.endGroup();
+  if (enable_dropbox) {
+    ui_->tabs->EnableTab(dropbox_view_);
+  }
+  else {
+    ui_->tabs->DisableTab(dropbox_view_);
+  }
+#endif
+
  ui_->tabs->ReloadSettings();

 }
@@ -1326,10 +1353,12 @@ void MainWindow::ReloadAllSettings() {
  qobuz_view_->ReloadSettings();
  qobuz_view_->search_view()->ReloadSettings();
 #endif
+#ifdef HAVE_DROPBOX
+  dropbox_view_->ReloadSettings();
+#endif
 #ifdef HAVE_DISCORD_RPC
  discord_rich_presence_->ReloadSettings();
 #endif
-
 }

 void MainWindow::RefreshStyleSheet() {
@@ -2717,6 +2746,9 @@ void MainWindow::OpenServiceSettingsDialog(const Song::Source source) {
    case Song::Source::Spotify:
      settings_dialog_->OpenAtPage(SettingsDialog::Page::Spotify);
      break;
+    case Song::Source::Dropbox:
+      settings_dialog_->OpenAtPage(SettingsDialog::Page::Dropbox);
+      break;
    default:
      break;
  }
@@ -3398,6 +3430,11 @@ void MainWindow::FocusSearchField() {
  else if (ui_->tabs->currentIndex() == ui_->tabs->IndexOfTab(qobuz_view_) && !qobuz_view_->SearchFieldHasFocus()) {
    qobuz_view_->FocusSearchField();
  }
+#endif
+#ifdef HAVE_DROPBOX
+  else if (ui_->tabs->currentIndex() == ui_->tabs->IndexOfTab(dropbox_view_) && !dropbox_view_->SearchFieldHasFocus()) {
+    dropbox_view_->FocusSearchField();
+  }
 #endif
  else if (!ui_->playlist->SearchFieldHasFocus()) {
    ui_->playlist->FocusSearchField();
--- a/src/core/mainwindow.h
+++ b/src/core/mainwindow.h
@@ -355,6 +355,9 @@ class MainWindow : public QMainWindow, public PlatformInterface {
 #ifdef HAVE_QOBUZ
  StreamingTabsView *qobuz_view_;
 #endif
+#ifdef HAVE_DROPBOX
+  StreamingSongsView *dropbox_view_;
+#endif

  RadioViewContainer *radio_view_;

--- a/src/core/song.cpp
+++ b/src/core/song.cpp
@@ -1163,6 +1163,8 @@ QString Song::TextForSource(const Source source) {
    case Source::Qobuz:         return u"qobuz"_s;
    case Source::SomaFM:        return u"somafm"_s;
    case Source::RadioParadise: return u"radioparadise"_s;
+    case Source::Dropbox:       return u"dropbox"_s;
+    case Source::OneDrive:      return u"onedrive"_s;
    case Source::Unknown:       return u"unknown"_s;
  }
  return u"unknown"_s;
@@ -1183,6 +1185,8 @@ QString Song::DescriptionForSource(const Source source) {
    case Source::Qobuz:         return u"Qobuz"_s;
    case Source::SomaFM:        return u"SomaFM"_s;
    case Source::RadioParadise: return u"Radio Paradise"_s;
+    case Source::Dropbox:       return u"Dropbox"_s;
+    case Source::OneDrive:      return u"OneDrive"_s;
    case Source::Unknown:       return u"Unknown"_s;
  }
  return u"unknown"_s;
@@ -1202,6 +1206,8 @@ Song::Source Song::SourceFromText(const QString &source) {
  if (source.compare("qobuz"_L1, Qt::CaseInsensitive) == 0) return Source::Qobuz;
  if (source.compare("somafm"_L1, Qt::CaseInsensitive) == 0) return Source::SomaFM;
  if (source.compare("radioparadise"_L1, Qt::CaseInsensitive) == 0) return Source::RadioParadise;
+  if (source.compare("dropbox"_L1, Qt::CaseInsensitive) == 0) return Source::Dropbox;
+  if (source.compare("onedrive"_L1, Qt::CaseInsensitive) == 0) return Source::OneDrive;

  return Source::Unknown;

@@ -1221,6 +1227,8 @@ QIcon Song::IconForSource(const Source source) {
    case Source::Qobuz:         return IconLoader::Load(u"qobuz"_s);
    case Source::SomaFM:        return IconLoader::Load(u"somafm"_s);
    case Source::RadioParadise: return IconLoader::Load(u"radioparadise"_s);
+    case Source::Dropbox:       return IconLoader::Load(u"dropbox"_s);
+    case Source::OneDrive:      return IconLoader::Load(u"onedrive"_s);
    case Source::Unknown:       return IconLoader::Load(u"edit-delete"_s);
  }
  return IconLoader::Load(u"edit-delete"_s);
@@ -1470,7 +1478,7 @@ Song::FileType Song::FiletypeByExtension(const QString &ext) {

 bool Song::IsLinkedCollectionSource(const Source source) {

-  return source == Source::Collection;
+  return source == Source::Collection || source == Source::Dropbox;

 }

@@ -1489,11 +1497,14 @@ QString Song::ImageCacheDir(const Source source) {
      return StandardPaths::WritableLocation(StandardPaths::StandardLocation::AppLocalDataLocation) + u"/qobuzalbumcovers"_s;
    case Source::Device:
      return StandardPaths::WritableLocation(StandardPaths::StandardLocation::AppLocalDataLocation) + u"/devicealbumcovers"_s;
+    case Source::Dropbox:
+      return StandardPaths::WritableLocation(StandardPaths::StandardLocation::AppLocalDataLocation) + u"/dropboxalbumcovers"_s;
    case Source::LocalFile:
    case Source::CDDA:
    case Source::Stream:
    case Source::SomaFM:
    case Source::RadioParadise:
+    case Source::OneDrive:
    case Source::Unknown:
      return StandardPaths::WritableLocation(StandardPaths::StandardLocation::AppLocalDataLocation) + u"/albumcovers"_s;
  }
--- a/src/core/song.h
+++ b/src/core/song.h
@@ -76,7 +76,9 @@ class Song {
    Qobuz = 8,
    SomaFM = 9,
    RadioParadise = 10,
-    Spotify = 11
+    Spotify = 11,
+    Dropbox = 12,
+    OneDrive = 13,
  };
  static const int kSourceCount = 16;

--- a/src/covermanager/albumcoverchoicecontroller.cpp
+++ b/src/covermanager/albumcoverchoicecontroller.cpp
@@ -589,6 +589,8 @@ void AlbumCoverChoiceController::SaveArtManualToSong(Song *song, const QUrl &art
    case Song::Source::Tidal:
    case Song::Source::Spotify:
    case Song::Source::Qobuz:
+    case Song::Source::Dropbox:
+    case Song::Source::OneDrive:
      StreamingServicePtr service = streaming_services_->ServiceBySource(song->source());
      if (!service) break;
      if (service->artists_collection_backend()) {
--- a/src/discord/richpresence.cpp
+++ b/src/discord/richpresence.cpp
@@ -75,7 +75,7 @@ void RichPresence::ReloadSettings() {
  s.endGroup();

  if (enabled && !initialized_) {
-    Discord_Initialize(kDiscordApplicationId, nullptr, 0, nullptr);
+    Discord_Initialize(kDiscordApplicationId, nullptr, 0);
    initialized_ = true;
  }
  else if (!enabled && initialized_) {
@@ -124,6 +124,7 @@ void RichPresence::SendPresenceUpdate() {
  // Listening to
  presence_data.type = 2;
  presence_data.status_display_type = status_display_type_;
+
  presence_data.largeImageKey = kStrawberryIconResourceName;
  presence_data.smallImageKey = kStrawberryIconResourceName;
  presence_data.smallImageText = kStrawberryIconDescription;
--- a/src/dropbox/dropboxbaserequest.cpp
+++ b/src/dropbox/dropboxbaserequest.cpp
@@ -0,0 +1,132 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <QByteArray>
+#include <QString>
+#include <QUrl>
+#include <QNetworkReply>
+#include <QJsonObject>
+
+#include "constants/dropboxconstants.h"
+#include "core/networkaccessmanager.h"
+#include "dropboxservice.h"
+#include "dropboxbaserequest.h"
+
+using namespace Qt::Literals::StringLiterals;
+using namespace DropboxConstants;
+
+DropboxBaseRequest::DropboxBaseRequest(const SharedPtr<NetworkAccessManager> network, DropboxService *service, QObject *parent)
+    : JsonBaseRequest(network, parent),
+      service_(service) {}
+
+QString DropboxBaseRequest::service_name() const {
+
+  return service_->name();
+
+}
+
+bool DropboxBaseRequest::authentication_required() const {
+
+  return true;
+
+}
+
+bool DropboxBaseRequest::authenticated() const {
+
+  return service_->authenticated();
+
+}
+
+bool DropboxBaseRequest::use_authorization_header() const {
+
+  return true;
+
+}
+
+QByteArray DropboxBaseRequest::authorization_header() const {
+
+  return service_->authorization_header();
+
+}
+
+QNetworkReply *DropboxBaseRequest::GetTemporaryLink(const QUrl &url) {
+
+  QJsonObject json_object;
+  json_object.insert("path"_L1, url.path());
+  return CreatePostRequest(QUrl(QLatin1String(kApiUrl) + "/2/files/get_temporary_link"_L1), json_object);
+
+}
+
+JsonBaseRequest::JsonObjectResult DropboxBaseRequest::ParseJsonObject(QNetworkReply *reply) {
+
+  if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
+    return ReplyDataResult(ErrorCode::NetworkError, QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
+  }
+
+  JsonObjectResult result(ErrorCode::Success);
+  result.network_error = reply->error();
+  if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid()) {
+    result.http_status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+  }
+
+  const QByteArray data = reply->readAll();
+  if (!data.isEmpty()) {
+    QJsonParseError json_parse_error;
+    const QJsonDocument json_document = QJsonDocument::fromJson(data, &json_parse_error);
+    if (json_parse_error.error == QJsonParseError::NoError) {
+      const QJsonObject json_object = json_document.object();
+      if (json_object.contains("error"_L1) && json_object["error"_L1].isObject()) {
+        const QJsonObject object_error = json_object["error"_L1].toObject();
+        if (object_error.contains("status"_L1) && object_error.contains("message"_L1)) {
+          const int status = object_error["status"_L1].toInt();
+          const QString message = object_error["message"_L1].toString();
+          result.error_code = ErrorCode::APIError;
+          result.error_message = QStringLiteral("%1 (%2)").arg(message).arg(status);
+        }
+      }
+      else {
+        result.json_object = json_document.object();
+      }
+    }
+    else {
+      result.error_code = ErrorCode::ParseError;
+      result.error_message = json_parse_error.errorString();
+    }
+  }
+
+  if (result.error_code != ErrorCode::APIError) {
+    if (reply->error() != QNetworkReply::NoError) {
+      result.error_code = ErrorCode::NetworkError;
+      result.error_message = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
+    }
+    else if (result.http_status_code != 200) {
+      result.error_code = ErrorCode::HttpError;
+      result.error_message = QStringLiteral("Received HTTP code %1").arg(result.http_status_code);
+    }
+  }
+
+  if (reply->error() == QNetworkReply::AuthenticationRequiredError) {
+    service_->ClearSession();
+  }
+
+  return result;
+
+}
--- a/src/dropbox/dropboxbaserequest.h
+++ b/src/dropbox/dropboxbaserequest.h
@@ -0,0 +1,59 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef DROPBOXBASEREQUEST_H
+#define DROPBOXBASEREQUEST_H
+
+#include "config.h"
+
+#include <QByteArray>
+#include <QString>
+#include <QUrl>
+
+#include "includes/shared_ptr.h"
+#include "core/jsonbaserequest.h"
+
+class QNetworkReply;
+class NetworkAccessManager;
+class DropboxService;
+
+class DropboxBaseRequest : public JsonBaseRequest {
+  Q_OBJECT
+
+ public:
+  explicit DropboxBaseRequest(const SharedPtr<NetworkAccessManager> network, DropboxService *service, QObject *parent = nullptr);
+
+  QString service_name() const override;
+  bool authentication_required() const override;
+  bool authenticated() const override;
+  bool use_authorization_header() const override;
+  QByteArray authorization_header() const override;
+
+ protected:
+  QNetworkReply *GetTemporaryLink(const QUrl &url);
+  JsonObjectResult ParseJsonObject(QNetworkReply *reply);
+
+ Q_SIGNALS:
+  void ShowErrorDialog(const QString &error);
+
+ private:
+  DropboxService *service_;
+};
+
+#endif  // DROPBOXBASEREQUEST_H
--- a/src/dropbox/dropboxservice.cpp
+++ b/src/dropbox/dropboxservice.cpp
@@ -0,0 +1,190 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QString>
+#include <QUrl>
+#include <QTimer>
+
+#include "constants/dropboxsettings.h"
+#include "core/logging.h"
+#include "core/settings.h"
+#include "core/database.h"
+#include "core/urlhandlers.h"
+#include "core/networkaccessmanager.h"
+#include "core/oauthenticator.h"
+#include "collection/collectionbackend.h"
+#include "collection/collectionmodel.h"
+#include "streaming/cloudstoragestreamingservice.h"
+#include "dropboxservice.h"
+#include "dropboxurlhandler.h"
+#include "dropboxsongsrequest.h"
+#include "dropboxstreamurlrequest.h"
+
+using namespace Qt::Literals::StringLiterals;
+using namespace DropboxSettings;
+
+const Song::Source DropboxService::kSource = Song::Source::Dropbox;
+
+namespace {
+constexpr char kClientIDB64[] = "Zmx0b2EyYzRwaGo2eHlw";
+constexpr char kClientSecretB64[] = "emo3em5jNnNpM3Ftd2s3";
+constexpr char kOAuthRedirectUrl[] = "http://localhost/";
+constexpr char kOAuthAuthorizeUrl[] = "https://www.dropbox.com/1/oauth2/authorize";
+constexpr char kOAuthAccessTokenUrl[] = "https://api.dropboxapi.com/1/oauth2/token";
+}  // namespace
+
+DropboxService::DropboxService(const SharedPtr<TaskManager> task_manager,
+                               const SharedPtr<Database> database,
+                               const SharedPtr<NetworkAccessManager> network,
+                               const SharedPtr<UrlHandlers> url_handlers,
+                               const SharedPtr<TagReaderClient> tagreader_client,
+                               const SharedPtr<AlbumCoverLoader> albumcover_loader,
+                               QObject *parent)
+    : CloudStorageStreamingService(task_manager, database, tagreader_client, albumcover_loader, Song::Source::Dropbox, u"Dropbox"_s, u"dropbox"_s, QLatin1String(kSettingsGroup), parent),
+      network_(network),
+      oauth_(new OAuthenticator(network, this)),
+      songs_request_(new DropboxSongsRequest(network, collection_backend_, this, this)),
+      enabled_(false),
+      next_stream_url_request_id_(0) {
+
+  url_handlers->Register(new DropboxUrlHandler(task_manager, this, this));
+
+  oauth_->set_settings_group(QLatin1String(kSettingsGroup));
+  oauth_->set_type(OAuthenticator::Type::Authorization_Code);
+  oauth_->set_authorize_url(QUrl(QLatin1String(kOAuthAuthorizeUrl)));
+  oauth_->set_redirect_url(QUrl(QLatin1String(kOAuthRedirectUrl)));
+  oauth_->set_access_token_url(QUrl(QLatin1String(kOAuthAccessTokenUrl)));
+  oauth_->set_client_id(QString::fromLatin1(QByteArray::fromBase64(kClientIDB64)));
+  oauth_->set_client_secret(QString::fromLatin1(QByteArray::fromBase64(kClientSecretB64)));
+  oauth_->set_use_local_redirect_server(true);
+  oauth_->set_random_port(true);
+
+  QObject::connect(oauth_, &OAuthenticator::AuthenticationFinished, this, &DropboxService::OAuthFinished);
+
+  DropboxService::ReloadSettings();
+  oauth_->LoadSession();
+
+}
+
+bool DropboxService::authenticated() const {
+
+  return oauth_->authenticated();
+
+}
+
+void DropboxService::Exit() {
+
+  wait_for_exit_ << &*collection_backend_;
+  QObject::connect(&*collection_backend_, &CollectionBackend::ExitFinished, this, &DropboxService::ExitReceived);
+  collection_backend_->ExitAsync();
+
+}
+
+void DropboxService::ExitReceived() {
+
+  QObject *obj = sender();
+  QObject::disconnect(obj, nullptr, this, nullptr);
+  qLog(Debug) << obj << "successfully exited.";
+  wait_for_exit_.removeAll(obj);
+  if (wait_for_exit_.isEmpty()) Q_EMIT ExitFinished();
+
+}
+
+void DropboxService::ReloadSettings() {
+
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  enabled_ = s.value(kEnabled, false).toBool();
+  s.endGroup();
+
+}
+
+void DropboxService::Authenticate() {
+
+  oauth_->Authenticate();
+
+}
+
+void DropboxService::ClearSession() {
+
+  oauth_->ClearSession();
+}
+
+void DropboxService::OAuthFinished(const bool success, const QString &error) {
+
+  if (success) {
+    Q_EMIT LoginFinished(true);
+    Q_EMIT LoginSuccess();
+  }
+  else {
+    Q_EMIT LoginFailure(error);
+    Q_EMIT LoginFinished(false);
+  }
+
+}
+
+QByteArray DropboxService::authorization_header() const {
+  return oauth_->authorization_header();
+}
+
+void DropboxService::Start() {
+  songs_request_->GetFolderList();
+}
+
+void DropboxService::Reset() {
+
+  collection_backend_->DeleteAll();
+
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  s.remove("cursor");
+  s.endGroup();
+
+  if (authenticated()) {
+    Start();
+  }
+
+}
+
+uint DropboxService::GetStreamURL(const QUrl &url, QString &error) {
+
+  if (!authenticated()) {
+    error = tr("Not authenticated with Dropbox.");
+    return 0;
+  }
+
+  uint id = 0;
+  while (id == 0) id = ++next_stream_url_request_id_;
+  DropboxStreamURLRequestPtr stream_url_request = DropboxStreamURLRequestPtr(new DropboxStreamURLRequest(network_, this, id, url));
+  stream_url_requests_.insert(id, stream_url_request);
+  QObject::connect(&*stream_url_request, &DropboxStreamURLRequest::StreamURLRequestFinished, this, &DropboxService::StreamURLRequestFinishedSlot);
+  stream_url_request->Process();
+
+  return id;
+
+}
+
+void DropboxService::StreamURLRequestFinishedSlot(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error) {
+
+  if (!stream_url_requests_.contains(id)) return;
+  DropboxStreamURLRequestPtr stream_url_request = stream_url_requests_.take(id);
+
+  Q_EMIT StreamURLRequestFinished(id, media_url, success, stream_url, error);
+
+}
--- a/src/dropbox/dropboxservice.h
+++ b/src/dropbox/dropboxservice.h
@@ -0,0 +1,93 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef DROPBOXSERVICE_H
+#define DROPBOXSERVICE_H
+
+#include <QList>
+#include <QString>
+#include <QUrl>
+#include <QSharedPointer>
+
+#include "core/song.h"
+#include "streaming/cloudstoragestreamingservice.h"
+
+class QNetworkReply;
+
+class TaskManager;
+class Database;
+class NetworkAccessManager;
+class UrlHandlers;
+class TagReaderClient;
+class AlbumCoverLoader;
+class OAuthenticator;
+class DropboxSongsRequest;
+class DropboxStreamURLRequest;
+
+class DropboxService : public CloudStorageStreamingService {
+  Q_OBJECT
+
+ public:
+  explicit DropboxService(const SharedPtr<TaskManager> task_manager,
+                          const SharedPtr<Database> database,
+                          const SharedPtr<NetworkAccessManager> network,
+                          const SharedPtr<UrlHandlers> url_handlers,
+                          const SharedPtr<TagReaderClient> tagreader_client,
+                          const SharedPtr<AlbumCoverLoader> albumcover_loader,
+                          QObject *parent = nullptr);
+
+  static const Song::Source kSource;
+
+  bool oauth() const override { return true; }
+  bool authenticated() const override;
+  bool show_progress() const override { return false; }
+  bool enable_refresh_button() const override { return false; }
+
+  void Exit() override;
+  void ReloadSettings() override;
+
+  void Authenticate();
+  void ClearSession();
+
+  void Start();
+  void Reset();
+  uint GetStreamURL(const QUrl &url, QString &error);
+
+  QByteArray authorization_header() const;
+
+ Q_SIGNALS:
+  void StreamURLRequestFinished(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error = QString());
+
+ private Q_SLOTS:
+  void ExitReceived();
+  void OAuthFinished(const bool success, const QString &error = QString());
+  void StreamURLRequestFinishedSlot(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error = QString());
+
+ private:
+  const SharedPtr<NetworkAccessManager> network_;
+  OAuthenticator *oauth_;
+  DropboxSongsRequest *songs_request_;
+  bool enabled_;
+  QList<QObject*> wait_for_exit_;
+  bool finished_;
+  uint next_stream_url_request_id_;
+  QMap<uint, QSharedPointer<DropboxStreamURLRequest>> stream_url_requests_;
+};
+
+#endif  // DROPBOXSERVICE_H
--- a/src/dropbox/dropboxsongsrequest.cpp
+++ b/src/dropbox/dropboxsongsrequest.cpp
@@ -0,0 +1,244 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <QByteArray>
+#include <QString>
+#include <QUrl>
+#include <QDateTime>
+#include <QTimer>
+#include <QNetworkReply>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QJsonValue>
+
+#include "constants/dropboxsettings.h"
+#include "core/logging.h"
+#include "core/settings.h"
+#include "core/networkaccessmanager.h"
+#include "collection/collectionbackend.h"
+#include "dropboxservice.h"
+#include "dropboxbaserequest.h"
+#include "dropboxsongsrequest.h"
+
+using namespace Qt::Literals::StringLiterals;
+using namespace DropboxSettings;
+
+DropboxSongsRequest::DropboxSongsRequest(const SharedPtr<NetworkAccessManager> network, const SharedPtr<CollectionBackend> collection_backend, DropboxService *service, QObject *parent)
+    : DropboxBaseRequest(network, service, parent),
+      network_(network),
+      collection_backend_(collection_backend),
+      service_(service) {}
+
+void DropboxSongsRequest::GetFolderList() {
+
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  QString cursor = s.value("cursor").toString();
+  s.endGroup();
+
+  QUrl url(QLatin1String(kApiUrl) + "/2/files/list_folder"_L1);
+  QJsonObject json_object;
+
+  if (cursor.isEmpty()) {
+    json_object.insert("path"_L1, ""_L1);
+    json_object.insert("recursive"_L1, true);
+    json_object.insert("include_deleted"_L1, true);
+  }
+  else {
+    url.setUrl(QLatin1String(kApiUrl) + "/2/files/list_folder/continue"_L1);
+    json_object.insert("cursor"_L1, cursor);
+  }
+
+  QNetworkReply *reply = CreatePostRequest(url, json_object);
+  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply] { GetFolderListFinished(reply); });
+
+}
+
+void DropboxSongsRequest::GetFolderListFinished(QNetworkReply *reply) {
+
+  reply->deleteLater();
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (json_object_result.success()) {
+    Error(json_object_result.error_message);
+    return;
+  }
+
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
+    return;
+  }
+
+  if (json_object.contains("reset"_L1) && json_object["reset"_L1].toBool()) {
+    qLog(Debug) << "Resetting Dropbox database";
+    collection_backend_->DeleteAll();
+  }
+
+  {
+    Settings s;
+    s.beginGroup(kSettingsGroup);
+    s.setValue("cursor", json_object["cursor"_L1].toString());
+    s.endGroup();
+  }
+
+  const QJsonArray entires = json_object["entries"_L1].toArray();
+  qLog(Debug) << "File list found:" << entires.size();
+
+  QList<QUrl> urls_deleted;
+  for (const QJsonValue &value_entry : entires) {
+    if (!value_entry.isObject()) {
+      continue;
+    }
+    const QJsonObject object_entry = value_entry.toObject();
+    const QString tag = object_entry[".tag"_L1].toString();
+    const QString path = object_entry["path_lower"_L1].toString();
+    const qint64 size = object_entry["size"_L1].toInt();
+    const QString server_modified = object_entry["server_modified"_L1].toString();
+
+    QUrl url;
+    url.setScheme(service_->url_scheme());
+    url.setPath(path);
+
+    if (tag == "deleted"_L1) {
+      qLog(Debug) << "Deleting song with URL" << url;
+      urls_deleted << url;
+      continue;
+    }
+
+    if (tag == "folder"_L1) {
+      continue;
+    }
+
+    if (DropboxService::IsSupportedFiletype(path)) {
+      GetStreamURL(url, path, size, QDateTime::fromString(server_modified, Qt::ISODate).toSecsSinceEpoch());
+    }
+
+  }
+
+  if (!urls_deleted.isEmpty()) {
+    collection_backend_->DeleteSongsByUrlsAsync(urls_deleted);
+  }
+
+  if (json_object.contains("has_more"_L1) && json_object["has_more"_L1].isBool() && json_object["has_more"_L1].toBool()) {
+    Settings s;
+    s.beginGroup(kSettingsGroup);
+    s.setValue("cursor", json_object["cursor"_L1].toVariant());
+    s.endGroup();
+    GetFolderList();
+  }
+  else {
+    // Long-poll wait for changes.
+    LongPollDelta();
+  }
+
+}
+
+void DropboxSongsRequest::LongPollDelta() {
+
+  if (!service_->authenticated()) {
+    return;
+  }
+
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  const QString cursor = s.value("cursor").toString();
+  s.endGroup();
+
+  QJsonObject json_object;
+  json_object.insert("cursor"_L1, cursor);
+  json_object.insert("timeout"_L1, 30);
+
+  QNetworkReply *reply = CreatePostRequest(QUrl(QLatin1String(kNotifyApiUrl) + "/2/files/list_folder/longpoll"_L1), json_object);
+  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply] { LongPollDeltaFinished(reply); });
+
+}
+
+void DropboxSongsRequest::LongPollDeltaFinished(QNetworkReply *reply) {
+
+  reply->deleteLater();
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (json_object_result.success()) {
+    Error(json_object_result.error_message);
+    return;
+  }
+
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object["changes"_L1].toBool()) {
+    qLog(Debug) << "Dropbox: Received changes...";
+    GetFolderList();
+  }
+  else {
+    bool ok = false;
+    int backoff = json_object["backoff"_L1].toString().toInt(&ok);
+    if (!ok) {
+      backoff = 10;
+    }
+    QTimer::singleShot(backoff * 1000, this, &DropboxSongsRequest::LongPollDelta);
+  }
+
+}
+
+void DropboxSongsRequest::GetStreamURL(const QUrl &url, const QString &path, const qint64 size, const qint64 mtime) {
+
+  QNetworkReply *reply = GetTemporaryLink(url);
+  QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, path, size, mtime]() {
+    GetStreamUrlFinished(reply, path, size, mtime);
+  });
+
+}
+
+void DropboxSongsRequest::GetStreamUrlFinished(QNetworkReply *reply, const QString &filename, const qint64 size, const qint64 mtime) {
+
+  reply->deleteLater();
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply);
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
+    return;
+  }
+
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object.isEmpty()) {
+    return;
+  }
+
+  if (!json_object.contains("link"_L1)) {
+    Error(u"Missing link"_s);
+    return;
+  }
+
+  const QUrl url = QUrl::fromEncoded(json_object["link"_L1].toVariant().toByteArray());
+
+  service_->MaybeAddFileToDatabase(url, filename, size, mtime);
+
+}
+
+void DropboxSongsRequest::Error(const QString &error_message, const QVariant &debug_output) {
+
+  qLog(Error) << service_name() << error_message;
+  if (debug_output.isValid()) {
+    qLog(Debug) << debug_output;
+  }
+
+  Q_EMIT ShowErrorDialog(error_message);
+
+}
--- a/src/dropbox/dropboxsongsrequest.h
+++ b/src/dropbox/dropboxsongsrequest.h
@@ -0,0 +1,67 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef DROPBOXSONGSREQUEST_H
+#define DROPBOXSONGSREQUEST_H
+
+#include "config.h"
+
+#include <QList>
+#include <QString>
+#include <QUrl>
+
+#include "dropboxbaserequest.h"
+
+class NetworkAccessManager;
+class CollectionBackend;
+class QNetworkReply;
+class DropboxService;
+
+class DropboxSongsRequest : public DropboxBaseRequest {
+  Q_OBJECT
+
+ public:
+  explicit DropboxSongsRequest(const SharedPtr<NetworkAccessManager> network, const SharedPtr<CollectionBackend> collection_backend, DropboxService *service, QObject *parent = nullptr);
+
+  void ReloadSettings();
+
+  void GetFolderList();
+
+ Q_SIGNALS:
+  void ShowErrorDialog(const QString &error);
+
+ private:
+  void LongPollDelta();
+  void GetStreamURL(const QUrl &url, const QString &path, const qint64 size, const qint64 mtime);
+
+ protected:
+  void Error(const QString &error_message, const QVariant &debug_output = QVariant()) override;
+
+ private Q_SLOTS:
+  void GetFolderListFinished(QNetworkReply *reply);
+  void LongPollDeltaFinished(QNetworkReply *reply);
+  void GetStreamUrlFinished(QNetworkReply *reply, const QString &filename, const qint64 size, const qint64 mtime);
+
+ private:
+  const SharedPtr<NetworkAccessManager> network_;
+  const SharedPtr<CollectionBackend> collection_backend_;
+  DropboxService *service_;
+};
+
+#endif  // DROPBOXSONGSREQUEST_H
--- a/src/dropbox/dropboxstreamurlrequest.cpp
+++ b/src/dropbox/dropboxstreamurlrequest.cpp
@@ -0,0 +1,129 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "config.h"
+
+#include <QByteArray>
+#include <QString>
+#include <QUrl>
+#include <QNetworkReply>
+#include <QJsonObject>
+
+#include "includes/shared_ptr.h"
+#include "core/logging.h"
+#include "core/networkaccessmanager.h"
+#include "dropboxservice.h"
+#include "dropboxbaserequest.h"
+#include "dropboxstreamurlrequest.h"
+
+using namespace Qt::Literals::StringLiterals;
+
+DropboxStreamURLRequest::DropboxStreamURLRequest(const SharedPtr<NetworkAccessManager> network, DropboxService *service, const uint id, const QUrl &media_url, QObject *parent)
+    : DropboxBaseRequest(network, service, parent),
+      network_(network),
+      service_(service),
+      id_(id),
+      media_url_(media_url),
+      reply_(nullptr) {}
+
+DropboxStreamURLRequest::~DropboxStreamURLRequest() {
+
+  if (reply_) {
+    QObject::disconnect(reply_, nullptr, this, nullptr);
+    if (reply_->isRunning()) reply_->abort();
+    reply_->deleteLater();
+    reply_ = nullptr;
+  }
+
+}
+
+void DropboxStreamURLRequest::Cancel() {
+
+  if (reply_ && reply_->isRunning()) {
+    reply_->abort();
+  }
+
+}
+
+void DropboxStreamURLRequest::Process() {
+
+  GetStreamURL();
+
+}
+
+void DropboxStreamURLRequest::GetStreamURL() {
+
+  if (reply_) {
+    QObject::disconnect(reply_, nullptr, this, nullptr);
+    if (reply_->isRunning()) reply_->abort();
+    reply_->deleteLater();
+  }
+
+  reply_ = GetTemporaryLink(media_url_);
+  QObject::connect(reply_, &QNetworkReply::finished, this, &DropboxStreamURLRequest::StreamURLReceived);
+
+}
+
+void DropboxStreamURLRequest::StreamURLReceived() {
+
+  const QScopeGuard finish = qScopeGuard([this]() { Finish(); });
+
+  if (!reply_) return;
+
+  Q_ASSERT(replies_.contains(reply_));
+  replies_.removeAll(reply_);
+
+  const JsonObjectResult json_object_result = ParseJsonObject(reply_).json_object;
+
+  QObject::disconnect(reply_, nullptr, this, nullptr);
+  reply_->deleteLater();
+  reply_ = nullptr;
+
+  if (!json_object_result.success()) {
+    Error(json_object_result.error_message);
+    return;
+  }
+
+  const QJsonObject &json_object = json_object_result.json_object;
+  if (json_object.isEmpty() || !json_object.contains("link"_L1)) {
+    Error(u"Could not parse stream URL"_s);
+    return;
+  }
+
+  stream_url_ = QUrl::fromEncoded(json_object["link"_L1].toVariant().toByteArray());
+  success_ = stream_url_.isValid();
+
+}
+
+void DropboxStreamURLRequest::Error(const QString &error_message, const QVariant &debug_output) {
+
+  qLog(Error) << service_name() << error_message;
+  if (debug_output.isValid()) {
+    qLog(Debug) << debug_output;
+  }
+
+  error_ = error_message;
+
+}
+
+void DropboxStreamURLRequest::Finish() {
+
+  Q_EMIT StreamURLRequestFinished(id_, media_url_, success_, stream_url_, error_);
+
+}
--- a/src/dropbox/dropboxstreamurlrequest.h
+++ b/src/dropbox/dropboxstreamurlrequest.h
@@ -0,0 +1,71 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef DROPBOXSTREAMURLREQUEST_H
+#define DROPBOXSTREAMURLREQUEST_H
+
+#include "config.h"
+
+#include <QVariant>
+#include <QString>
+#include <QUrl>
+#include <QSharedPointer>
+
+#include "includes/shared_ptr.h"
+#include "dropboxservice.h"
+#include "dropboxbaserequest.h"
+
+class QNetworkReply;
+class NetworkAccessManager;
+
+class DropboxStreamURLRequest : public DropboxBaseRequest {
+  Q_OBJECT
+
+ public:
+  explicit DropboxStreamURLRequest(const SharedPtr<NetworkAccessManager> network, DropboxService *service, const uint id, const QUrl &media_url, QObject *parent = nullptr);
+  ~DropboxStreamURLRequest() override;
+
+  void Process();
+  void Cancel();
+
+ Q_SIGNALS:
+  void StreamURLRequestFinished(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error = QString());
+
+ private Q_SLOTS:
+  void StreamURLReceived();
+
+ private:
+  void GetStreamURL();
+  void Error(const QString &error_message, const QVariant &debug_output = QVariant()) override;
+  void Finish();
+
+ private:
+  const SharedPtr<NetworkAccessManager> network_;
+  DropboxService *service_;
+  uint id_;
+  QUrl media_url_;
+  QUrl stream_url_;
+  QNetworkReply *reply_;
+  bool success_;
+  QString error_;
+};
+
+using DropboxStreamURLRequestPtr = QSharedPointer<DropboxStreamURLRequest>;
+
+#endif  // DROPBOXSTREAMURLREQUEST_H
--- a/src/dropbox/dropboxurlhandler.cpp
+++ b/src/dropbox/dropboxurlhandler.cpp
@@ -0,0 +1,76 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QString>
+#include <QUrl>
+
+#include "includes/shared_ptr.h"
+#include "core/taskmanager.h"
+#include "dropboxurlhandler.h"
+#include "dropboxservice.h"
+
+DropboxUrlHandler::DropboxUrlHandler(const SharedPtr<TaskManager> task_manager, DropboxService *service, QObject *parent)
+    : UrlHandler(parent),
+      task_manager_(task_manager),
+      service_(service) {
+
+  QObject::connect(service, &DropboxService::StreamURLRequestFinished, this, &DropboxUrlHandler::StreamURLRequestFinished);
+
+}
+
+QString DropboxUrlHandler::scheme() const { return service_->url_scheme(); }
+
+UrlHandler::LoadResult DropboxUrlHandler::StartLoading(const QUrl &url) {
+
+  Request request;
+  request.task_id = task_manager_->StartTask(QStringLiteral("Loading %1 stream...").arg(url.scheme()));
+  QString error;
+  request.id = service_->GetStreamURL(url, error);
+  if (request.id == 0) {
+    CancelTask(request.task_id);
+    return LoadResult(url, LoadResult::Type::Error, error);
+  }
+
+  requests_.insert(request.id, request);
+
+  LoadResult load_result(url);
+  load_result.type_ = LoadResult::Type::WillLoadAsynchronously;
+
+  return load_result;
+
+}
+
+void DropboxUrlHandler::StreamURLRequestFinished(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error) {
+
+  if (!requests_.contains(id)) return;
+  const Request request = requests_.take(id);
+  CancelTask(request.task_id);
+
+  if (success) {
+    Q_EMIT AsyncLoadComplete(LoadResult(media_url, LoadResult::Type::TrackAvailable, stream_url));
+  }
+  else {
+    Q_EMIT AsyncLoadComplete(LoadResult(media_url, LoadResult::Type::Error, error));
+  }
+
+}
+
+void DropboxUrlHandler::CancelTask(const int task_id) {
+  task_manager_->SetTaskFinished(task_id);
+}
--- a/src/dropbox/dropboxurlhandler.h
+++ b/src/dropbox/dropboxurlhandler.h
@@ -0,0 +1,56 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef DROPBOXURLHANDLER_H
+#define DROPBOXURLHANDLER_H
+
+#include "includes/shared_ptr.h"
+#include "core/urlhandler.h"
+
+class TaskManager;
+class DropboxService;
+
+class DropboxUrlHandler : public UrlHandler {
+  Q_OBJECT
+
+ public:
+  explicit DropboxUrlHandler(const SharedPtr<TaskManager> task_manager, DropboxService *service, QObject *parent = nullptr);
+
+  QString scheme() const override;
+  LoadResult StartLoading(const QUrl &url) override;
+
+ private:
+  void CancelTask(const int task_id);
+
+ private Q_SLOTS:
+  void StreamURLRequestFinished(const uint id, const QUrl &media_url, const bool success, const QUrl &stream_url, const QString &error = QString());
+
+ private:
+  class Request {
+   public:
+    explicit Request() : id(0), task_id(-1) {}
+    uint id;
+    int task_id;
+  };
+  const SharedPtr<TaskManager> task_manager_;
+  DropboxService *service_;
+  QMap<uint, Request> requests_;
+};
+
+#endif  // DROPBOXURLHANDLER_H
--- a/src/playlist/playlistbackend.cpp
+++ b/src/playlist/playlistbackend.cpp
@@ -56,7 +56,7 @@ using namespace Qt::Literals::StringLiterals;
 using std::make_shared;

 namespace {
-constexpr int kSongTableJoins = 2;
+constexpr int kSongTableJoins = 3;
 }

 PlaylistBackend::PlaylistBackend(const SharedPtr<Database> database,
@@ -186,10 +186,12 @@ PlaylistBackend::Playlist PlaylistBackend::GetPlaylist(const int id) {

 QString PlaylistBackend::PlaylistItemsQuery() {

-  return QStringLiteral("SELECT %1, %2, p.type FROM playlist_items AS p "
+  return QStringLiteral("SELECT %1, %2, %3, p.type FROM playlist_items AS p "
                        "LEFT JOIN songs ON p.type = songs.source AND p.collection_id = songs.ROWID "
+                        "LEFT JOIN dropbox_songs ON p.type = dropbox_songs.source AND p.collection_id = dropbox_songs.ROWID "
                        "WHERE p.playlist = :playlist"
                        ).arg(Song::JoinSpec(u"songs"_s),
+                              Song::JoinSpec(u"dropbox_songs"_s),
                              Song::JoinSpec(u"p"_s));

 }
--- a/src/playlist/playlistitem.cpp
+++ b/src/playlist/playlistitem.cpp
@@ -47,6 +47,8 @@ PlaylistItemPtr PlaylistItem::NewFromSource(const Song::Source source) {

  switch (source) {
    case Song::Source::Collection:
+    case Song::Source::Dropbox:
+    case Song::Source::OneDrive:
      return make_shared<CollectionPlaylistItem>(source);
    case Song::Source::Subsonic:
    case Song::Source::Tidal:
@@ -72,6 +74,8 @@ PlaylistItemPtr PlaylistItem::NewFromSong(const Song &song) {

  switch (song.source()) {
    case Song::Source::Collection:
+    case Song::Source::Dropbox:
+    case Song::Source::OneDrive:
      return make_shared<CollectionPlaylistItem>(song);
    case Song::Source::Subsonic:
    case Song::Source::Tidal:
--- a/src/playlist/songplaylistitem.cpp
+++ b/src/playlist/songplaylistitem.cpp
@@ -34,7 +34,7 @@ SongPlaylistItem::SongPlaylistItem(const Song::Source source) : PlaylistItem(sou
 SongPlaylistItem::SongPlaylistItem(const Song &song) : PlaylistItem(song.source()), song_(song) {}

 bool SongPlaylistItem::InitFromQuery(const SqlRow &query) {
-  song_.InitFromQuery(query, false, static_cast<int>(Song::kRowIdColumns.count()));
+  song_.InitFromQuery(query, false, static_cast<int>(Song::kRowIdColumns.count() * 2));
  return true;
 }

--- a/src/playlist/streamplaylistitem.cpp
+++ b/src/playlist/streamplaylistitem.cpp
@@ -47,7 +47,7 @@ void StreamPlaylistItem::InitMetadata() {

 bool StreamPlaylistItem::InitFromQuery(const SqlRow &query) {

-  song_.InitFromQuery(query, false, static_cast<int>(Song::kRowIdColumns.count()));
+  song_.InitFromQuery(query, false, static_cast<int>(Song::kRowIdColumns.count() * 2));
  InitMetadata();
  return true;

--- a/src/settings/dropboxsettingspage.cpp
+++ b/src/settings/dropboxsettingspage.cpp
@@ -0,0 +1,144 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QObject>
+#include <QVariant>
+#include <QByteArray>
+#include <QString>
+#include <QSettings>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QSpinBox>
+#include <QMessageBox>
+#include <QEvent>
+
+#include "constants/dropboxsettings.h"
+#include "core/settings.h"
+#include "core/iconloader.h"
+#include "widgets/loginstatewidget.h"
+#include "dropbox/dropboxservice.h"
+#include "settingsdialog.h"
+#include "dropboxsettingspage.h"
+#include "ui_dropboxsettingspage.h"
+
+using namespace Qt::Literals::StringLiterals;
+using namespace DropboxSettings;
+
+DropboxSettingsPage::DropboxSettingsPage(SettingsDialog *dialog, const SharedPtr<DropboxService> service, QWidget *parent)
+    : SettingsPage(dialog, parent),
+      ui_(new Ui_DropboxSettingsPage),
+      service_(service) {
+
+  Q_ASSERT(service);
+
+  ui_->setupUi(this);
+
+  setWindowIcon(IconLoader::Load(u"dropbox"_s));
+
+  ui_->login_state->AddCredentialGroup(ui_->widget_authorization);
+
+  QObject::connect(ui_->button_login, &QPushButton::clicked, this, &DropboxSettingsPage::LoginClicked);
+  QObject::connect(ui_->button_reset, &QPushButton::clicked, this, &DropboxSettingsPage::ResetClicked);
+  QObject::connect(ui_->login_state, &LoginStateWidget::LogoutClicked, this, &DropboxSettingsPage::LogoutClicked);
+
+  QObject::connect(this, &DropboxSettingsPage::Authorize, &*service_, &DropboxService::Authenticate);
+  QObject::connect(&*service_, &StreamingService::LoginFailure, this, &DropboxSettingsPage::LoginFailure);
+  QObject::connect(&*service_, &StreamingService::LoginSuccess, this, &DropboxSettingsPage::LoginSuccess);
+
+  dialog->installEventFilter(this);
+
+}
+
+DropboxSettingsPage::~DropboxSettingsPage() {
+  delete ui_;
+}
+
+void DropboxSettingsPage::Load() {
+
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  ui_->enable->setChecked(s.value(kEnabled, false).toBool());
+  s.endGroup();
+
+  if (service_->authenticated()) ui_->login_state->SetLoggedIn(LoginStateWidget::State::LoggedIn);
+
+  Init(ui_->layout_dropboxsettingspage->parentWidget());
+
+  if (!Settings().childGroups().contains(QLatin1String(kSettingsGroup))) set_changed();
+
+}
+
+void DropboxSettingsPage::Save() {
+
+  Settings s;
+  s.beginGroup(kSettingsGroup);
+  s.setValue(kEnabled, ui_->enable->isChecked());
+  s.endGroup();
+
+}
+
+void DropboxSettingsPage::LoginClicked() {
+
+  Q_EMIT Authorize();
+
+  ui_->button_login->setEnabled(false);
+
+}
+
+bool DropboxSettingsPage::eventFilter(QObject *object, QEvent *event) {
+
+  if (object == dialog() && event->type() == QEvent::Enter) {
+    ui_->button_login->setEnabled(true);
+  }
+
+  return SettingsPage::eventFilter(object, event);
+
+}
+
+void DropboxSettingsPage::LogoutClicked() {
+
+  service_->ClearSession();
+  ui_->button_login->setEnabled(true);
+  ui_->login_state->SetLoggedIn(LoginStateWidget::State::LoggedOut);
+
+}
+
+void DropboxSettingsPage::LoginSuccess() {
+
+  if (!isVisible()) return;
+  ui_->login_state->SetLoggedIn(LoginStateWidget::State::LoggedIn);
+  ui_->button_login->setEnabled(true);
+
+}
+
+void DropboxSettingsPage::LoginFailure(const QString &failure_reason) {
+
+  if (!isVisible()) return;
+  QMessageBox::warning(this, tr("Authentication failed"), failure_reason);
+  ui_->button_login->setEnabled(true);
+
+}
+
+void DropboxSettingsPage::ResetClicked() {
+
+  service_->Reset();
+
+}
--- a/src/settings/dropboxsettingspage.h
+++ b/src/settings/dropboxsettingspage.h
@@ -0,0 +1,58 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef DROPBOXSETTINGSPAGE_H
+#define DROPBOXSETTINGSPAGE_H
+
+#include <QObject>
+
+#include "includes/shared_ptr.h"
+#include "settingspage.h"
+
+class DropboxService;
+class Ui_DropboxSettingsPage;
+
+class DropboxSettingsPage : public SettingsPage {
+  Q_OBJECT
+
+ public:
+  explicit DropboxSettingsPage(SettingsDialog *dialog, const SharedPtr<DropboxService> service, QWidget *parent);
+  ~DropboxSettingsPage();
+
+  void Load() override;
+  void Save() override;
+
+  bool eventFilter(QObject *object, QEvent *event) override;
+
+ Q_SIGNALS:
+  void Authorize();
+
+ private Q_SLOTS:
+  void LoginClicked();
+  void LogoutClicked();
+  void LoginSuccess();
+  void LoginFailure(const QString &failure_reason);
+  void ResetClicked();
+
+ private:
+  Ui_DropboxSettingsPage *ui_;
+  const SharedPtr<DropboxService> service_;
+};
+
+#endif  // DROPBOXSETTINGSPAGE_H
--- a/src/settings/dropboxsettingspage.ui
+++ b/src/settings/dropboxsettingspage.ui
@@ -0,0 +1,125 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>DropboxSettingsPage</class>
+ <widget class="QWidget" name="DropboxSettingsPage">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>569</width>
+    <height>491</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dropbox</string>
+  </property>
+  <layout class="QVBoxLayout" name="layout_dropboxsettingspage">
+   <item>
+    <widget class="QLabel" name="label_info">
+     <property name="text">
+      <string>Strawberry can play music that you have uploaded to Dropbox</string>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QCheckBox" name="enable">
+     <property name="text">
+      <string>Enable</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="LoginStateWidget" name="login_state" native="true"/>
+   </item>
+   <item>
+    <widget class="QWidget" name="widget_authorization" native="true">
+     <layout class="QVBoxLayout" name="verticalLayout">
+      <property name="leftMargin">
+       <number>28</number>
+      </property>
+      <property name="topMargin">
+       <number>0</number>
+      </property>
+      <property name="bottomMargin">
+       <number>0</number>
+      </property>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QPushButton" name="button_login">
+          <property name="text">
+           <string>Login</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="spacer_login">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="layout_buttons">
+     <item>
+      <widget class="QPushButton" name="button_reset">
+       <property name="text">
+        <string>Reset cursor and songs</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="spacer_buttons">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <spacer name="spacer_bottom">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>357</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>LoginStateWidget</class>
+   <extends>QWidget</extends>
+   <header>widgets/loginstatewidget.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
--- a/src/settings/settingsdialog.cpp
+++ b/src/settings/settingsdialog.cpp
@@ -90,6 +90,10 @@
 #  include "qobuz/qobuzservice.h"
 #  include "qobuzsettingspage.h"
 #endif
+#ifdef HAVE_DROPBOX
+#  include "dropbox/dropboxservice.h"
+#  include "dropboxsettingspage.h"
+#endif

 #include "ui_settingsdialog.h"

@@ -144,7 +148,7 @@ SettingsDialog::SettingsDialog(const SharedPtr<Player> player,
  AddPage(Page::Moodbar, new MoodbarSettingsPage(this, this), iface);
 #endif

-#if defined(HAVE_SUBSONIC) || defined(HAVE_TIDAL) || defined(HAVE_SPOTIFY) || defined(HAVE_QOBUZ)
+#if defined(HAVE_SUBSONIC) || defined(HAVE_TIDAL) || defined(HAVE_SPOTIFY) || defined(HAVE_QOBUZ) || defined(HAVE_DROPBOX)
  QTreeWidgetItem *streaming = AddCategory(tr("Streaming"));
 #endif

@@ -160,6 +164,9 @@ SettingsDialog::SettingsDialog(const SharedPtr<Player> player,
 #ifdef HAVE_QOBUZ
  AddPage(Page::Qobuz, new QobuzSettingsPage(this, streaming_services->Service<QobuzService>(), this), streaming);
 #endif
+#ifdef HAVE_DROPBOX
+  AddPage(Page::Dropbox, new DropboxSettingsPage(this, streaming_services->Service<DropboxService>(), this), streaming);
+#endif

  // List box
  QObject::connect(ui_->list, &QTreeWidget::currentItemChanged, this, &SettingsDialog::CurrentItemChanged);
--- a/src/settings/settingsdialog.h
+++ b/src/settings/settingsdialog.h
@@ -93,6 +93,8 @@ class SettingsDialog : public QDialog {
    Tidal,
    Qobuz,
    Spotify,
+    Dropbox,
+    OneDrive,
  };

  enum Role {
--- a/src/streaming/cloudstoragestreamingservice.cpp
+++ b/src/streaming/cloudstoragestreamingservice.cpp
@@ -0,0 +1,134 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <memory>
+
+#include <QString>
+#include <QUrl>
+#include <QFileInfo>
+
+#include "core/logging.h"
+#include "core/database.h"
+#include "core/taskmanager.h"
+#include "core/song.h"
+#include "collection/collectionbackend.h"
+#include "collection/collectionmodel.h"
+#include "playlist/playlist.h"
+#include "cloudstoragestreamingservice.h"
+
+using namespace Qt::Literals::StringLiterals;
+using std::make_shared;
+
+CloudStorageStreamingService::CloudStorageStreamingService(const SharedPtr<TaskManager> task_manager,
+                                                           const SharedPtr<Database> database,
+                                                           const SharedPtr<TagReaderClient> tagreader_client,
+                                                           const SharedPtr<AlbumCoverLoader> albumcover_loader,
+                                                           const Song::Source source,
+                                                           const QString &name,
+                                                           const QString &url_scheme,
+                                                           const QString &settings_group,
+                                                           QObject *parent)
+    : StreamingService(source, name, url_scheme, settings_group, parent),
+      task_manager_(task_manager),
+      tagreader_client_(tagreader_client),
+      source_(source),
+      indexing_task_id_(-1),
+      indexing_task_progress_(0),
+      indexing_task_max_(0) {
+
+  collection_backend_ = make_shared<CollectionBackend>();
+  collection_backend_->moveToThread(database->thread());
+  collection_backend_->Init(database, task_manager, source, name + "_songs"_L1);
+  collection_model_ = new CollectionModel(collection_backend_, albumcover_loader, this);
+
+}
+
+void CloudStorageStreamingService::MaybeAddFileToDatabase(const QUrl &url, const QString &filename, const size_t size, const quint64 mtime, const QString &token_type, const QString &access_token) {
+
+  if (!IsSupportedFiletype(filename)) {
+    return;
+  }
+
+  if (indexing_task_id_ == -1) {
+    indexing_task_id_ = task_manager_->StartTask(tr("Indexing %1").arg(name()));
+    indexing_task_progress_ = 0;
+    indexing_task_max_ = 0;
+  }
+  indexing_task_max_++;
+  task_manager_->SetTaskProgress(indexing_task_id_, indexing_task_progress_, indexing_task_max_);
+
+  TagReaderReadStreamReplyPtr reply = tagreader_client_->ReadStreamAsync(url, filename, size, mtime, token_type, access_token);
+  pending_tagreader_replies_.append(reply);
+
+  SharedPtr<QMetaObject::Connection> connection = make_shared<QMetaObject::Connection>();
+  *connection = QObject::connect(&*reply, &TagReaderReadStreamReply::Finished, this, [this, reply, url, filename, connection]() {
+    ReadStreamFinished(reply, url, filename);
+    QObject::disconnect(*connection);
+  }, Qt::QueuedConnection);
+
+}
+
+void CloudStorageStreamingService::ReadStreamFinished(TagReaderReadStreamReplyPtr reply, const QUrl url, const QString filename) {
+
+  ++indexing_task_progress_;
+  if (indexing_task_progress_ >= indexing_task_max_) {
+    task_manager_->SetTaskFinished(indexing_task_id_);
+    indexing_task_id_ = -1;
+    Q_EMIT AllIndexingTasksFinished();
+  }
+  else {
+    task_manager_->SetTaskProgress(indexing_task_id_, indexing_task_progress_, indexing_task_max_);
+  }
+
+  if (!reply->result().success()) {
+    qLog(Error) << "Failed to read tags from stream, URL" << url << reply->result().error_string();
+    return;
+  }
+
+  Song song = reply->song();
+  song.set_source(source_);
+  song.set_directory_id(0);
+  QUrl song_url;
+  song_url.setScheme(url_scheme());
+  song_url.setPath(filename);
+  song.set_url(song_url);
+
+  collection_backend_->AddOrUpdateSongs(SongList() << song);
+
+}
+
+bool CloudStorageStreamingService::IsSupportedFiletype(const QString &filename) {
+
+  const QFileInfo fileinfo(filename);
+  return Song::kAcceptedExtensions.contains(fileinfo.suffix(), Qt::CaseInsensitive) && !Song::kRejectedExtensions.contains(fileinfo.suffix(), Qt::CaseInsensitive);
+
+}
+
+void CloudStorageStreamingService::AbortReadTagsReplies() {
+
+  qLog(Debug) << "Aborting the read tags replies";
+
+  pending_tagreader_replies_.clear();
+
+  task_manager_->SetTaskFinished(indexing_task_id_);
+  indexing_task_id_ = -1;
+
+  Q_EMIT AllIndexingTasksFinished();
+
+}
--- a/src/streaming/cloudstoragestreamingservice.h
+++ b/src/streaming/cloudstoragestreamingservice.h
@@ -0,0 +1,89 @@
+/*
+ * Strawberry Music Player
+ * Copyright 2025, Jonas Kvinge <jonas@jkvinge.net>
+ *
+ * Strawberry is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Strawberry is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Strawberry.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef CLOUDSTORAGESTREAMINGSERVICE_H
+#define CLOUDSTORAGESTREAMINGSERVICE_H
+
+#include <QList>
+
+#include "includes/shared_ptr.h"
+#include "tagreader/tagreaderclient.h"
+#include "streamingservice.h"
+#include "covermanager/albumcovermanager.h"
+#include "collection/collectionmodel.h"
+
+class TaskManager;
+class Database;
+class TagReaderClient;
+class AlbumCoverLoader;
+class CollectionBackend;
+class CollectionModel;
+class NetworkAccessManager;
+
+class CloudStorageStreamingService : public StreamingService {
+  Q_OBJECT
+
+ public:
+  explicit CloudStorageStreamingService(const SharedPtr<TaskManager> task_manager,
+                                        const SharedPtr<Database> database,
+                                        const SharedPtr<TagReaderClient> tagreader_client,
+                                        const SharedPtr<AlbumCoverLoader> albumcover_loader,
+                                        const Song::Source source,
+                                        const QString &name,
+                                        const QString &url_scheme,
+                                        const QString &settings_group,
+                                        QObject *parent = nullptr);
+
+  bool is_indexing() const { return indexing_task_id_ != -1; }
+
+  SharedPtr<CollectionBackend> collection_backend() const { return collection_backend_; }
+  CollectionModel *collection_model() const { return collection_model_; }
+  CollectionFilter *collection_filter_model() const { return collection_model_->filter(); }
+
+  SharedPtr<CollectionBackend> songs_collection_backend() override { return collection_backend_; }
+  CollectionModel *songs_collection_model() override { return collection_model_; }
+  CollectionFilter *songs_collection_filter_model() override { return collection_model_->filter(); }
+
+  virtual void MaybeAddFileToDatabase(const QUrl &url, const QString &filename, const size_t size, const quint64 mtime, const QString &token_type = QString(), const QString &access_token = QString());
+  static bool IsSupportedFiletype(const QString &filename);
+
+ Q_SIGNALS:
+  void AllIndexingTasksFinished();
+
+ protected:
+  void AbortReadTagsReplies();
+
+ protected Q_SLOTS:
+  void ReadStreamFinished(TagReaderReadStreamReplyPtr reply, const QUrl url, const QString filename);
+
+ protected:
+  const SharedPtr<TaskManager> task_manager_;
+  const SharedPtr<TagReaderClient> tagreader_client_;
+  SharedPtr<CollectionBackend> collection_backend_;
+  CollectionModel *collection_model_;
+  QList<TagReaderReplyPtr> pending_tagreader_replies_;
+
+ private:
+  Song::Source source_;
+  int indexing_task_id_;
+  int indexing_task_progress_;
+  int indexing_task_max_;
+};
+
+#endif  // CLOUDSTORAGESTREAMINGSERVICE_H
--- a/src/utilities/coverutils.cpp
+++ b/src/utilities/coverutils.cpp
@@ -142,6 +142,8 @@ QString CoverUtils::CoverFilenameFromSource(const Song::Source source, const QUr
    case Song::Source::Stream:
    case Song::Source::SomaFM:
    case Song::Source::RadioParadise:
+    case Song::Source::Dropbox:
+    case Song::Source::OneDrive:
    case Song::Source::Unknown:
      filename = QString::fromLatin1(Sha1CoverHash(artist, album).toHex());
      break;