Web MIDI: make MidiManagerMac notify device connections

media/midi/midi_manager_mac.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/midi/midi_manager_mac.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 
 #include <CoreAudio/HostTime.h>
 
 using base::IntToString;
 using base::SysCFStringRefToUTF8;
 using std::string;
 
 // NB: System MIDI types are pointer types in 32-bit and integer types in
 // 64-bit. Therefore, the initialization is the simplest one that satisfies both
 // (if possible).
 
 namespace media {
 
 namespace {
 
-MidiPortInfo GetPortInfoFromEndpoint(
-    MIDIEndpointRef endpoint) {
+MidiPortInfo GetPortInfoFromEndpoint(const MIDIEndpointRef endpoint) {

[yhirano, 2014/10/24 03:30:08]

What does this const mean?

[Takashi Toyoshima, 2015/02/17 17:10:38]

reverted

   SInt32 id_number = 0;
   MIDIObjectGetIntegerProperty(endpoint, kMIDIPropertyUniqueID, &id_number);
   string id = IntToString(id_number);
 
   string manufacturer;
   CFStringRef manufacturer_ref = NULL;
   OSStatus result = MIDIObjectGetStringProperty(
       endpoint, kMIDIPropertyManufacturer, &manufacturer_ref);
   if (result == noErr) {
     manufacturer = SysCFStringRefToUTF8(manufacturer_ref);
@@ skipping 18 matching lines @@
       endpoint, kMIDIPropertyDriverVersion, &version_number);
   if (result == noErr) {
     version = IntToString(version_number);
   } else {
     // kMIDIPropertyDriverVersion is not supported in IAC driver providing
     // endpoints, and the result will be kMIDIUnknownProperty (-10835).
     DLOG(WARNING) << "Failed to get kMIDIPropertyDriverVersion with status "
                   << result;
   }
 
-  return MidiPortInfo(id, manufacturer, name, version);
+  const bool connected = true;
+  return MidiPortInfo(id, manufacturer, name, version, connected);
 }
 
 double MIDITimeStampToSeconds(MIDITimeStamp timestamp) {
   UInt64 nanoseconds = AudioConvertHostTimeToNanos(timestamp);
   return static_cast<double>(nanoseconds) / 1.0e9;
 }
 
 MIDITimeStamp SecondsToMIDITimeStamp(double seconds) {
   UInt64 nanos = UInt64(seconds * 1.0e9);
   return AudioConvertNanosToHostTime(nanos);
@@ skipping 54 matching lines @@
   client_thread_.message_loop()->PostTask(FROM_HERE, closure);
 }
 
 void MidiManagerMac::InitializeCoreMIDI() {
   DCHECK(client_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   // CoreMIDI registration.
   // TODO(toyoshim): Set MIDINotifyProc to receive CoreMIDI event notifications.
   midi_client_ = 0;
   OSStatus result =
-      MIDIClientCreate(CFSTR("Chrome"), NULL, NULL, &midi_client_);
+      MIDIClientCreate(CFSTR("Chrome"), ReceiveMidiNotifyDispatch, this,
+                       &midi_client_);
 
   if (result != noErr)
     return CompleteInitialization(MIDI_INITIALIZATION_ERROR);
 
   coremidi_input_ = 0;
 
   // Create input and output port.
   result = MIDIInputPortCreate(
       midi_client_,
       CFSTR("MIDI Input"),
@@ skipping 39 matching lines @@
     AddInputPort(info);
   }
 
   packet_list_ = reinterpret_cast<MIDIPacketList*>(midi_buffer_);
   midi_packet_ = MIDIPacketListInit(packet_list_);
 
   CompleteInitialization(MIDI_OK);
 }
 
 // static
+void MidiManagerMac::ReceiveMidiNotifyDispatch(const MIDINotification* message,
+                                               void* refcon) {
+  MidiManagerMac* manager = static_cast<MidiManagerMac*>(refcon);
+  manager->ReceiveMidiNotify(message);
+}
+
+void MidiManagerMac::ReceiveMidiNotify(const MIDINotification* message) {
+  DCHECK(client_thread_.message_loop_proxy()->BelongsToCurrentThread());
+
+  if (kMIDIMsgObjectAdded == message->messageID) {
+    const MIDIObjectAddRemoveNotification* notification =
+        reinterpret_cast<const MIDIObjectAddRemoveNotification*>(message);
+    MIDIEndpointRef endpoint =
+        static_cast<MIDIEndpointRef>(notification->child);
+    if (notification->childType == kMIDIObjectType_Source) {
+      SourceMap::iterator it = source_map_.find(endpoint);
+      if (it == source_map_.end()) {
+        uint32 index = source_map_.size();
+        source_map_[endpoint] = index;
+        MidiPortInfo info = GetPortInfoFromEndpoint(endpoint);
+        AddInputPort(info);
+      } else {
+        uint32 index = source_map_[endpoint];
+        SetInputPortState(index, true);
+      }
+    } else if (notification->childType == kMIDIObjectType_Destination) {
+      bool found = false;
+      for (uint32 i = 0; i < destinations_.size(); ++i) {

[yhirano, 2014/10/24 03:30:08]

You can use std::find.

[palmer, 2014/10/24 19:07:14]

Yes, std::find.

[Takashi Toyoshima, 2015/02/17 17:10:37]

But, I need to use the index i for SetOutputPortState() at line 235.

[yhirano, 2015/02/18 03:21:25]

Year, and you can use it:

auto i = std::find(...);
if (i != destinations_.end()) {
  SetOutputPortState(i - destinations_.begin(), MIDI_PORT_OPENED);
} else {
  ...
}

[Takashi Toyoshima, 2015/02/18 04:43:13]

Oh, great. Sorry, I did't know this usage. thanks!

+        if (destinations_[i] != endpoint)
+          continue;
+        found = true;
+        SetOutputPortState(i, true);
+        break;
+      }
+      if (!found) {
+        destinations_.push_back(endpoint);
+        MidiPortInfo info = GetPortInfoFromEndpoint(endpoint);
+        AddOutputPort(info);
+      }
+    }
+  } else if (kMIDIMsgObjectRemoved == message->messageID) {
+    const MIDIObjectAddRemoveNotification* notification =
+        reinterpret_cast<const MIDIObjectAddRemoveNotification*>(message);
+    MIDIEndpointRef endpoint =
+        static_cast<MIDIEndpointRef>(notification->child);
+    if (notification->childType == kMIDIObjectType_Source) {
+      SourceMap::iterator it = source_map_.find(endpoint);
+      if (it != source_map_.end()) {
+        uint32 index = source_map_[endpoint];
+        SetInputPortState(index, false);
+      }
+    } else if (notification->childType == kMIDIObjectType_Destination) {
+      for (uint32 i = 0; i < destinations_.size(); ++i) {

[yhirano, 2014/10/24 03:30:08]

ditto

[Takashi Toyoshima, 2015/02/17 17:10:38]

same reason

+        if (destinations_[i] != endpoint)
+          continue;
+        SetOutputPortState(i, false);
+        break;
+      }
+    }
+  }
+}
+
+// static
 void MidiManagerMac::ReadMidiDispatch(const MIDIPacketList* packet_list,
                                       void* read_proc_refcon,
                                       void* src_conn_refcon) {
   // This method is called on a separate high-priority thread owned by CoreMIDI.
 
   MidiManagerMac* manager = static_cast<MidiManagerMac*>(read_proc_refcon);
 #if __LP64__
   MIDIEndpointRef source = reinterpret_cast<uintptr_t>(src_conn_refcon);
 #else
   MIDIEndpointRef source = static_cast<MIDIEndpointRef>(src_conn_refcon);
@@ skipping 55 matching lines @@
 
   MIDISend(coremidi_output_, destination, packet_list_);
 
   // Re-initialize for next time.
   midi_packet_ = MIDIPacketListInit(packet_list_);
 
   client->AccumulateMidiBytesSent(data.size());
 }
 
 }  // namespace media