openharmony/midi_framework
1
0
Fork 0
mirror of https://github.com/openharmony/midi_framework.git synced 2026-06-30 22:17:53 -04:00
Code Issues Packages Projects Releases Wiki Activity

hdi

Browse Source 
Signed-off-by: 蒋志庆 <jiangzhiqing4@h-partners.com>
This commit is contained in:
蒋志庆
2025-12-30 14:56:03 +08:00
parent 8f9d631bdf
commit a59ef7845c
12 changed files with 61 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
frameworks/native/midi/include/midi_client_private.h
+1 -1
View File
@@ -36,7 +36,7 @@ public:
virtual ~MidiClientPrivate();
OH_MidiStatusCode Init(OH_MidiCallbacks callbacks, void *userData) override;
OH_MidiStatusCode GetDevices(OH_MidiDeviceInformation *infos, size_t *numDevices) override;
OH_MidiStatusCode OpenDevice(int64_t deviceId, MidiDevice *midiDevice) override;
OH_MidiStatusCode OpenDevice(int64_t deviceId, MidiDevice **midiDevice) override;
OH_MidiStatusCode GetDevicePorts(int64_t deviceId, OH_MidiPortInformation *infos, size_t *numPorts) override;
OH_MidiStatusCode DestroyMidiClient() override;
private:
frameworks/native/midi/src/midi_client.cpp
+6 -5
View File
@@ -174,20 +174,20 @@ OH_MidiStatusCode MidiClientPrivate::GetDevices(OH_MidiDeviceInformation *infos,
return MIDI_STATUS_OK;
}
OH_MidiStatusCode MidiClientPrivate::OpenDevice(int64_t deviceId, MidiDevice *midiDevice)
OH_MidiStatusCode MidiClientPrivate::OpenDevice(int64_t deviceId, MidiDevice **midiDevice)
{
CHECK_AND_RETURN_RET_LOG(midiDevice != nullptr, MIDI_STATUS_UNKNOWN_ERROR, "midiDevice is nullptr");
std::lock_guard<std::mutex> lock(mutex_);
auto ret = ipc_->OpenDevice(deviceId);
CHECK_AND_RETURN_RET(ret == MIDI_STATUS_OK, ret);
auto newDevice = new MidiDevicePrivate(ipc_, deviceId);
midiDevice = newDevice;
*midiDevice = newDevice;
MIDI_INFO_LOG("Device opened: %{public}" PRId64, deviceId);
return MIDI_STATUS_OK;
}
OH_MidiStatusCode MidiClientPrivate::GetDevicePorts(int64_t deviceId, OH_MidiPortInformation *infos, size_t *numPorts)
{
std::lock_guard<std::mutex> lock(mutex_);
std::vector<std::map<int32_t, std::string>> portInfos;
auto ret = ipc_->GetDevicePorts(deviceId, portInfos);
@@ -214,14 +214,15 @@ OH_MidiStatusCode MidiClientPrivate::DestroyMidiClient()
return ipc_->DestroyMidiClient();
}
OH_MidiStatusCode MidiClient::CreateMidiClient(MidiClient *client, OH_MidiCallbacks callbacks, void *userData)
OH_MidiStatusCode MidiClient::CreateMidiClient(MidiClient **client, OH_MidiCallbacks callbacks, void *userData)
{
CHECK_AND_RETURN_RET_LOG(client != nullptr, MIDI_STATUS_UNKNOWN_ERROR, "client is nullptr");
std::lock_guard<std::mutex> lock(clientsMutex);
auto midiClient = std::make_unique<MidiClientPrivate>();
OH_MidiStatusCode ret = midiClient->Init(callbacks, userData);
CHECK_AND_RETURN_RET(ret == MIDI_STATUS_OK, ret);
clients.push_back(std::move(midiClient));
client = clients.back().get();
*client = clients.back().get();
return MIDI_STATUS_OK;
}
} // namespace MIDI
frameworks/native/ohmidi/OHMidi.cpp
+2 -4
View File
@@ -22,7 +22,7 @@ OH_MidiStatusCode OH_MidiClient_Create(OH_MidiClient **client, OH_MidiCallbacks
CHECK_AND_RETURN_RET_LOG(client != nullptr,
MIDI_STATUS_GENERIC_INVALID_ARGUMENT,"client is nullptr");
OHOS::MIDI::MidiClient *midiclient = nullptr;
OH_MidiStatusCode ret = OHOS::MIDI::MidiClient::CreateMidiClient(midiclient, callbacks, userData);
OH_MidiStatusCode ret = OHOS::MIDI::MidiClient::CreateMidiClient(&midiclient, callbacks, userData);
CHECK_AND_RETURN_RET_LOG(ret == MIDI_STATUS_OK, ret, "CreateMidiClient falid");
*client = (OH_MidiClient*)midiclient;
return MIDI_STATUS_OK;
@@ -36,7 +36,6 @@ OH_MidiStatusCode OH_MidiClient_Destroy(OH_MidiClient *client)
OH_MidiStatusCode ret = midiclient->DestroyMidiClient();
CHECK_AND_RETURN_RET_LOG(ret == MIDI_STATUS_OK, ret, "DestroyMidiClient falid");
delete midiclient;
client = nullptr;
return MIDI_STATUS_OK;
}
@@ -57,7 +56,7 @@ OH_MidiStatusCode OH_MidiOpenDevice(OH_MidiClient *client, int64_t deviceId, OH_
MIDI_STATUS_GENERIC_INVALID_ARGUMENT,"Invalid parameter");
OHOS::MIDI::MidiDevice *midiDevice = nullptr;
OH_MidiStatusCode ret = midiclient->OpenDevice(deviceId, midiDevice);
OH_MidiStatusCode ret = midiclient->OpenDevice(deviceId, &midiDevice);
CHECK_AND_RETURN_RET_LOG(ret == MIDI_STATUS_OK, ret, "OpenDevice falid");
*device = (OH_MidiDevice*) midiDevice;
@@ -79,7 +78,6 @@ OH_MidiStatusCode OH_MidiCloseDevice(OH_MidiDevice *device)
OH_MidiStatusCode ret = midiDevice->CloseDevice();
CHECK_AND_RETURN_RET_LOG(ret == MIDI_STATUS_OK, ret, "CloseDevice falid");
delete midiDevice;
device = nullptr;
return MIDI_STATUS_OK;
}
interfaces/inner_api/native/midi_client.h
+2 -2
View File
@@ -28,10 +28,10 @@ public:
class MidiClient {
public:
virtual ~MidiClient() = default;
static OH_MidiStatusCode CreateMidiClient(MidiClient *client, OH_MidiCallbacks callbacks, void *userData);
static OH_MidiStatusCode CreateMidiClient(MidiClient **client, OH_MidiCallbacks callbacks, void *userData);
virtual OH_MidiStatusCode Init(OH_MidiCallbacks callbacks, void *userData);
virtual OH_MidiStatusCode GetDevices(OH_MidiDeviceInformation *infos, size_t *numDevices);
virtual OH_MidiStatusCode OpenDevice(int64_t deviceId, MidiDevice *midiDevice);
virtual OH_MidiStatusCode OpenDevice(int64_t deviceId, MidiDevice **midiDevice);
virtual OH_MidiStatusCode GetDevicePorts(int64_t deviceId, OH_MidiPortInformation *infos, size_t *numPorts);
virtual OH_MidiStatusCode DestroyMidiClient();
};
interfaces/midi_info.h
+3 -3
View File
@@ -60,8 +60,8 @@ enum TransportProtocol {
struct PortInformation {
int64_t portId;
PortDirection direction;
std::string name;
PortDirection direction;
TransportProtocol transportProtocol;
};
@@ -70,8 +70,8 @@ struct DeviceInformation{
int64_t driverDeviceId;
DeviceType deviceType;
TransportProtocol transportProtocol;
char productName[256];
char vendorName[256];
std::string productName;
std::string vendorName;
std::vector<PortInformation> portInfos;
DeviceInformation() : deviceId(0), deviceType(DeviceType::DEVICE_TYPE_USB) {}
};
sa_profile/midi_server.json
+1 -1
View File
@@ -4,7 +4,7 @@
{
"name": 3014,
"libpath": "libmidi_service.z.so",
"run-on-create": true,
"run-on-create": false,
"distributed": false,
"start-on-demand": {
"allow-update": false
services/BUILD.gn
+2 -1
View File
@@ -77,7 +77,8 @@ ohos_shared_library("midi_service") {
"safwk:system_ability_fwk",
"samgr:samgr_proxy",
"common_event_service:cesfwk_innerkits",
"usb_manager:usbsrv_client"
"usb_manager:usbsrv_client",
"drivers_interface_midi:libmidi_proxy_1.0"
]
cflags_cc = [ "-std=c++20" ]
services/server/include/midi_device_driver.h
+3 -5
View File
@@ -24,13 +24,11 @@ public:
virtual std::vector<DeviceInformation> GetRegisteredDevices() = 0;
virtual std::vector<PortInformation> GetPortsForDevice(int64_t deviceId) = 0;
virtual int32_t OpenDevice(int64_t deviceId) = 0;
virtual bool OpenDevice(int64_t deviceId) = 0;
virtual int32_t CloseDevice(int64_t deviceId) = 0;
virtual bool CloseDevice(int64_t deviceId) = 0;
virtual bool HanleUmpInput(int64_t deviceId, size_t portIndex, MidiEvent list) = 0;
virtual int32_t HanleUmpInput(int64_t deviceId, size_t portIndex, MidiEvent list) = 0;
};
}
services/server/include/midi_device_usb.h
+4 -6
View File
@@ -29,15 +29,13 @@ public:
std::vector<DeviceInformation> GetRegisteredDevices() override;
std::vector<PortInformation> GetPortsForDevice(int64_t deviceId) override;
int32_t OpenDevice(int64_t deviceId) override;
bool OpenDevice(int64_t deviceId) override;
int32_t CloseDevice(int64_t deviceId) override;
bool CloseDevice(int64_t deviceId) override;
bool HanleUmpInput(int64_t deviceId, size_t portIndex, MidiEvent list) override;
int32_t HanleUmpInput(int64_t deviceId, size_t portIndex, MidiEvent list) override;
private:
sptr<IMidiInterface> midiHdi_ = nullptr;
sptr<HDI::Midi::V1_0::IMidiInterface> midiHdi_ = nullptr;
};
}
}
services/server/src/midi_device_mananger.cpp
+2 -2
View File
@@ -173,7 +173,7 @@ void MidiDeviceManager::CompareDevices(const std::vector<DeviceInformation>& old
MIDI_INFO_LOG("Device added: midiId=%{public}" PRId64
", driverId=%{public}" PRId64
", name: %{public}s",
newDevice.deviceId, newDevice.driverDeviceId, newDevice.productName);
newDevice.deviceId, newDevice.driverDeviceId, newDevice.productName.c_str());
}
}
@@ -188,7 +188,7 @@ void MidiDeviceManager::CompareDevices(const std::vector<DeviceInformation>& old
MIDI_INFO_LOG("Device removed: midiId=%{public}" PRId64
", driverId=%{public}" PRId64
", name: %{public}s",
oldDevice.deviceId, oldDevice.driverDeviceId, oldDevice.productName);
oldDevice.deviceId, oldDevice.driverDeviceId, oldDevice.productName.c_str());
}
}
services/server/src/midi_device_usb.cpp
+33 -16
View File
@@ -10,35 +10,52 @@ UsbMidiTransportDeviceDriver::UsbMidiTransportDeviceDriver()
{
midiHdi_ = IMidiInterface::Get(true);
}
static std::vector<PortInformation> ConvertToDeviceInformation(const MidiDeviceInfo device)
{
std::vector<PortInformation> portInfos;
for (const auto &port : device.ports)
{
PortInformation portInfo;
portInfo.portId = port.portId;
portInfo.name = port.name;
portInfo.direction = (PortDirection)port.direction;
portInfo.transportProtocol = (TransportProtocol)device.protocol;
portInfos.push_back(portInfo);
}
return portInfos;
}
std::vector<DeviceInformation> UsbMidiTransportDeviceDriver::GetRegisteredDevices()
{
// 默认返回空列表
return std::vector<DeviceInformation>();
std::vector<MidiDeviceInfo> deviceList;
midiHdi_->GetDeviceList(deviceList);
std::vector<DeviceInformation> deviceInfos;
for (auto device : deviceList) {
DeviceInformation devInfo;
devInfo.driverDeviceId = device.deviceId;
devInfo.deviceType = DEVICE_TYPE_USB;
devInfo.transportProtocol = (TransportProtocol)device.protocol;
devInfo.productName = device.productName;
devInfo.vendorName = device.vendorName;
devInfo.portInfos = ConvertToDeviceInformation(device);
deviceInfos.push_back(devInfo);
}
return deviceInfos;
}
std::vector<PortInformation> UsbMidiTransportDeviceDriver::GetPortsForDevice(int64_t deviceId)
int32_t UsbMidiTransportDeviceDriver::OpenDevice(int64_t deviceId)
{
// 默认返回空列表
return std::vector<PortInformation>();
}
bool UsbMidiTransportDeviceDriver::OpenDevice(int64_t deviceId)
{
// 默认返回失败
return midiHdi_->OpenDevice(deviceId);
}
bool UsbMidiTransportDeviceDriver::CloseDevice(int64_t deviceId)
int32_t UsbMidiTransportDeviceDriver::CloseDevice(int64_t deviceId)
{
// 默认返回失败
return false;
return midiHdi_->OpenDevice(deviceId);
}
bool UsbMidiTransportDeviceDriver::HanleUmpInput(int64_t deviceId, size_t portIndex, MidiEvent list)
int32_t UsbMidiTransportDeviceDriver::HanleUmpInput(int64_t deviceId, size_t portIndex, MidiEvent list)
{
// 默认返回失败
return false;
return 0;
}
} // namespace MIDI
services/server/src/midi_service_controller.cpp
+2 -2
View File
@@ -125,7 +125,7 @@ int32_t MidiServiceController::OpenDevice(uint32_t clientId, int64_t deviceId)
deviceId, clientId);
return MIDI_STATUS_OK;
}
if (!deviceManager_.OpenDevice(deviceId)) {
if (deviceManager_.OpenDevice(deviceId) != MIDI_STATUS_OK) {
MIDI_ERR_LOG("Open device failed: deviceId=%{public}" PRId64, deviceId);
return MIDI_STATUS_UNKNOWN_ERROR;
}
@@ -160,7 +160,7 @@ int32_t MidiServiceController::CloseDevice(uint32_t clientId, int64_t deviceId)
if (clients.empty()) {
deviceClientContexts_.erase(it);
if (!deviceManager_.CloseDevice(deviceId)) {
if (deviceManager_.CloseDevice(deviceId) != MIDI_STATUS_OK) {
MIDI_ERR_LOG("Close device failed: deviceId=%{public}" PRId64, deviceId);
return MIDI_STATUS_UNKNOWN_ERROR;
}