source/modules/juce_events/native/juce_linux_Messaging.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library.
   5    Copyright (c) 2022 - Raw Material Software Limited
   6
   7    JUCE is an open source library subject to commercial or open-source
   8    licensing.
   9
  10    The code included in this file is provided under the terms of the ISC license
  11    http://www.isc.org/downloads/software-support-policy/isc-license. Permission
  12    To use, copy, modify, and/or distribute this software for any purpose with or
  13    without fee is hereby granted provided that the above copyright notice and
  14    this permission notice appear in all copies.
  15
  16    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
  17    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
  18    DISCLAIMED.
  19
  20   ==============================================================================
  21 */
  22
  23 namespace juce
  24 {
  25
  26 //==============================================================================
  27 class InternalMessageQueue
  28 {
  29 public:
  30     InternalMessageQueue()
  31     {
  32         auto err = ::socketpair (AF_LOCAL, SOCK_STREAM, 0, msgpipe);
  33         jassertquiet (err == 0);
  34
  35         LinuxEventLoop::registerFdCallback (getReadHandle(),
  36                                             [this] (int fd)
  37                                             {
  38                                                 while (auto msg = popNextMessage (fd))
  39                                                 {
  40                                                     JUCE_TRY
  41                                                     {
  42                                                         msg->messageCallback();
  43                                                     }
  44                                                     JUCE_CATCH_EXCEPTION
  45                                                 }
  46                                             });
  47     }
  48
  49     ~InternalMessageQueue()
  50     {
  51         LinuxEventLoop::unregisterFdCallback (getReadHandle());
  52
  53         close (getReadHandle());
  54         close (getWriteHandle());
  55
  56         clearSingletonInstance();
  57     }
  58
  59     //==============================================================================
  60     void postMessage (MessageManager::MessageBase* const msg) noexcept
  61     {
  62         ScopedLock sl (lock);
  63         queue.add (msg);
  64
  65         if (bytesInSocket < maxBytesInSocketQueue)
  66         {
  67             bytesInSocket++;
  68
  69             ScopedUnlock ul (lock);
  70             unsigned char x = 0xff;
  71             auto numBytes = write (getWriteHandle(), &x, 1);
  72             ignoreUnused (numBytes);
  73         }
  74     }
  75
  76     //==============================================================================
  77     JUCE_DECLARE_SINGLETON (InternalMessageQueue, false)
  78
  79 private:
  80     CriticalSection lock;
  81     ReferenceCountedArray <MessageManager::MessageBase> queue;
  82
  83     int msgpipe[2];
  84     int bytesInSocket = 0;
  85     static constexpr int maxBytesInSocketQueue = 128;
  86
  87     int getWriteHandle() const noexcept  { return msgpipe[0]; }
  88     int getReadHandle() const noexcept   { return msgpipe[1]; }
  89
  90     MessageManager::MessageBase::Ptr popNextMessage (int fd) noexcept
  91     {
  92         const ScopedLock sl (lock);
  93
  94         if (bytesInSocket > 0)
  95         {
  96             --bytesInSocket;
  97
  98             ScopedUnlock ul (lock);
  99             unsigned char x;
 100             auto numBytes = read (fd, &x, 1);
 101             ignoreUnused (numBytes);
 102         }
 103
 104         return queue.removeAndReturn (0);
 105     }
 106 };
 107
 108 JUCE_IMPLEMENT_SINGLETON (InternalMessageQueue)
 109
 110 //==============================================================================
 111 /*
 112     Stores callbacks associated with file descriptors (FD).
 113
 114     The callback for a particular FD should be called whenever that file has data to read.
 115
 116     For standalone apps, the main thread will call poll to wait for new data on any FD, and then
 117     call the associated callbacks for any FDs that changed.
 118
 119     For plugins, the host (generally) provides some kind of run loop mechanism instead.
 120     - In VST2 plugins, the host should call effEditIdle at regular intervals, and plugins can
 121       dispatch all pending events inside this callback. The host doesn't know about any of the
 122       plugin's FDs, so it's possible there will be a bit of latency between an FD becoming ready,
 123       and its associated callback being called.
 124     - In VST3 plugins, it's possible to register each FD individually with the host. In this case,
 125       the facilities in LinuxEventLoopInternal can be used to observe added/removed FD callbacks,
 126       and the host can be notified whenever the set of FDs changes. The host will call onFDIsSet
 127       whenever a particular FD has data ready. This call should be forwarded through to
 128       InternalRunLoop::dispatchEvent.
 129 */
 130 struct InternalRunLoop
 131 {
 132 public:
 133     InternalRunLoop() = default;
 134
 135     void registerFdCallback (int fd, std::function<void()>&& cb, short eventMask)
 136     {
 137         {
 138             const ScopedLock sl (lock);
 139
 140             callbacks.emplace (fd, std::make_shared<std::function<void()>> (std::move (cb)));
 141
 142             const auto iter = getPollfd (fd);
 143
 144             if (iter == pfds.end() || iter->fd != fd)
 145                 pfds.insert (iter, { fd, eventMask, 0 });
 146             else
 147                 jassertfalse;
 148
 149             jassert (pfdsAreSorted());
 150         }
 151
 152         listeners.call ([] (auto& l) { l.fdCallbacksChanged(); });
 153     }
 154
 155     void unregisterFdCallback (int fd)
 156     {
 157         {
 158             const ScopedLock sl (lock);
 159
 160             callbacks.erase (fd);
 161
 162             const auto iter = getPollfd (fd);
 163
 164             if (iter != pfds.end() && iter->fd == fd)
 165                 pfds.erase (iter);
 166             else
 167                 jassertfalse;
 168
 169             jassert (pfdsAreSorted());
 170         }
 171
 172         listeners.call ([] (auto& l) { l.fdCallbacksChanged(); });
 173     }
 174
 175     bool dispatchPendingEvents()
 176     {
 177         callbackStorage.clear();
 178         getFunctionsToCallThisTime (callbackStorage);
 179
 180         // CriticalSection should be available during the callback
 181         for (auto& fn : callbackStorage)
 182             (*fn)();
 183
 184         return ! callbackStorage.empty();
 185     }
 186
 187     void dispatchEvent (int fd) const
 188     {
 189         const auto fn = [&]
 190         {
 191             const ScopedLock sl (lock);
 192             const auto iter = callbacks.find (fd);
 193             return iter != callbacks.end() ? iter->second : nullptr;
 194         }();
 195
 196         // CriticalSection should be available during the callback
 197         if (auto* callback = fn.get())
 198             (*callback)();
 199     }
 200
 201     bool sleepUntilNextEvent (int timeoutMs)
 202     {
 203         const ScopedLock sl (lock);
 204         return poll (pfds.data(), static_cast<nfds_t> (pfds.size()), timeoutMs) != 0;
 205     }
 206
 207     std::vector<int> getRegisteredFds()
 208     {
 209         const ScopedLock sl (lock);
 210         std::vector<int> result;
 211         result.reserve (callbacks.size());
 212         std::transform (callbacks.begin(),
 213                         callbacks.end(),
 214                         std::back_inserter (result),
 215                         [] (const auto& pair) { return pair.first; });
 216         return result;
 217     }
 218
 219     void addListener    (LinuxEventLoopInternal::Listener& listener)         { listeners.add    (&listener); }
 220     void removeListener (LinuxEventLoopInternal::Listener& listener)         { listeners.remove (&listener); }
 221
 222     //==============================================================================
 223     JUCE_DECLARE_SINGLETON (InternalRunLoop, false)
 224
 225 private:
 226     using SharedCallback = std::shared_ptr<std::function<void()>>;
 227
 228     /*  Appends any functions that need to be called to the passed-in vector.
 229
 230         We take a copy of each shared function so that the functions can be called without
 231         locking or racing in the event that the function attempts to register/deregister a
 232         new FD callback.
 233     */
 234     void getFunctionsToCallThisTime (std::vector<SharedCallback>& functions)
 235     {
 236         const ScopedLock sl (lock);
 237
 238         if (! sleepUntilNextEvent (0))
 239             return;
 240
 241         for (auto& pfd : pfds)
 242         {
 243             if (std::exchange (pfd.revents, 0) != 0)
 244             {
 245                 const auto iter = callbacks.find (pfd.fd);
 246
 247                 if (iter != callbacks.end())
 248                     functions.emplace_back (iter->second);
 249             }
 250         }
 251     }
 252
 253     std::vector<pollfd>::iterator getPollfd (int fd)
 254     {
 255         return std::lower_bound (pfds.begin(), pfds.end(), fd, [] (auto descriptor, auto toFind)
 256         {
 257             return descriptor.fd < toFind;
 258         });
 259     }
 260
 261     bool pfdsAreSorted() const
 262     {
 263         return std::is_sorted (pfds.begin(), pfds.end(), [] (auto a, auto b) { return a.fd < b.fd; });
 264     }
 265
 266     CriticalSection lock;
 267
 268     std::map<int, SharedCallback> callbacks;
 269     std::vector<SharedCallback> callbackStorage;
 270     std::vector<pollfd> pfds;
 271
 272     ListenerList<LinuxEventLoopInternal::Listener> listeners;
 273 };
 274
 275 JUCE_IMPLEMENT_SINGLETON (InternalRunLoop)
 276
 277 //==============================================================================
 278 namespace LinuxErrorHandling
 279 {
 280     static bool keyboardBreakOccurred = false;
 281
 282     static void keyboardBreakSignalHandler (int sig)
 283     {
 284         if (sig == SIGINT)
 285             keyboardBreakOccurred = true;
 286     }
 287
 288     static void installKeyboardBreakHandler()
 289     {
 290         struct sigaction saction;
 291         sigset_t maskSet;
 292         sigemptyset (&maskSet);
 293         saction.sa_handler = keyboardBreakSignalHandler;
 294         saction.sa_mask = maskSet;
 295         saction.sa_flags = 0;
 296         sigaction (SIGINT, &saction, nullptr);
 297     }
 298 }
 299
 300 //==============================================================================
 301 void MessageManager::doPlatformSpecificInitialisation()
 302 {
 303     if (JUCEApplicationBase::isStandaloneApp())
 304         LinuxErrorHandling::installKeyboardBreakHandler();
 305
 306     InternalRunLoop::getInstance();
 307     InternalMessageQueue::getInstance();
 308 }
 309
 310 void MessageManager::doPlatformSpecificShutdown()
 311 {
 312     InternalMessageQueue::deleteInstance();
 313     InternalRunLoop::deleteInstance();
 314 }
 315
 316 bool MessageManager::postMessageToSystemQueue (MessageManager::MessageBase* const message)
 317 {
 318     if (auto* queue = InternalMessageQueue::getInstanceWithoutCreating())
 319     {
 320         queue->postMessage (message);
 321         return true;
 322     }
 323
 324     return false;
 325 }
 326
 327 void MessageManager::broadcastMessage (const String&)
 328 {
 329     // TODO
 330 }
 331
 332 // this function expects that it will NEVER be called simultaneously for two concurrent threads
 333 bool dispatchNextMessageOnSystemQueue (bool returnIfNoPendingMessages)
 334 {
 335     for (;;)
 336     {
 337         if (LinuxErrorHandling::keyboardBreakOccurred)
 338             JUCEApplicationBase::quit();
 339
 340         if (auto* runLoop = InternalRunLoop::getInstanceWithoutCreating())
 341         {
 342             if (runLoop->dispatchPendingEvents())
 343                 break;
 344
 345             if (returnIfNoPendingMessages)
 346                 return false;
 347
 348             runLoop->sleepUntilNextEvent (2000);
 349         }
 350     }
 351
 352     return true;
 353 }
 354
 355 //==============================================================================
 356 void LinuxEventLoop::registerFdCallback (int fd, std::function<void (int)> readCallback, short eventMask)
 357 {
 358     if (auto* runLoop = InternalRunLoop::getInstanceWithoutCreating())
 359         runLoop->registerFdCallback (fd, [cb = std::move (readCallback), fd] { cb (fd); }, eventMask);
 360 }
 361
 362 void LinuxEventLoop::unregisterFdCallback (int fd)
 363 {
 364     if (auto* runLoop = InternalRunLoop::getInstanceWithoutCreating())
 365         runLoop->unregisterFdCallback (fd);
 366 }
 367
 368 //==============================================================================
 369 void LinuxEventLoopInternal::registerLinuxEventLoopListener (LinuxEventLoopInternal::Listener& listener)
 370 {
 371     if (auto* runLoop = InternalRunLoop::getInstanceWithoutCreating())
 372         runLoop->addListener (listener);
 373 }
 374
 375 void LinuxEventLoopInternal::deregisterLinuxEventLoopListener (LinuxEventLoopInternal::Listener& listener)
 376 {
 377     if (auto* runLoop = InternalRunLoop::getInstanceWithoutCreating())
 378         runLoop->removeListener (listener);
 379 }
 380
 381 void LinuxEventLoopInternal::invokeEventLoopCallbackForFd (int fd)
 382 {
 383     if (auto* runLoop = InternalRunLoop::getInstanceWithoutCreating())
 384         runLoop->dispatchEvent (fd);
 385 }
 386
 387 std::vector<int> LinuxEventLoopInternal::getRegisteredFds()
 388 {
 389     if (auto* runLoop = InternalRunLoop::getInstanceWithoutCreating())
 390         return runLoop->getRegisteredFds();
 391
 392     return {};
 393 }
 394
 395 } // namespace juce