gecko-dev/dom/midi/MIDIPlatformService.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "MIDIPlatformService.h"
#include "TestMIDIPlatformService.h"
#include "mozilla/Unused.h"
#include "mozilla/dom/PMIDIManagerParent.h"
#include "mozilla/ipc/BackgroundParent.h"
#include "mozilla/dom/MIDIPortParent.h"

using namespace mozilla;
using namespace mozilla::dom;


MIDIPlatformService::MIDIPlatformService() :
  mHasSentPortList(false),
  mMessageQueueMutex("MIDIPlatformServce::mMessageQueueMutex")
{
}

MIDIPlatformService::~MIDIPlatformService()
{
}

void
MIDIPlatformService::CheckAndReceive(const nsAString& aPortId,
                                     const nsTArray<MIDIMessage>& aMsgs)
{
  AssertIsOnBackgroundThread();
  for (auto& port : mPorts) {
    // TODO Clean this up when we split input/output port arrays
    if (port->MIDIPortInterface::Id() != aPortId ||
        port->Type() != MIDIPortType::Input ||
        port->ConnectionState() != MIDIPortConnectionState::Open) {
      continue;
    }
    if (!port->SysexEnabled()) {
      nsTArray<MIDIMessage> msgs;
      for (auto& msg : aMsgs) {
        if (!MIDIUtils::IsSysexMessage(msg)) {
          msgs.AppendElement(msg);
        }
      }
      Unused << port->SendReceive(msgs);
    } else {
      Unused << port->SendReceive(aMsgs);
    }
  }
}

void
MIDIPlatformService::AddPort(MIDIPortParent* aPort)
{
  MOZ_ASSERT(aPort);
  AssertIsOnBackgroundThread();
  mPorts.AppendElement(aPort);
}

void
MIDIPlatformService::RemovePort(MIDIPortParent* aPort)
{
  // This should only be called from the background thread, when a MIDIPort
  // actor has been destroyed.
  AssertIsOnBackgroundThread();
  MOZ_ASSERT(aPort);
  mPorts.RemoveElement(aPort);
  MaybeStop();
}

void
MIDIPlatformService::BroadcastState(const MIDIPortInfo& aPortInfo,
                                    const MIDIPortDeviceState& aState)
{
  AssertIsOnBackgroundThread();
  for (auto& p : mPorts) {
    if (p->MIDIPortInterface::Id() == aPortInfo.id() &&
        p->DeviceState() != aState) {
      p->SendUpdateStatus(aState, p->ConnectionState());
    }
  }
}

void
MIDIPlatformService::QueueMessages(const nsAString& aId, nsTArray<MIDIMessage>& aMsgs)
{
  AssertIsOnBackgroundThread();
  {
    MutexAutoLock lock(mMessageQueueMutex);
    MIDIMessageQueue* msgQueue = mMessageQueues.LookupOrAdd(aId);
    msgQueue->Add(aMsgs);
    ScheduleSend(aId);
  }
}

void
MIDIPlatformService::SendPortList()
{
  AssertIsOnBackgroundThread();
  mHasSentPortList = true;
  MIDIPortList l;
  for (auto& el : mPortInfo) {
    l.ports().AppendElement(el);
  }
  for (auto& mgr : mManagers) {
    Unused << mgr->SendMIDIPortListUpdate(l);
  }
}

void
MIDIPlatformService::Clear(MIDIPortParent* aPort)
{
  AssertIsOnBackgroundThread();
  MOZ_ASSERT(aPort);
  {
    MutexAutoLock lock(mMessageQueueMutex);
    MIDIMessageQueue* msgQueue = mMessageQueues.Get(aPort->MIDIPortInterface::Id());
    if (msgQueue) {
      msgQueue->Clear();
    }
  }
}

void
MIDIPlatformService::AddPortInfo(MIDIPortInfo& aPortInfo)
{
  AssertIsOnBackgroundThread();
  MOZ_ASSERT(XRE_IsParentProcess());

  mPortInfo.AppendElement(aPortInfo);

  // ORDER MATTERS HERE.
  //
  // When MIDI hardware is disconnected, all open MIDIPort objects revert to a
  // "pending" state, and they are removed from the port maps of MIDIAccess
  // objects. We need to send connection updates to all living ports first, THEN
  // we can send port list updates to all of the live MIDIAccess objects. We
  // have to go in this order because if a port object is still held live but is
  // disconnected, it needs to readd itself to its originating MIDIAccess object.
  // Running SendPortList first would cause MIDIAccess to create a new MIDIPort
  // object, which would conflict (i.e. old disconnected object != new object in
  // port map, which is against spec).
  for (auto& port : mPorts) {
    if (port->MIDIPortInterface::Id() == aPortInfo.id()) {
      port->SendUpdateStatus(MIDIPortDeviceState::Connected,
                             port->ConnectionState());
    }
  }
  if (mHasSentPortList) {
    SendPortList();
  }
}

void
MIDIPlatformService::RemovePortInfo(MIDIPortInfo& aPortInfo)
{
  AssertIsOnBackgroundThread();
  mPortInfo.RemoveElement(aPortInfo);
  BroadcastState(aPortInfo, MIDIPortDeviceState::Disconnected);
  if (mHasSentPortList) {
    SendPortList();
  }
}

StaticRefPtr<MIDIPlatformService> gMIDIPlatformService;

//static
bool
MIDIPlatformService::IsRunning()
{
  return gMIDIPlatformService != nullptr;
}

void
MIDIPlatformService::Close(mozilla::dom::MIDIPortParent *aPort)
{
  AssertIsOnBackgroundThread();
  {
    MutexAutoLock lock(mMessageQueueMutex);
    MIDIMessageQueue* msgQueue = mMessageQueues.Get(aPort->MIDIPortInterface::Id());
    if (msgQueue) {
      msgQueue->ClearAfterNow();
    }
  }
  // Send all messages before sending a close request
  ScheduleSend(aPort->MIDIPortInterface::Id());
  // TODO We should probably have the send function schedule closing
  ScheduleClose(aPort);
}

//static
MIDIPlatformService*
MIDIPlatformService::Get()
{
  // We should never touch the platform service in a child process.
  MOZ_ASSERT(XRE_IsParentProcess());
  AssertIsOnBackgroundThread();
  if (!IsRunning()) {
    ErrorResult rv;
    // Uncomment once we have an actual platform library to test.
    //
    // bool useTestService = false;
    // rv = Preferences::GetRootBranch()->GetBoolPref("midi.testing", &useTestService);
    gMIDIPlatformService = new TestMIDIPlatformService();
    gMIDIPlatformService->Init();
  }
  return gMIDIPlatformService;
}

void
MIDIPlatformService::MaybeStop()
{
  AssertIsOnBackgroundThread();
  if (!IsRunning()) {
    // Service already stopped or never started. Exit.
    return;
  }
  // If we have any ports or managers left, we should still be alive.
  if (!mPorts.IsEmpty() ||
      !mManagers.IsEmpty()) {
    return;
  }
  Stop();
  gMIDIPlatformService = nullptr;
}

void
MIDIPlatformService::AddManager(MIDIManagerParent* aManager)
{
  AssertIsOnBackgroundThread();
  mManagers.AppendElement(aManager);
  // Managers add themselves during construction. We have to wait for the protocol
  // construction to finish before we send them a port list. The runnable calls
  // SendPortList, which iterates through the live manager list, so this saves
  // us from having to worry about Manager pointer validity at time of runnable
  // execution.
  nsCOMPtr<nsIRunnable> r(new SendPortListRunnable());
  NS_DispatchToCurrentThread(r);
}

void
MIDIPlatformService::RemoveManager(MIDIManagerParent* aManager)
{
  AssertIsOnBackgroundThread();
  mManagers.RemoveElement(aManager);
  MaybeStop();
}

void
MIDIPlatformService::UpdateStatus(const nsAString& aPortId,
                                  const MIDIPortDeviceState& aDeviceState,
                                  const MIDIPortConnectionState& aConnectionState)
{
  AssertIsOnBackgroundThread();
  for (auto port : mPorts) {
    if (port->MIDIPortInterface::Id() == aPortId) {
      port->SendUpdateStatus(aDeviceState, aConnectionState);
    }
  }
}

void
MIDIPlatformService::GetMessages(const nsAString& aPortId,
                                 nsTArray<MIDIMessage>& aMsgs)
{
  // Can run on either background thread or platform specific IO Thread.
  {
    MutexAutoLock lock(mMessageQueueMutex);
    MIDIMessageQueue* msgQueue;
    if (!mMessageQueues.Get(aPortId, &msgQueue)) {
      return;
    }
    msgQueue->GetMessages(aMsgs);
  }
}

void
MIDIPlatformService::GetMessagesBefore(const nsAString& aPortId,
                                       const TimeStamp& aTimeStamp,
                                       nsTArray<MIDIMessage>& aMsgs)
{
  // Can run on either background thread or platform specific IO Thread.
  {
    MutexAutoLock lock(mMessageQueueMutex);
    MIDIMessageQueue* msgQueue;
    if (!mMessageQueues.Get(aPortId, &msgQueue)) {
      return;
    }
    msgQueue->GetMessagesBefore(aTimeStamp, aMsgs);
  }
}