blob: 9704a3ef2c2f906d445df2747123b0a0935663a8 [file] [log] [blame]
// Copyright 2014 The Chromium Authors
// 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_android.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/metrics/field_trial_params.h"
#include "base/strings/stringprintf.h"
#include "media/midi/midi_device_android.h"
#include "media/midi/midi_jni_headers/MidiManagerAndroid_jni.h"
#include "media/midi/midi_manager_usb.h"
#include "media/midi/midi_output_port_android.h"
#include "media/midi/midi_service.h"
#include "media/midi/midi_switches.h"
#include "media/midi/task_service.h"
#include "media/midi/usb_midi_device_factory_android.h"
using base::android::JavaParamRef;
using midi::mojom::PortState;
using midi::mojom::Result;
namespace midi {
namespace {
bool HasSystemFeatureMidi() {
// Check if the MIDI service actually runs on the system.
return Java_MidiManagerAndroid_hasSystemFeatureMidi(
jni_zero::AttachCurrentThread());
}
} // namespace
MidiManager* MidiManager::Create(MidiService* service) {
if (HasSystemFeatureMidi())
return new MidiManagerAndroid(service);
return new MidiManagerUsb(service,
std::make_unique<UsbMidiDeviceFactoryAndroid>());
}
MidiManagerAndroid::MidiManagerAndroid(MidiService* service)
: MidiManager(service) {}
MidiManagerAndroid::~MidiManagerAndroid() {
if (!service()->task_service()->UnbindInstance())
return;
// Finalization steps should be implemented after the UnbindInstance() call.
JNIEnv* env = jni_zero::AttachCurrentThread();
Java_MidiManagerAndroid_stop(env, raw_manager_);
}
void MidiManagerAndroid::StartInitialization() {
if (!service()->task_service()->BindInstance())
return CompleteInitialization(Result::INITIALIZATION_ERROR);
JNIEnv* env = jni_zero::AttachCurrentThread();
uintptr_t pointer = reinterpret_cast<uintptr_t>(this);
raw_manager_.Reset(Java_MidiManagerAndroid_create(env, pointer));
Java_MidiManagerAndroid_initialize(env, raw_manager_);
}
void MidiManagerAndroid::DispatchSendMidiData(MidiManagerClient* client,
uint32_t port_index,
const std::vector<uint8_t>& data,
base::TimeTicks timestamp) {
if (port_index >= all_output_ports_.size()) {
// |port_index| is provided by a renderer so we can't believe that it is
// in the valid range.
return;
}
if (GetOutputPortState(port_index) == PortState::CONNECTED) {
// We treat send call as implicit open.
// TODO(yhirano): Implement explicit open operation from the renderer.
if (all_output_ports_[port_index]->Open()) {
SetOutputPortState(port_index, PortState::OPENED);
} else {
// We cannot open the port. It's useless to send data to such a port.
return;
}
}
// output_streams_[port_index] is alive unless MidiManagerAndroid is deleted.
// The task posted to the TaskService will be disposed safely after unbinding
// the service.
base::TimeDelta delay = MidiService::TimestampToTimeDeltaDelay(timestamp);
service()->task_service()->PostBoundDelayedTask(
TaskService::kDefaultRunnerId,
base::BindOnce(&MidiOutputPortAndroid::Send,
base::Unretained(all_output_ports_[port_index]), data),
delay);
service()->task_service()->PostBoundDelayedTask(
TaskService::kDefaultRunnerId,
base::BindOnce(&MidiManagerAndroid::AccumulateMidiBytesSent,
base::Unretained(this), client, data.size()),
delay);
}
void MidiManagerAndroid::OnReceivedData(MidiInputPortAndroid* port,
const uint8_t* data,
size_t size,
base::TimeTicks timestamp) {
const auto i = input_port_to_index_.find(port);
DCHECK(input_port_to_index_.end() != i);
ReceiveMidiData(i->second, data, size, timestamp);
}
void MidiManagerAndroid::OnInitialized(
JNIEnv* env,
const JavaParamRef<jobjectArray>& devices) {
for (auto raw_device : devices.ReadElements<jobject>()) {
AddDevice(std::make_unique<MidiDeviceAndroid>(env, raw_device, this));
}
service()->task_service()->PostBoundTask(
TaskService::kDefaultRunnerId,
base::BindOnce(&MidiManagerAndroid::CompleteInitialization,
base::Unretained(this), Result::OK));
}
void MidiManagerAndroid::OnInitializationFailed(JNIEnv* env) {
service()->task_service()->PostBoundTask(
TaskService::kDefaultRunnerId,
base::BindOnce(&MidiManagerAndroid::CompleteInitialization,
base::Unretained(this), Result::INITIALIZATION_ERROR));
}
void MidiManagerAndroid::OnAttached(JNIEnv* env,
const JavaParamRef<jobject>& raw_device) {
AddDevice(std::make_unique<MidiDeviceAndroid>(env, raw_device, this));
}
void MidiManagerAndroid::OnDetached(JNIEnv* env,
const JavaParamRef<jobject>& raw_device) {
for (auto& device : devices_) {
if (device->HasRawDevice(env, raw_device)) {
for (auto& port : device->input_ports()) {
DCHECK(input_port_to_index_.end() !=
input_port_to_index_.find(port.get()));
size_t index = input_port_to_index_[port.get()];
SetInputPortState(index, PortState::DISCONNECTED);
}
for (auto& port : device->output_ports()) {
DCHECK(output_port_to_index_.end() !=
output_port_to_index_.find(port.get()));
size_t index = output_port_to_index_[port.get()];
SetOutputPortState(index, PortState::DISCONNECTED);
}
}
}
}
void MidiManagerAndroid::AddDevice(std::unique_ptr<MidiDeviceAndroid> device) {
for (auto& port : device->input_ports()) {
// We implicitly open input ports here, because there are no signal
// from the renderer when to open.
// TODO(yhirano): Implement open operation in Blink.
PortState state = port->Open() ? PortState::OPENED : PortState::CONNECTED;
const size_t index = all_input_ports_.size();
all_input_ports_.push_back(port.get());
// Port ID must be unique in a MIDI manager. This ID setting is
// sufficiently unique although there is no user-friendly meaning.
// TODO(yhirano): Use a hashed string as ID.
const std::string id(
base::StringPrintf("native:port-in-%ld", static_cast<long>(index)));
input_port_to_index_.insert(std::make_pair(port.get(), index));
AddInputPort(mojom::PortInfo(id, device->GetManufacturer(),
device->GetProductName(),
device->GetDeviceVersion(), state));
}
for (auto& port : device->output_ports()) {
const size_t index = all_output_ports_.size();
all_output_ports_.push_back(port.get());
// Port ID must be unique in a MIDI manager. This ID setting is
// sufficiently unique although there is no user-friendly meaning.
// TODO(yhirano): Use a hashed string as ID.
const std::string id(
base::StringPrintf("native:port-out-%ld", static_cast<long>(index)));
output_port_to_index_.insert(std::make_pair(port.get(), index));
AddOutputPort(
mojom::PortInfo(id, device->GetManufacturer(), device->GetProductName(),
device->GetDeviceVersion(), PortState::CONNECTED));
}
devices_.push_back(std::move(device));
}
} // namespace midi