openharmony/usb_manager
1
0
Fork 0
mirror of https://github.com/openharmony/usb_manager.git synced 2026-07-19 16:43:52 -04:00
Code Issues Packages Projects Releases Wiki Activity

!53 fix(usb):delete redundant log

Browse Source 
Merge pull request !53 from 吴成文/master
This commit is contained in:
openharmony_ci
2022-04-19 03:04:34 +00:00
committed by Gitee
parent bf738c31e8 37ac81a3ed
commit 062215c084
12 changed files with 272 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files
interfaces/innerkits/native/src/usb_request.cpp
+4 -8
View File
@@ -25,8 +25,7 @@ int32_t UsbRequest::Initialize(const USBDevicePipe &pipe, const USBEndpoint &end
this->endpoint_ = endpoint;
int32_t ret = UsbSrvClient::GetInstance().RequestInitialize(*this);
if (ERR_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbRequest::%{public}s:%{public}d failed with ret = %{public}d.", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "RequestInitialize failed with ret = %{public}d.", ret);
}
return ret;
}
@@ -35,8 +34,7 @@ int32_t UsbRequest::Queue()
{
int32_t ret = UsbSrvClient::GetInstance().RequestQueue(*this);
if (ERR_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbRequest::%{public}s:%{public}d failed with ret = %{public}d.", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "RequestQueue failed with ret = %{public}d.", ret);
}
return ret;
}
@@ -45,8 +43,7 @@ int32_t UsbRequest::Free()
{
int32_t ret = UsbSrvClient::GetInstance().RequestFree(*this);
if (ERR_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbRequest::%{public}s:%{public}d failed with ret = %{public}d.", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "RequestFree failed with ret = %{public}d.", ret);
}
return ret;
}
@@ -55,8 +52,7 @@ int32_t UsbRequest::Abort()
{
int32_t ret = UsbSrvClient::GetInstance().RequestAbort(*this);
if (ERR_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbRequest::%{public}s:%{public}d failed with ret = %{public}d.", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "RequestAbort failed with ret = %{public}d.", ret);
}
return ret;
}
interfaces/innerkits/native/src/usb_srv_client.cpp
+27 -29
View File
@@ -14,7 +14,6 @@
*/
#include "usb_srv_client.h"
#include <sstream>
#include "datetime_ex.h"
#include "if_system_ability_manager.h"
#include "ipc_skeleton.h"
@@ -42,7 +41,7 @@ int32_t UsbSrvClient::Connect()
}
sptr<ISystemAbilityManager> sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
if (sm == nullptr) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:fail to get Registry", __func__);
USB_HILOGE(MODULE_USB_INNERKIT, "fail to get SystemAbilityManager");
return UEC_INTERFACE_GET_SYSTEM_ABILITY_MANAGER_FAILED;
}
sptr<IRemoteObject> remoteObject_ = sm->CheckSystemAbility(USB_SYSTEM_ABILITY_ID);
@@ -51,7 +50,7 @@ int32_t UsbSrvClient::Connect()
return UEC_INTERFACE_GET_USB_SERVICE_FAILED;
}
proxy_ = iface_cast<IUsbSrv>(remoteObject_);
USB_HILOGI(MODULE_USB_INNERKIT, "%{public}s :Connect UsbService ok.", __func__);
USB_HILOGI(MODULE_USB_INNERKIT, "Connect UsbService ok.");
return UEC_OK;
}
@@ -78,11 +77,11 @@ void UsbSrvClient::UsbSrvDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>
int32_t UsbSrvClient::OpenDevice(const UsbDevice &device, USBDevicePipe &pipe)
{
USB_HILOGI(MODULE_USB_INNERKIT, " Calling OpenDevice Start!");
USB_HILOGI(MODULE_USB_INNERKIT, "Calling OpenDevice Start!");
RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->OpenDevice(device.GetBusNum(), device.GetDevAddr());
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "OpenDevice failed with ret = %{public}d !", ret);
return ret;
}
@@ -93,7 +92,7 @@ int32_t UsbSrvClient::OpenDevice(const UsbDevice &device, USBDevicePipe &pipe)
bool UsbSrvClient::HasRight(std::string deviceName)
{
USB_HILOGI(MODULE_USB_INNERKIT, " Calling HasRight Start!");
USB_HILOGI(MODULE_USB_INNERKIT, "Calling HasRight Start!");
RETURN_IF_WITH_RET(Connect() != UEC_OK, false);
return proxy_->HasRight(deviceName);
}
@@ -103,7 +102,7 @@ int32_t UsbSrvClient::RequestRight(std::string deviceName)
RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->RequestRight(deviceName);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, " Calling RequestRight False!");
USB_HILOGE(MODULE_USB_INNERKIT, "Calling RequestRight failed with ret = %{public}d !", ret);
}
return ret;
}
@@ -113,7 +112,7 @@ int32_t UsbSrvClient::RemoveRight(std::string deviceName)
RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->RemoveRight(deviceName);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, " Calling RequestRight False!");
USB_HILOGE(MODULE_USB_INNERKIT, "Calling RequestRight failed with ret = %{public}d !", ret);
}
return ret;
}
@@ -123,9 +122,9 @@ int32_t UsbSrvClient::GetDevices(std::vector<UsbDevice> &deviceList)
RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->GetDevices(deviceList);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "GetDevices failed ret = %{public}d!", ret);
}
USB_HILOGI(MODULE_USB_INNERKIT, "%{public}s list size = %{public}zu!", __func__, deviceList.size());
USB_HILOGI(MODULE_USB_INNERKIT, "list size = %{public}zu!", deviceList.size());
return ret;
}
@@ -134,7 +133,7 @@ int32_t UsbSrvClient::GetCurrentFunctions(int32_t &funcs)
RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->GetCurrentFunctions(funcs);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
}
USB_HILOGI(MODULE_USB_INNERKIT, " Calling GetCurrentFunctions Success!");
return ret;
@@ -145,7 +144,7 @@ int32_t UsbSrvClient::SetCurrentFunctions(int32_t funcs)
RETURN_IF_WITH_RET(Connect() != UEC_OK, false);
int32_t ret = proxy_->SetCurrentFunctions(funcs);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
return ret;
}
USB_HILOGI(MODULE_USB_INNERKIT, " Calling SetCurrentFunctions Success!");
@@ -175,7 +174,7 @@ int32_t UsbSrvClient::GetPorts(std::vector<UsbPort> &usbports)
USB_HILOGI(MODULE_USB_INNERKIT, " Calling GetPorts");
int32_t ret = proxy_->GetPorts(usbports);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
}
return ret;
}
@@ -186,7 +185,7 @@ int32_t UsbSrvClient::GetSupportedModes(int32_t portId, int32_t &result)
USB_HILOGI(MODULE_USB_INNERKIT, " Calling GetSupportedModes");
int32_t ret = proxy_->GetSupportedModes(portId, result);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
}
return ret;
}
@@ -194,10 +193,10 @@ int32_t UsbSrvClient::GetSupportedModes(int32_t portId, int32_t &result)
int32_t UsbSrvClient::SetPortRole(int32_t portId, int32_t powerRole, int32_t dataRole)
{
RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
USB_HILOGI(MODULE_USB_INNERKIT, " Calling SetPortRole");
USB_HILOGI(MODULE_USB_INNERKIT, "Calling SetPortRole");
int32_t ret = proxy_->SetPortRole(portId, powerRole, dataRole);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
}
return ret;
}
@@ -207,7 +206,7 @@ int32_t UsbSrvClient::ClaimInterface(USBDevicePipe &pipe, const UsbInterface &in
RETURN_IF_WITH_RET(proxy_ == nullptr, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->ClaimInterface(pipe.GetBusNum(), pipe.GetDevAddr(), interface.GetId(), force);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
}
@@ -217,7 +216,7 @@ int32_t UsbSrvClient::ReleaseInterface(USBDevicePipe &pipe, const UsbInterface &
RETURN_IF_WITH_RET(proxy_ == nullptr, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->ReleaseInterface(pipe.GetBusNum(), pipe.GetDevAddr(), interface.GetId());
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
}
@@ -235,7 +234,7 @@ int32_t UsbSrvClient::BulkTransfer(USBDevicePipe &pipe, const USBEndpoint &endpo
ret = proxy_->BulkTransferWrite(tdev, tpipe, bufferData, timeOut);
}
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
}
@@ -247,7 +246,7 @@ int32_t UsbSrvClient::ControlTransfer(USBDevicePipe &pipe, const UsbCtrlTransfer
const UsbDev dev = {pipe.GetBusNum(), pipe.GetDevAddr()};
int32_t ret = proxy_->ControlTransfer(dev, ctrl, bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
@@ -272,7 +271,7 @@ int32_t UsbSrvClient::GetRawDescriptors(USBDevicePipe &pipe, std::vector<uint8_t
RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->GetRawDescriptor(pipe.GetBusNum(), pipe.GetDevAddr(), bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
}
return ret;
}
@@ -282,7 +281,7 @@ int32_t UsbSrvClient::GetFileDescriptor(USBDevicePipe &pipe, int32_t &fd)
RETURN_IF_WITH_RET(Connect() != UEC_OK, UEC_INTERFACE_NO_INIT);
int32_t ret = proxy_->GetFileDescriptor(pipe.GetBusNum(), pipe.GetDevAddr(), fd);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s failed ret = %{public}d!", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret = %{public}d!", ret);
}
return ret;
}
@@ -302,8 +301,7 @@ int32_t UsbSrvClient::PipeRequestWait(USBDevicePipe &pipe, int64_t timeOut, UsbR
const UsbDev tdev = {pipe.GetBusNum(), pipe.GetDevAddr()};
int32_t ret = proxy_->RequestWait(tdev, timeOut, clientData, bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbSrvClient::%{public}s:%{public}d :failed width ret = %{public}d.", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d.", ret);
return ret;
}
@@ -354,7 +352,7 @@ int32_t UsbSrvClient::RegBulkCallback(USBDevicePipe &pip, const USBEndpoint &end
const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
int32_t ret = proxy_->RegBulkCallback(tdev, tpipe, cb);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
}
@@ -366,7 +364,7 @@ int32_t UsbSrvClient::UnRegBulkCallback(USBDevicePipe &pip, const USBEndpoint &e
const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
int32_t ret = proxy_->UnRegBulkCallback(tdev, tpipe);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
}
@@ -378,7 +376,7 @@ int32_t UsbSrvClient::BulkRead(USBDevicePipe &pip, const USBEndpoint &endpoint,
const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
int32_t ret = proxy_->BulkRead(tdev, tpipe, ashmem);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
}
@@ -390,7 +388,7 @@ int32_t UsbSrvClient::BulkWrite(USBDevicePipe &pip, const USBEndpoint &endpoint,
const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
int32_t ret = proxy_->BulkWrite(tdev, tpipe, ashmem);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
}
@@ -402,7 +400,7 @@ int32_t UsbSrvClient::BulkCancel(USBDevicePipe &pip, const USBEndpoint &endpoint
const UsbPipe tpipe = {endpoint.GetInterfaceId(), endpoint.GetAddress()};
int32_t ret = proxy_->BulkCancel(tdev, tpipe);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s : failed width ret = %{public}d !", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed width ret = %{public}d !", ret);
}
return ret;
}
interfaces/innerkits/native/src/usbd_bulk_callback.cpp
+9 -10
View File
@@ -24,45 +24,44 @@ int32_t UsbdBulkCallBack::OnRemoteRequest(uint32_t code, MessageParcel &data, Me
switch (code) {
case CMD_USBD_BULK_CALLBACK_WRITE: {
if (data.ReadInterfaceToken() != GetObjectDescriptor()) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s: checkout interface descriptor failed!", __func__);
USB_HILOGE(MODULE_USB_INNERKIT, "check interface token failed, code=%{public}u", code);
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
int32_t status;
int32_t actLength;
if (!data.ReadInt32(status)) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d get status error", __func__, __LINE__);
USB_HILOGE(MODULE_USB_INNERKIT, "get status error");
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
if (!data.ReadInt32(actLength)) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d get actLength error", __func__, __LINE__);
USB_HILOGE(MODULE_USB_INNERKIT, "get actLength error");
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
USB_HILOGI(MODULE_USB_INNERKIT, "%{public}s:%{public}d status:%{public}d actLength:%{public}d", __func__,
__LINE__, status, actLength);
USB_HILOGI(MODULE_USB_INNERKIT, "status:%{public}d actLength:%{public}d", status, actLength);
OnBulkWriteCallback(status, actLength);
break;
}
case CMD_USBD_BULK_CALLBACK_READ: {
if (data.ReadInterfaceToken() != GetObjectDescriptor()) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s: checkout interface descriptor failed!", __func__);
USB_HILOGE(MODULE_USB_INNERKIT, "check interface token failed, code=%{public}u", code);
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
int32_t status;
int32_t actLength;
if (!data.ReadInt32(status)) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d get status error", __func__, __LINE__);
USB_HILOGE(MODULE_USB_INNERKIT, "get status error code=%{public}u", code);
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
if (!data.ReadInt32(actLength)) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d get actLength error", __func__, __LINE__);
USB_HILOGE(MODULE_USB_INNERKIT, "get actLength error code=%{public}u", code);
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
USB_HILOGI(MODULE_USB_INNERKIT, "%{public}s:%{public}d status:%{public}d actLength:%{public}d", __func__,
__LINE__, status, actLength);
USB_HILOGI(MODULE_USB_INNERKIT, "%{public}d status:%{public}d actLength:%{public}d", __LINE__, status,
actLength);
OnBulkReadCallback(status, actLength);
break;
}
interfaces/kits/js/napi/src/napi_util.cpp
+9 -9
View File
@@ -27,7 +27,7 @@ const int32_t MAX_STR_LENGTH = 1024;
void NapiUtil::JsValueToString(const napi_env &env, const napi_value &value, const int32_t bufLen, std::string &target)
{
if (bufLen <= 0 || bufLen > MAX_STR_LENGTH) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s string too long malloc failed", __func__);
USB_HILOGE(MODULE_JS_NAPI, "string too long malloc failed");
return;
}
@@ -67,7 +67,7 @@ void NapiUtil::JsObjectToString(const napi_env &env, const napi_value &object, s
napi_get_value_string_utf8(env, field, buf.get(), bufLen, &result);
fieldRef = buf.get();
} else {
USB_HILOGW(MODULE_JS_NAPI, "%{public}s js to str no property: %{public}s", __func__, fieldStr.c_str());
USB_HILOGW(MODULE_JS_NAPI, "js to str no property: %{public}s", fieldStr.c_str());
}
}
@@ -79,7 +79,7 @@ bool NapiUtil::JsObjectGetProperty(const napi_env &env, const napi_value &object
if (hasProperty) {
napi_get_named_property(env, object, fieldStr.c_str(), &value);
} else {
USB_HILOGW(MODULE_JS_NAPI, "%{public}s js object has no property: %{public}s", __func__, fieldStr.c_str());
USB_HILOGW(MODULE_JS_NAPI, "js object has no property: %{public}s", fieldStr.c_str());
}
return hasProperty;
}
@@ -97,7 +97,7 @@ void NapiUtil::JsObjectToInt(const napi_env &env, const napi_value &object, std:
NAPI_ASSERT_RETURN_VOID(env, valueType == napi_number, "Wrong argument type. Number expected.");
napi_get_value_int32(env, field, &fieldRef);
} else {
USB_HILOGW(MODULE_JS_NAPI, "%{public}s js to int32_t no property: %{public}s", __func__, fieldStr.c_str());
USB_HILOGW(MODULE_JS_NAPI, "js to int32_t no property: %{public}s", fieldStr.c_str());
}
}
@@ -106,7 +106,7 @@ bool NapiUtil::JsUint8ArrayParse(const napi_env &env, const napi_value &object,
{
bool isTypedArray = false;
if (napi_is_typedarray(env, object, &isTypedArray) != napi_ok || !isTypedArray) {
USB_HILOGW(MODULE_JS_NAPI, "%{public}s invalid type", __func__);
USB_HILOGW(MODULE_JS_NAPI, "invalid type");
return false;
}
@@ -116,17 +116,17 @@ bool NapiUtil::JsUint8ArrayParse(const napi_env &env, const napi_value &object,
napi_status infoStatus = napi_get_typedarray_info(env, object, &type, &bufferSize,
reinterpret_cast<void **>(uint8Buffer), &buffer, &offset);
if (infoStatus != napi_ok) {
USB_HILOGW(MODULE_JS_NAPI, "%{public}s get typedarray info failed, status: %{public}d", __func__, infoStatus);
USB_HILOGW(MODULE_JS_NAPI, "get typedarray info failed, status: %{public}d", infoStatus);
return false;
}
if (type != napi_uint8_array) {
USB_HILOGW(MODULE_JS_NAPI, "%{public}s not Uint8Array type: %{public}d", __func__, type);
USB_HILOGW(MODULE_JS_NAPI, "not Uint8Array type: %{public}d", type);
return false;
}
if (bufferSize == 0) {
USB_HILOGW(MODULE_JS_NAPI, "%{public}s:%{public}d bufferSize error", __func__, __LINE__);
USB_HILOGW(MODULE_JS_NAPI, "bufferSize error");
return false;
}
@@ -142,7 +142,7 @@ void NapiUtil::Uint8ArrayToJsValue(const napi_env &env, std::vector<uint8_t> &ui
errno_t ret = memcpy_s(nativeArraybuffer, bufferSize, uint8Buffer.data(), bufferSize);
if (ret != EOK) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s:%{public}d memcpy_s failed\n", __func__, __LINE__);
USB_HILOGE(MODULE_JS_NAPI, "memcpy_s failed\n");
return;
}
interfaces/kits/js/napi/src/usb_info.cpp
+17 -17
View File
@@ -190,14 +190,14 @@ static bool ParseEndpointsObjs(const napi_env env, const napi_value interfaceObj
napi_value endpointsObjs;
bool isGetObjSuccess = NapiUtil::JsObjectGetProperty(env, interfaceObj, "endpoints", endpointsObjs);
if (!isGetObjSuccess) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get endpoints failed.", __func__);
USB_HILOGE(MODULE_JS_NAPI, "get endpoints failed.");
return false;
}
bool result = false;
napi_status status = napi_is_array(env, endpointsObjs, &result);
if (!result || status != napi_ok) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s, invalid endpoints.", __func__);
USB_HILOGE(MODULE_JS_NAPI, "invalid endpoints.");
return false;
}
@@ -212,7 +212,7 @@ static bool ParseEndpointsObjs(const napi_env env, const napi_value interfaceObj
napi_value endpointObj;
status = napi_get_element(env, endpointsObjs, k, &endpointObj);
if (status != napi_ok) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get endpoints element failed k=%u.", __func__, k);
USB_HILOGE(MODULE_JS_NAPI, "get endpoints element failed k=%u.", k);
return false;
}
USBEndpoint ep;
@@ -289,21 +289,21 @@ static bool ParseInterfacesObjs(const napi_env env, const napi_value configObj,
napi_value interfacesObjs;
bool isGetObjSuccess = NapiUtil::JsObjectGetProperty(env, configObj, "interfaces", interfacesObjs);
if (!isGetObjSuccess) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get interfaces failed.", __func__);
USB_HILOGE(MODULE_JS_NAPI, "get interfaces failed.");
return false;
}
bool result = false;
napi_status status = napi_is_array(env, interfacesObjs, &result);
if (!result || status != napi_ok) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s, invalid param.", __func__);
USB_HILOGE(MODULE_JS_NAPI, "invalid param.");
return false;
}
uint32_t interfaceCount = 0;
status = napi_get_array_length(env, interfacesObjs, &interfaceCount);
if (status != napi_ok) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get len failed.", __func__);
USB_HILOGE(MODULE_JS_NAPI, "get len failed.");
return false;
}
@@ -311,7 +311,7 @@ static bool ParseInterfacesObjs(const napi_env env, const napi_value configObj,
napi_value interfaceObj;
status = napi_get_element(env, interfacesObjs, i, &interfaceObj);
if (status != napi_ok) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s, get element failed,i=%{public}u.", __func__, i);
USB_HILOGE(MODULE_JS_NAPI, "get element failed,i=%{public}u.", i);
return false;
}
UsbInterface interface;
@@ -403,7 +403,7 @@ static napi_value CoreGetDevices(napi_env env, napi_callback_info info)
napi_value result;
if (ret != UEC_OK) {
napi_get_undefined(env, &result);
USB_HILOGE(MODULE_JS_NAPI, "end call %{public}s, get device failed ret : %{public}d", __func__, ret);
USB_HILOGE(MODULE_JS_NAPI, "end call get device failed ret : %{public}d", ret);
return result;
}
@@ -634,7 +634,7 @@ static napi_value CoreGetCurrentFunctions(napi_env env, napi_callback_info info)
napi_value result;
if (ret != UEC_OK) {
napi_get_undefined(env, &result);
USB_HILOGE(MODULE_JS_NAPI, "end call %{public}s, get ports failed ret : %{public}d", __func__, ret);
USB_HILOGE(MODULE_JS_NAPI, "end call get ports failed ret : %{public}d", ret);
return result;
}
napi_create_int32(env, cfuncs, &result);
@@ -655,7 +655,7 @@ static napi_value CoreGetPorts(napi_env env, napi_callback_info info)
napi_value result;
if (ret != UEC_OK) {
napi_get_undefined(env, &result);
USB_HILOGE(MODULE_JS_NAPI, "end call %{public}s, get ports failed ret : %{public}d", __func__, ret);
USB_HILOGE(MODULE_JS_NAPI, "end call get ports failed ret : %{public}d", ret);
return result;
}
@@ -696,7 +696,7 @@ static napi_value PortGetSupportedModes(napi_env env, napi_callback_info info)
napi_get_value_int32(env, args[INDEX_0], &id);
int32_t ret = g_usbClient.GetSupportedModes(id, result);
if (ret) {
USB_HILOGD(MODULE_JS_NAPI, "%{public}s:false ret = %{public}d", __func__, ret);
USB_HILOGD(MODULE_JS_NAPI, "false ret = %{public}d", ret);
}
napi_value napiValue = nullptr;
NAPI_CALL(env, napi_create_int32(env, result, &napiValue));
@@ -1041,14 +1041,14 @@ static napi_value PipeControlTransfer(napi_env env, napi_callback_info info)
if ((asyncContext->reqType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
uint8_t *nativeArraybuffer = new(std::nothrow) uint8_t[controlParam.dataLength];
if (nativeArraybuffer == nullptr) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s:%{public}d, new failed", __func__, __LINE__);
USB_HILOGE(MODULE_JS_NAPI, "new failed");
delete asyncContext;
return nullptr;
}
errno_t ret = memcpy_s(nativeArraybuffer, controlParam.dataLength, controlParam.data, controlParam.dataLength);
if (ret != EOK) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s:%{public}d, memcpy_s failed\n", __func__, __LINE__);
USB_HILOGE(MODULE_JS_NAPI, "memcpy_s failed\n");
delete asyncContext;
delete []nativeArraybuffer;
return nullptr;
@@ -1160,7 +1160,7 @@ static bool GetBulkTransferParams(napi_env env, napi_callback_info info, USBBulk
errno_t ret = memcpy_s(nativeArraybuffer, bufferSize, buffer, bufferSize);
if (ret != EOK) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s:%{public}d, memcpy_s failed\n", __func__, __LINE__);
USB_HILOGE(MODULE_JS_NAPI, "memcpy_s failed\n");
delete []nativeArraybuffer;
return false;
}
@@ -1182,7 +1182,7 @@ static napi_value PipeBulkTransfer(napi_env env, napi_callback_info info)
napi_value result = nullptr;
napi_create_promise(env, &asyncContext->deferred, &result);
if (!GetBulkTransferParams(env, info, *asyncContext)) {
USB_HILOGE(MODULE_JS_NAPI, "end call %{public}s %{public}d : invalid arg", __func__, __LINE__);
USB_HILOGE(MODULE_JS_NAPI, "end call invalid arg");
asyncContext->status = napi_invalid_arg;
napi_value queryResult = nullptr;
napi_create_int32(env, -1, &queryResult);
@@ -1197,7 +1197,7 @@ static napi_value PipeBulkTransfer(napi_env env, napi_callback_info info)
napi_status status = napi_create_async_work(env, nullptr, resource, g_bulkTransferExecute, g_bulkTransferComplete,
reinterpret_cast<void *>(asyncContext), &asyncContext->work);
if (status != napi_ok) {
USB_HILOGE(MODULE_JS_NAPI, "%{public}s, create async work failed", __func__);
USB_HILOGE(MODULE_JS_NAPI, "create async work failed");
return result;
}
napi_queue_async_work(env, asyncContext->work);
@@ -1230,7 +1230,7 @@ static napi_value PipeClose(napi_env env, napi_callback_info info)
static napi_value GetVersion(napi_env env, napi_callback_info info)
{
auto version = g_usbClient.GetVersion();
USB_HILOGD(MODULE_JS_NAPI, "call %{public}s, version is %{public}s", __func__, version.c_str());
USB_HILOGD(MODULE_JS_NAPI, "version is %{public}s", version.c_str());
napi_value result;
napi_create_string_utf8(env, version.c_str(), NAPI_AUTO_LENGTH, &result);
return result;
services/native/src/usb_descriptor_parser.cpp
+18 -22
View File
@@ -40,22 +40,21 @@ int32_t UsbDescriptorParser::ParseDeviceDescriptor(const uint8_t *buffer, uint32
{
uint32_t cursor = 0;
if (buffer == nullptr || length == 0) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: buffer is null", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "buffer is null");
return UEC_SERVICE_INVALID_VALUE;
}
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: parse begin length=%{public}u, cursor=%{public}u",
__func__, length, cursor);
USB_HILOGI(MODULE_USB_SERVICE, "parse begin length=%{public}u, cursor=%{public}u", length, cursor);
uint32_t deviceDescriptorSize = sizeof(UsbdDeviceDescriptor);
if (length < deviceDescriptorSize) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: buffer size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "buffer size error");
return UEC_SERVICE_INVALID_VALUE;
}
UsbdDeviceDescriptor deviceDescriptor = *(UsbdDeviceDescriptor *)buffer;
cursor += deviceDescriptorSize;
if (deviceDescriptor.bLength != deviceDescriptorSize) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: UsbdDeviceDescriptor size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "UsbdDeviceDescriptor size error");
return UEC_SERVICE_INVALID_VALUE;
}
@@ -81,18 +80,17 @@ int32_t UsbDescriptorParser::ParseConfigDescriptor(const uint8_t *buffer, uint32
return UEC_SERVICE_INVALID_VALUE;
}
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: parse begin length=%{public}u, cursor=%{public}u",
__func__, length, cursor);
USB_HILOGI(MODULE_USB_SERVICE, "parse begin length=%{public}u, cursor=%{public}u", length, cursor);
uint32_t configDescriptorSize = sizeof(UsbdConfigDescriptor);
if (length < configDescriptorSize) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: buffer size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "buffer size error");
return UEC_SERVICE_INVALID_VALUE;
}
UsbdConfigDescriptor configDescriptor = *(UsbdConfigDescriptor *)buffer;
cursor += configDescriptorSize;
if (configDescriptor.bLength != configDescriptorSize) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: UsbdDeviceDescriptor size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "UsbdDeviceDescriptor size error");
return UEC_SERVICE_INVALID_VALUE;
}
@@ -129,25 +127,25 @@ int32_t UsbDescriptorParser::ParseInterfaceDescriptor(const uint8_t *buffer, uin
uint32_t descriptorHeaderSize = sizeof(UsbdDescriptorHeader);
while ((uint32_t)cursor < length) {
if (descriptorHeaderSize >= length) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: descriptor size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "length error");
return UEC_SERVICE_INVALID_VALUE;
}
UsbdDescriptorHeader descriptorHeader = *(UsbdDescriptorHeader *)(buffer + cursor);
if (descriptorHeader.bLength > length) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: descriptor size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "descriptor size error");
return UEC_SERVICE_INVALID_VALUE;
}
if (descriptorHeader.bDescriptorType == static_cast<uint8_t>(DescriptorType::DESCRIPTOR_TYPE_INTERFACE)) {
break;
}
cursor += descriptorHeader.bLength;
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: type = %{public}d, length=%{public}d", __func__,
descriptorHeader.bDescriptorType, descriptorHeader.bLength);
USB_HILOGI(MODULE_USB_SERVICE, "type = %{public}d, length=%{public}d", descriptorHeader.bDescriptorType,
descriptorHeader.bLength);
}
UsbdInterfaceDescriptor interfaceDescriptor = *(UsbdInterfaceDescriptor *)(buffer + cursor);
if (interfaceDescriptor.bLength != sizeof(UsbdInterfaceDescriptor)) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: UsbdInterfaceDescriptor size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "UsbdInterfaceDescriptor size error");
return UEC_SERVICE_INVALID_VALUE;
}
cursor += interfaceDescriptor.bLength;
@@ -175,8 +173,7 @@ int32_t UsbDescriptorParser::ParseInterfaceDescriptor(const uint8_t *buffer, uin
int32_t UsbDescriptorParser::ParseEndpointDescriptor(const uint8_t *buffer, uint32_t length, uint32_t &cursor,
USBEndpoint &ep)
{
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: parse begin, length=%{public}u, cursor=%{public}u",
__func__, length, cursor);
USB_HILOGI(MODULE_USB_SERVICE, "parse begin, length=%{public}u, cursor=%{public}u", length, cursor);
if (buffer == nullptr || length == 0) {
return UEC_SERVICE_INVALID_VALUE;
}
@@ -184,26 +181,25 @@ int32_t UsbDescriptorParser::ParseEndpointDescriptor(const uint8_t *buffer, uint
uint32_t descriptorHeaderSize = sizeof(UsbdDescriptorHeader);
while ((uint32_t)cursor < length) {
if (descriptorHeaderSize >= length) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: descriptor size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "length error");
return UEC_SERVICE_INVALID_VALUE;
}
UsbdDescriptorHeader descriptorHeader = *(UsbdDescriptorHeader *)(buffer + cursor);
if (descriptorHeader.bLength > length) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: descriptor size error", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "descriptor size error");
return UEC_SERVICE_INVALID_VALUE;
}
if (descriptorHeader.bDescriptorType == static_cast<uint8_t>(DescriptorType::DESCRIPTOR_TYPE_ENDPOINT)) {
break;
}
cursor += descriptorHeader.bLength;
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: error type = %{public}d, length=%{public}d", __func__,
descriptorHeader.bDescriptorType, descriptorHeader.bLength);
USB_HILOGI(MODULE_USB_SERVICE, "error type = %{public}d, length=%{public}d", descriptorHeader.bDescriptorType,
descriptorHeader.bLength);
}
UsbdEndpointDescriptor endpointDescriptor = *(UsbdEndpointDescriptor *)(buffer + cursor);
if (endpointDescriptor.bLength != sizeof(UsbdEndpointDescriptor)) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: Endpoint descriptor size error, length=%{public}d", __func__,
endpointDescriptor.bLength);
USB_HILOGE(MODULE_USB_SERVICE, "Endpoint descriptor size error, length=%{public}d", endpointDescriptor.bLength);
return UEC_SERVICE_INVALID_VALUE;
}
cursor += endpointDescriptor.bLength;
services/native/src/usb_host_manager.cpp
+9 -10
View File
@@ -36,12 +36,12 @@ bool UsbHostManager::DelDevice(uint8_t busNum, uint8_t devNum)
std::string name = std::to_string(busNum) + "-" + std::to_string(devNum);
MAP_STR_DEVICE::iterator iter = devices_.find(name);
if (iter == devices_.end()) {
USB_HILOGF(MODULE_SERVICE, "%{public}s:%{public}d name:%{public}s bus:%{public}hhu dev:%{public}hhu not exist",
__func__, __LINE__, name.c_str(), busNum, devNum);
USB_HILOGF(MODULE_SERVICE, "name:%{public}s bus:%{public}hhu dev:%{public}hhu not exist", name.c_str(),
busNum, devNum);
return false;
}
USB_HILOGF(MODULE_SERVICE, "%{public}s:%{public}d device:%{public}s bus:%{public}hhu dev:%{public}hhu erase ",
__func__, __LINE__, name.c_str(), busNum, devNum);
USB_HILOGI(MODULE_SERVICE, "device:%{public}s bus:%{public}hhu dev:%{public}hhu erase ", name.c_str(), busNum,
devNum);
UsbDevice *devOld = iter->second;
devices_.erase(iter);
if (devOld)
@@ -52,7 +52,7 @@ bool UsbHostManager::DelDevice(uint8_t busNum, uint8_t devNum)
bool UsbHostManager::AddDevice(UsbDevice *dev)
{
if (dev == nullptr) {
USB_HILOGF(MODULE_SERVICE, "%{public}s:%{public}d device is NULL", __func__, __LINE__);
USB_HILOGF(MODULE_SERVICE, "device is NULL");
return false;
}
uint8_t busNum = dev->GetBusNum();
@@ -60,16 +60,15 @@ bool UsbHostManager::AddDevice(UsbDevice *dev)
std::string name = std::to_string(busNum) + "-" + std::to_string(devNum);
MAP_STR_DEVICE::iterator iter = devices_.find(name);
if (iter != devices_.end()) {
USB_HILOGF(MODULE_SERVICE,
"%{public}s:%{public}d device:%{public}s bus:%{public}hhu dev:%{public}hhu already exist", __func__,
__LINE__, name.c_str(), busNum, devNum);
USB_HILOGF(MODULE_SERVICE, "device:%{public}s bus:%{public}hhu dev:%{public}hhu already exist", name.c_str(),
busNum, devNum);
UsbDevice *devOld = iter->second;
devices_.erase(iter);
if (devOld)
delete devOld;
}
USB_HILOGF(MODULE_SERVICE, "%{public}s:%{public}d device:%{public}s bus:%{public}hhu dev:%{public}hhu insert",
__func__, __LINE__, name.c_str(), busNum, devNum);
USB_HILOGI(MODULE_SERVICE, "device:%{public}s bus:%{public}hhu dev:%{public}hhu insert", name.c_str(), busNum,
devNum);
devices_.insert(std::pair<std::string, UsbDevice *>(name, dev));
return true;
}
services/native/src/usb_service.cpp
+55 -72
View File
@@ -64,7 +64,7 @@ UsbService::~UsbService() {}
void UsbService::OnStart()
{
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d usb_service OnStart enter", __func__, __LINE__);
USB_HILOGI(MODULE_USB_SERVICE, "usb_service OnStart enter");
if (ready_) {
USB_HILOGE(MODULE_USB_SERVICE, "OnStart is ready, nothing to do");
return;
@@ -97,7 +97,7 @@ void UsbService::OnStart()
bool UsbService::Init()
{
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d usb_service Init enter", __func__, __LINE__);
USB_HILOGI(MODULE_USB_SERVICE, "usb_service Init enter");
if (!eventRunner_) {
eventRunner_ = AppExecFwk::EventRunner::Create(USB_SERVICE_NAME);
if (eventRunner_ == nullptr) {
@@ -130,18 +130,18 @@ bool UsbService::InitUsbd()
{
usbdSubscriber_ = new(std::nothrow) UsbServiceSubscriber();
if (usbdSubscriber_ == nullptr) {
USB_HILOGE(MODULE_USB_SERVICE, " %{public}s:%{public}d Init failed\n", __func__, __LINE__);
USB_HILOGE(MODULE_USB_SERVICE, "Init failed\n");
return false;
}
ErrCode ret = UsbdClient::GetInstance().BindUsbdSubscriber(usbdSubscriber_);
USB_HILOGE(MODULE_USB_SERVICE, " entry InitUsbd ret: %{public}d", ret);
USB_HILOGI(MODULE_USB_SERVICE, "entry InitUsbd ret: %{public}d", ret);
return SUCCEEDED(ret);
}
void UsbService::OnStop()
{
USB_HILOGE(MODULE_USB_SERVICE, " entry stop service %{public}d", ready_);
USB_HILOGI(MODULE_USB_SERVICE, "entry stop service %{public}d", ready_);
if (!ready_) {
return;
}
@@ -172,15 +172,14 @@ int32_t UsbService::OpenDevice(uint8_t busNum, uint8_t devAddr)
{
std::string name = std::to_string(busNum) + "-" + std::to_string(devAddr);
if (!UsbService::HasRight(name)) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d No permission", __func__, __LINE__);
USB_HILOGE(MODULE_USB_SERVICE, "No permission");
return UEC_SERVICE_PERMISSION_DENIED;
}
const UsbDev dev = {busNum, devAddr};
int32_t ret = UsbdClient::GetInstance().OpenDevice(dev);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d OpenDevice failed ret:%{public}d", __func__, __LINE__,
ret);
USB_HILOGE(MODULE_USB_SERVICE, "OpenDevice failed ret:%{public}d", ret);
}
return ret;
@@ -222,7 +221,7 @@ int32_t UsbService::GetDevices(std::vector<UsbDevice> &deviceList)
{
std::map<std::string, UsbDevice *> devices;
usbHostManger_->GetDevices(devices);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s list size %{public}zu", __func__, devices.size());
USB_HILOGI(MODULE_USB_SERVICE, "list size %{public}zu", devices.size());
for (auto it = devices.begin(); it != devices.end(); ++it) {
deviceList.push_back(*it->second);
}
@@ -287,8 +286,7 @@ int32_t UsbService::BulkTransferRead(const UsbDev &devInfo, const UsbPipe &pipe,
{
int32_t ret = UsbdClient::GetInstance().BulkTransferRead(devInfo, pipe, timeOut, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkTransferRead error ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferRead error ret:%{public}d", ret);
}
return ret;
}
@@ -298,8 +296,7 @@ int32_t UsbService::BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe, co
{
int32_t ret = UsbdClient::GetInstance().BulkTransferWrite(dev, pipe, timeOut, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkTransferWrite error ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "BulkTransferWrite error ret:%{public}d", ret);
}
return ret;
}
@@ -308,7 +305,7 @@ int32_t UsbService::ControlTransfer(const UsbDev &dev, const UsbCtrlTransfer &ct
{
int32_t ret = UsbdClient::GetInstance().ControlTransfer(dev, ctrl, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
}
return ret;
}
@@ -336,7 +333,7 @@ int32_t UsbService::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::vecto
const UsbDev dev = {busNum, devAddr};
int32_t ret = UsbdClient::GetInstance().GetRawDescriptor(dev, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
}
return ret;
}
@@ -346,7 +343,7 @@ int32_t UsbService::GetFileDescriptor(uint8_t busNum, uint8_t devAddr, int32_t &
const UsbDev dev = {busNum, devAddr};
int32_t ret = UsbdClient::GetInstance().GetFileDescriptor(dev, fd);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
}
return ret;
}
@@ -356,7 +353,7 @@ int32_t UsbService::RequestQueue(const UsbDev &dev, const UsbPipe &pipe, const s
{
int32_t ret = UsbdClient::GetInstance().RequestQueue(dev, pipe, clientData, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
}
return ret;
}
@@ -366,7 +363,7 @@ int32_t UsbService::RequestWait(const UsbDev &dev, int32_t timeOut, std::vector<
{
int32_t ret = UsbdClient::GetInstance().RequestWait(dev, clientData, bufferData, timeOut);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "error ret:%{public}d", ret);
}
return ret;
}
@@ -396,20 +393,18 @@ static std::string GetDevStringValFromIdx(uint8_t busNum, uint8_t devAddr, uint8
int32_t ret = UsbdClient::GetInstance().GetStringDescriptor(dev, idx, strV);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d get string[%{public}hhu] failed ret:%{public}d", __func__,
__LINE__, idx, ret);
USB_HILOGE(MODULE_USB_SERVICE, "get string[%{public}hhu] failed ret:%{public}d", idx, ret);
return strDesc;
}
uint32_t length = strV.size();
if ((length < DESCRIPTOR_VALUE_START_OFFSET) || (strV[1] != DESCRIPTOR_TYPE_STRING)) {
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d type or length error, len:%{public}u", __func__, __LINE__,
length);
USB_HILOGI(MODULE_USB_SERVICE, "type or length error, len:%{public}u", length);
return strDesc;
}
uint16_t *tbuf = new(std::nothrow) uint16_t[length + 1]();
if (tbuf == nullptr) {
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d new failed\n", __func__, __LINE__);
USB_HILOGI(MODULE_USB_SERVICE, "new failed\n");
return strDesc;
}
@@ -418,8 +413,8 @@ static std::string GetDevStringValFromIdx(uint8_t busNum, uint8_t devAddr, uint8
}
std::wstring wstr((wchar_t *)(tbuf), (length - DESCRIPTOR_VALUE_START_OFFSET) / HALF);
strDesc = std::string(wstr.begin(), wstr.end());
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d getString idx:%{public}d String:%{public}s length:%{public}d",
__func__, __LINE__, idx, strDesc.c_str(), length);
USB_HILOGI(MODULE_USB_SERVICE, "getString idx:%{public}d String:%{public}s length:%{public}d", idx, strDesc.c_str(),
length);
delete[] tbuf;
return strDesc;
}
@@ -448,23 +443,20 @@ static int32_t FillDevStrings(UsbDevice &dev)
dev.SetManufacturerName(GetDevStringValFromIdx(busNum, devAddr, dev.GetiManufacturer()));
dev.SetProductName(GetDevStringValFromIdx(busNum, devAddr, dev.GetiProduct()));
dev.SetmSerial(GetDevStringValFromIdx(busNum, devAddr, dev.GetiSerialNumber()));
USB_HILOGI(MODULE_USB_SERVICE,
"%{public}s:%{public}d iSerial:%{public}d mSerial:%{public}s Manufactur:%{public}s product:%{public}s "
"version:%{public}s",
__func__, __LINE__, dev.GetiSerialNumber(), dev.GetmSerial().c_str(), dev.GetManufacturerName().c_str(),
dev.GetProductName().c_str(), dev.GetVersion().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "iSerial:%{public}d mSerial:%{public}s Manufactur:%{public}s product:%{public}s "
"version:%{public}s", dev.GetiSerialNumber(), dev.GetmSerial().c_str(), dev.GetManufacturerName().c_str(),
dev.GetProductName().c_str(), dev.GetVersion().c_str());
std::vector<USBConfig> configs;
configs = dev.GetConfigs();
for (auto it = configs.begin(); it != configs.end(); ++it) {
it->SetName(GetDevStringValFromIdx(busNum, devAddr, it->GetiConfiguration()));
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d Config:%{public}d %{public}s", __func__, __LINE__,
it->GetiConfiguration(), it->GetName().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "Config:%{public}d %{public}s", it->GetiConfiguration(), it->GetName().c_str());
std::vector<UsbInterface> interfaces = it->GetInterfaces();
for (auto itIF = interfaces.begin(); itIF != interfaces.end(); ++itIF) {
itIF->SetName(GetDevStringValFromIdx(busNum, devAddr, itIF->GetiInterface()));
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d interface:%{public}hhu %{public}s", __func__,
__LINE__, itIF->GetiInterface(), itIF->GetName().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "interface:%{public}hhu %{public}s", itIF->GetiInterface(),
itIF->GetName().c_str());
}
it->SetInterfaces(interfaces);
}
@@ -478,19 +470,15 @@ int32_t UsbService::GetDeviceInfoDescriptor(const UsbDev &uDev, std::vector<uint
int32_t ret = UsbdClient::GetInstance().GetRawDescriptor(uDev, descriptor);
if (ret != UEC_OK) {
UsbdClient::GetInstance().CloseDevice(uDev);
USB_HILOGE(MODULE_USB_SERVICE,
"%{public}s:%{public}d GetRawDescriptor failed ret=%{public}d busNum:%{public}d "
"devAddr:%{public}d",
__func__, __LINE__, ret, uDev.busNum, uDev.devAddr);
USB_HILOGE(MODULE_USB_SERVICE, "GetRawDescriptor failed ret=%{public}d busNum:%{public}d devAddr:%{public}d",
ret, uDev.busNum, uDev.devAddr);
return ret;
}
uint8_t *buffer = descriptor.data();
uint32_t length = descriptor.size();
if ((!buffer) || (length == 0)) {
USB_HILOGE(MODULE_USB_SERVICE,
"%{public}s:%{public}d GetRawDescriptor failed len=%{public}d busNum:%{public}d "
"devAddr:%{public}d",
__func__, __LINE__, length, uDev.busNum, uDev.devAddr);
USB_HILOGE(MODULE_USB_SERVICE, "GetRawDescriptor failed len=%{public}d busNum:%{public}d devAddr:%{public}d",
length, uDev.busNum, uDev.devAddr);
return UEC_SERVICE_INVALID_VALUE;
}
dev.SetBusNum(uDev.busNum);
@@ -500,7 +488,7 @@ int32_t UsbService::GetDeviceInfoDescriptor(const UsbDev &uDev, std::vector<uint
ret = UsbDescriptorParser::ParseDeviceDescriptor(buffer, length, dev);
if (ret != UEC_OK) {
UsbdClient::GetInstance().CloseDevice(uDev);
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s ParseDeviceDescriptor failed ret=%{public}d", __func__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "ParseDeviceDescriptor failed ret=%{public}d", ret);
return ret;
}
return ret;
@@ -515,51 +503,50 @@ int32_t UsbService::GetConfigDescriptor(UsbDevice &dev, std::vector<uint8_t> &de
int32_t ret = UEC_OK;
for (uint8_t i = 0; i < dev.GetDescConfigCount(); ++i) {
if (length <= cursor) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d GetConfigDescriptor[%{public}d] length=%{public}d",
__func__, __LINE__, i, length);
USB_HILOGE(MODULE_USB_SERVICE, "GetConfigDescriptor[%{public}d] length=%{public}d", i, length);
break;
}
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s GetConfigDescriptor length=%{public}d", __func__, length);
USB_HILOGI(MODULE_USB_SERVICE, "GetConfigDescriptor length=%{public}d", length);
uint32_t configCursor = 0;
USBConfig config;
ret = UsbDescriptorParser::ParseConfigDescriptor(buffer + cursor, length - cursor, configCursor, config);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "ParseConfigDescriptor failed ret=%{public}d", ret);
return ret;
}
cursor += configCursor;
configs.push_back(config);
}
dev.SetConfigs(configs);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d SetConfigs ret=%{public}d", __func__, __LINE__, ret);
ret = FillDevStrings(dev);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d FillDevStrings ret=%{public}d", __func__, __LINE__, ret);
USB_HILOGI(MODULE_USB_SERVICE, "FillDevStrings ret=%{public}d", ret);
return ret;
}
int32_t UsbService::GetDeviceInfo(uint8_t busNum, uint8_t devAddr, UsbDevice &dev)
{
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d busNum:%{public}d devAddr:%{public}d", __func__, __LINE__,
busNum, devAddr);
USB_HILOGI(MODULE_USB_SERVICE, "busNum:%{public}d devAddr:%{public}d", busNum, devAddr);
const UsbDev uDev = {busNum, devAddr};
std::vector<uint8_t> descriptor;
int32_t ret = UsbdClient::GetInstance().OpenDevice(uDev);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s OpenDevice failed ret=%{public}d", __func__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "OpenDevice failed ret=%{public}d", ret);
return ret;
}
ret = GetDeviceInfoDescriptor(uDev, descriptor, dev);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d GetDeviceInfoDescriptor ret=%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "GetDeviceInfoDescriptor ret=%{public}d", ret);
}
ret = GetConfigDescriptor(dev, descriptor);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d GetConfigDescriptor ret=%{public}d", __func__, __LINE__,
ret);
USB_HILOGE(MODULE_USB_SERVICE, "GetConfigDescriptor ret=%{public}d", ret);
return ret;
}
UsbdClient::GetInstance().CloseDevice(uDev);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s CloseDevice=%{public}s", __func__, dev.ToString().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "CloseDevice=%{public}s", dev.ToString().c_str());
return UEC_OK;
}
@@ -568,18 +555,18 @@ bool UsbService::AddDevice(uint8_t busNum, uint8_t devAddr)
{
UsbDevice *devInfo = new(std::nothrow) UsbDevice();
if (devInfo == nullptr) {
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d new failed", __func__, __LINE__);
USB_HILOGI(MODULE_USB_SERVICE, "new failed");
return false;
}
errno_t retSafe = memset_s(devInfo, sizeof(UsbDevice), 0, sizeof(UsbDevice));
if (retSafe != EOK) {
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d memset_s failed", __func__, __LINE__);
USB_HILOGI(MODULE_USB_SERVICE, "memset_s failed");
return false;
}
int32_t ret = GetDeviceInfo(busNum, devAddr, *devInfo);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s:%{public}d GetDeviceInfo ret=%{public}d", __func__, __LINE__, ret);
USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceInfo ret=%{public}d", ret);
if (ret == UEC_OK) {
usbHostManger_->AddDevice(devInfo);
return true;
@@ -590,11 +577,10 @@ bool UsbService::AddDevice(uint8_t busNum, uint8_t devAddr)
bool UsbService::DelDevice(uint8_t busNum, uint8_t devAddr)
{
USB_HILOGI(MODULE_USBD, "%{public}s:%{public}d entry", __func__, __LINE__);
USB_HILOGI(MODULE_USBD, "entry");
int32_t ret = Close(busNum, devAddr);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d Close device failed width ret = %{public}d", __func__, __LINE__,
ret);
USB_HILOGE(MODULE_USBD, "Close device failed width ret = %{public}d", ret);
}
return usbHostManger_->DelDevice(busNum, devAddr);
}
@@ -633,8 +619,7 @@ int32_t UsbService::RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe,
{
int32_t ret = UsbdClient::GetInstance().RegBulkCallback(devInfo, pipe, cb);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d RegBulkCallback error ret:%{public}d", __func__, __LINE__,
ret);
USB_HILOGE(MODULE_USB_SERVICE, "RegBulkCallback error ret:%{public}d", ret);
}
return ret;
}
@@ -643,8 +628,7 @@ int32_t UsbService::UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe
{
int32_t ret = UsbdClient::GetInstance().UnRegBulkCallback(devInfo, pipe);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d UnRegBulkCallback error ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "UnRegBulkCallback error ret:%{public}d", ret);
}
return ret;
}
@@ -652,12 +636,12 @@ int32_t UsbService::UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe
int32_t UsbService::BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
{
if (ashmem == nullptr) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkRead error ashmem", __func__, __LINE__);
USB_HILOGE(MODULE_USB_SERVICE, "BulkRead error ashmem");
return UEC_SERVICE_INVALID_VALUE;
}
int32_t ret = UsbdClient::GetInstance().BulkRead(devInfo, pipe, ashmem);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkRead error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "BulkRead error ret:%{public}d", ret);
}
return ret;
}
@@ -665,12 +649,12 @@ int32_t UsbService::BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<As
int32_t UsbService::BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
{
if (ashmem == nullptr) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkWrite error ashmem", __func__, __LINE__);
USB_HILOGE(MODULE_USB_SERVICE, "BulkWrite error ashmem");
return UEC_SERVICE_INVALID_VALUE;
}
int32_t ret = UsbdClient::GetInstance().BulkWrite(devInfo, pipe, ashmem);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkWrite error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_SERVICE, "BulkWrite error ret:%{public}d", ret);
}
return ret;
}
@@ -679,8 +663,7 @@ int32_t UsbService::BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
{
int32_t ret = UsbdClient::GetInstance().BulkCancel(devInfo, pipe);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_SERVICE, "%{public}s:%{public}d BulkCancel error ret:%{public}d", __func__, __LINE__,
ret);
USB_HILOGE(MODULE_USB_SERVICE, "BulkCancel error ret:%{public}d", ret);
}
return ret;
}
services/native/src/usb_service_subscriber.cpp
+3 -4
View File
@@ -87,8 +87,8 @@ int32_t UsbServiceSubscriber::DeviceEvent(const UsbInfo &info)
int32_t status = info.getDevInfoStatus();
int32_t ret = UEC_OK;
Want want;
USB_HILOGW(MODULE_USBD, "%{public}s:%{public}d status:%{public}d bus:%{public}d dev:%{public}d", __func__, __LINE__,
status, info.getDevInfoBusNum(), info.getDevInfoDevNum());
USB_HILOGW(MODULE_USBD, "status:%{public}d bus:%{public}d dev:%{public}d", status, info.getDevInfoBusNum(),
info.getDevInfoDevNum());
if (Invoking(info, want) == -1) {
return ret;
@@ -114,8 +114,7 @@ int32_t UsbServiceSubscriber::DeviceEvent(const UsbInfo &info)
}
int32_t busNum = info.getDevInfoBusNum();
int32_t devAddr = info.getDevInfoDevNum();
USB_HILOGW(MODULE_USBD, "%{public}s:%{public}d status:%{public}d bus:%{public}d dev:%{public}d", __func__, __LINE__,
status, busNum, devAddr);
USB_HILOGW(MODULE_USBD, "status:%{public}d bus:%{public}d dev:%{public}d", status, busNum, devAddr);
auto pms = DelayedSpSingleton<UsbService>::GetInstance();
if (pms == nullptr) {
USB_HILOGE(MODULE_USB_SERVICE, "failed to GetInstance");
services/zidl/src/usb_srv_proxy.cpp
+84 -115
View File
@@ -13,8 +13,6 @@
* limitations under the License.
*/
#include <map>
#include <sstream>
#include "ipc_types.h"
#include "message_parcel.h"
#include "securec.h"
@@ -41,14 +39,14 @@ int32_t UsbServerProxy::SetBufferMessage(MessageParcel &data, const std::vector<
}
if (!data.WriteUint32(length)) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed length:%{public}u", __func__, __LINE__, length);
USB_HILOGE(MODULE_USBD, "write length failed:%{public}u", length);
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
if ((ptr) && (length > 0) && !data.WriteBuffer((const void *)ptr, length)) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed length:%{public}u", __func__, __LINE__, length);
USB_HILOGE(MODULE_USBD, "write buffer failed length:%{public}u", length);
return UEC_SERVICE_WRITE_PARCEL_ERROR;
} else {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d success length:%{public}u", __func__, __LINE__, length);
USB_HILOGE(MODULE_USBD, "success length:%{public}u", length);
}
return UEC_OK;
}
@@ -58,17 +56,17 @@ int32_t UsbServerProxy::GetBufferMessage(MessageParcel &data, std::vector<uint8_
uint32_t dataSize = 0;
bufferData.clear();
if (!data.ReadUint32(dataSize)) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed", __func__, __LINE__);
USB_HILOGE(MODULE_USBD, "read dataSize failed");
return UEC_SERVICE_READ_PARCEL_ERROR;
}
if (dataSize == 0) {
USB_HILOGI(MODULE_USBD, "%{public}s:%{public}d size:%{public}u", __func__, __LINE__, dataSize);
USB_HILOGI(MODULE_USBD, "invalid size:%{public}u", dataSize);
return UEC_OK;
}
const uint8_t *readData = data.ReadUnpadBuffer(dataSize);
if (readData == nullptr) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed size:%{public}u", __func__, __LINE__, dataSize);
USB_HILOGE(MODULE_USBD, "failed size:%{public}u", dataSize);
return UEC_SERVICE_READ_PARCEL_ERROR;
}
std::vector<uint8_t> tdata(readData, readData + dataSize);
@@ -81,7 +79,7 @@ int32_t UsbServerProxy::GetDevices(std::vector<UsbDevice> &deviceList)
int32_t ret;
sptr<IRemoteObject> remote = Remote();
if (remote == nullptr) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s remote is failed", __func__);
USB_HILOGE(MODULE_USB_INNERKIT, "remote is failed");
return ERR_INVALID_VALUE;
}
MessageParcel data;
@@ -89,13 +87,13 @@ int32_t UsbServerProxy::GetDevices(std::vector<UsbDevice> &deviceList)
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_INVALID_VALUE;
}
ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_DEVICES), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s failed code: %{public}d", __func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed code: %{public}d", ret);
return ret;
}
ret = GetDeviceListMessageParcel(reply, deviceList);
@@ -159,12 +157,12 @@ int32_t UsbServerProxy::GetDeviceMessageParcel(MessageParcel &data, UsbDevice &d
data.ReadString(tstr);
devInfo.SetmSerial(tstr);
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d devName:%{public}s Bus:%{public}d dev:%{public}d ", __func__,
__LINE__, devInfo.GetName().c_str(), devInfo.GetBusNum(), devInfo.GetDevAddr());
USB_HILOGE(MODULE_USB_INNERKIT, "devName:%{public}s Bus:%{public}d dev:%{public}d ", devInfo.GetName().c_str(),
devInfo.GetBusNum(), devInfo.GetDevAddr());
std::vector<USBConfig> configs;
GetDeviceConfigsMessageParcel(data, configs);
devInfo.SetConfigs(configs);
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s ToString : %{public}s", __func__, devInfo.ToString().c_str());
USB_HILOGE(MODULE_USB_INNERKIT, "ToString : %{public}s", devInfo.ToString().c_str());
return UEC_OK;
}
@@ -194,7 +192,7 @@ int32_t UsbServerProxy::GetDeviceConfigsMessageParcel(MessageParcel &data, std::
GetDeviceInterfacesMessageParcel(data, interfaces);
config.SetInterfaces(interfaces);
configs.push_back(config);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, config.ToString().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "devInfo=%{public}s", config.ToString().c_str());
}
return UEC_OK;
@@ -232,7 +230,7 @@ int32_t UsbServerProxy::GetDeviceInterfacesMessageParcel(MessageParcel &data, st
}
interface.SetEndpoints(eps);
interfaces.push_back(interface);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, interface.ToString().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "devInfo=%{public}s", interface.ToString().c_str());
}
return UEC_OK;
}
@@ -253,7 +251,7 @@ int32_t UsbServerProxy::GetDeviceEndpointsMessageParcel(MessageParcel &data, std
data.ReadInt32(tmp);
ep.SetMaxPacketSize(tmp);
eps.push_back(ep);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, ep.ToString().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "devInfo=%{public}s", ep.ToString().c_str());
}
return UEC_OK;
}
@@ -266,15 +264,14 @@ int32_t UsbServerProxy::OpenDevice(uint8_t busNum, uint8_t devAddr)
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
SetDeviceMessage(data, busNum, devAddr);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_OPEN_DEVICE), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %{public}d",
__func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
return ret;
}
return ret;
@@ -288,15 +285,14 @@ bool UsbServerProxy::HasRight(std::string deviceName)
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, false);
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return false;
}
WRITE_PARCEL_WITH_RET(data, String, deviceName, false);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_HAS_RIGHT), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %{public}d",
__func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
return false;
}
@@ -314,14 +310,13 @@ int32_t UsbServerProxy::RequestRight(std::string deviceName)
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
WRITE_PARCEL_WITH_RET(data, String, deviceName, UEC_INTERFACE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REQUEST_RIGHT), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %{public}d",
__func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
}
return ret;
}
@@ -334,14 +329,13 @@ int32_t UsbServerProxy::RemoveRight(std::string deviceName)
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
WRITE_PARCEL_WITH_RET(data, String, deviceName, UEC_INTERFACE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REMOVE_RIGHT), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
}
return ret;
}
@@ -356,15 +350,14 @@ int32_t UsbServerProxy::GetCurrentFunctions(int32_t &funcs)
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
int32_t ret =
remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_CURRENT_FUNCTIONS), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_SERVICE, "SendRequest is failed, error code: %d", ret);
return ret;
}
READ_PARCEL_WITH_RET(reply, Int32, funcs, UEC_INTERFACE_READ_PARCEL_ERROR);
@@ -381,15 +374,14 @@ int32_t UsbServerProxy::SetCurrentFunctions(int32_t funcs)
MessageParcel reply;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
WRITE_PARCEL_WITH_RET(data, Int32, funcs, UEC_INTERFACE_WRITE_PARCEL_ERROR);
int32_t ret =
remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_SET_CURRENT_FUNCTIONS), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_SERVICE, "SendRequest is failed, error code: %d", ret);
}
return ret;
}
@@ -403,15 +395,14 @@ int32_t UsbServerProxy::UsbFunctionsFromString(std::string_view funcs)
MessageParcel reply;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
WRITE_PARCEL_WITH_RET(data, String, std::string { funcs }, UEC_INTERFACE_WRITE_PARCEL_ERROR);
int32_t ret =
remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_USB_FUNCTIONS_FROM_STRING), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_SERVICE, "SendRequest is failed, error code: %d", ret);
return UEC_INTERFACE_INVALID_VALUE;
}
int32_t result = 0;
@@ -430,15 +421,14 @@ std::string UsbServerProxy::UsbFunctionsToString(int32_t funcs)
RETURN_IF_WITH_RET(remote == nullptr, INVALID_STRING_VALUE);
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_USB_SERVICE, "write descriptor failed!");
return INVALID_STRING_VALUE;
}
WRITE_PARCEL_WITH_RET(data, Int32, funcs, INVALID_STRING_VALUE);
int32_t ret =
remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_USB_FUNCTIONS_TO_STRING), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_SERVICE, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_SERVICE, "SendRequest is failed, error code: %d", ret);
return INVALID_STRING_VALUE;
}
std::string result;
@@ -455,13 +445,12 @@ int32_t UsbServerProxy::GetPorts(std::vector<UsbPort> &ports)
MessageParcel reply;
RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_PORTS), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
return ret;
}
int32_t size;
@@ -502,14 +491,13 @@ int32_t UsbServerProxy::GetSupportedModes(int32_t portId, int32_t &supportedMode
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
WRITE_PARCEL_WITH_RET(data, Int32, portId, UEC_INTERFACE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_SUPPORTED_MODES), data, reply, option);
if (ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
return ret;
}
READ_PARCEL_WITH_RET(reply, Int32, supportedModes, UEC_INTERFACE_READ_PARCEL_ERROR);
@@ -524,7 +512,7 @@ int32_t UsbServerProxy::SetPortRole(int32_t portId, int32_t powerRole, int32_t d
sptr<IRemoteObject> remote = Remote();
RETURN_IF_WITH_RET(remote == nullptr, UEC_INTERFACE_INVALID_VALUE);
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return UEC_INTERFACE_WRITE_PARCEL_ERROR;
}
WRITE_PARCEL_WITH_RET(data, Int32, portId, UEC_INTERFACE_WRITE_PARCEL_ERROR);
@@ -532,8 +520,7 @@ int32_t UsbServerProxy::SetPortRole(int32_t portId, int32_t powerRole, int32_t d
WRITE_PARCEL_WITH_RET(data, Int32, dataRole, UEC_INTERFACE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_SET_PORT_ROLE), data, reply, option);
if (ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
return ret;
}
return ret;
@@ -547,7 +534,7 @@ int32_t UsbServerProxy::ClaimInterface(uint8_t busNum, uint8_t devAddr, uint8_t
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, busNum, devAddr);
@@ -555,8 +542,7 @@ int32_t UsbServerProxy::ClaimInterface(uint8_t busNum, uint8_t devAddr, uint8_t
WRITE_PARCEL_WITH_RET(data, Uint8, force, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_CLAIM_INTERFACE), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %{public}d",
__func__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %{public}d", ret);
return ret;
}
return ret;
@@ -570,15 +556,14 @@ int32_t UsbServerProxy::ReleaseInterface(uint8_t busNum, uint8_t devAddr, uint8_
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, busNum, devAddr);
WRITE_PARCEL_WITH_RET(data, Uint8, interface, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_RELEASE_INTERFACE), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
}
return ret;
}
@@ -591,7 +576,7 @@ int32_t UsbServerProxy::BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe,
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -600,17 +585,15 @@ int32_t UsbServerProxy::BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe,
WRITE_PARCEL_WITH_RET(data, Int32, timeOut, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_TRANSFER_READ), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s SendRequest is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SendRequest is failed, error code: %d", ret);
return ret;
}
ret = GetBufferMessage(reply, bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "UsbServerProxy::%{public}s get buffer is failed, error code: %d", __func__,
ret);
USB_HILOGE(MODULE_USB_INNERKIT, "get buffer is failed, error code: %d", ret);
return ret;
}
USB_HILOGI(MODULE_USBD, "%{public}s Set buffer message. length = %{public}zu", __func__, bufferData.size());
USB_HILOGI(MODULE_USBD, "Set buffer message. length = %{public}zu", bufferData.size());
return ret;
}
int32_t UsbServerProxy::BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe,
@@ -622,7 +605,7 @@ int32_t UsbServerProxy::BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -631,14 +614,12 @@ int32_t UsbServerProxy::BulkTransferWrite(const UsbDev &dev, const UsbPipe &pipe
WRITE_PARCEL_WITH_RET(data, Int32, timeOut, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = SetBufferMessage(data, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d SetBufferMessage ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "SetBufferMessage ret:%{public}d", ret);
return ret;
}
ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_TRANSFER_WRITE), data, reply, option);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d SendRequest ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "SendRequest ret:%{public}d", ret);
}
return ret;
}
@@ -652,7 +633,7 @@ int32_t UsbServerProxy::ControlTransfer(const UsbDev &dev, const UsbCtrlTransfer
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return UEC_SERVICE_INNER_ERR;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -663,25 +644,22 @@ int32_t UsbServerProxy::ControlTransfer(const UsbDev &dev, const UsbCtrlTransfer
WRITE_PARCEL_WITH_RET(data, Int32, ctrl.timeout, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = SetBufferMessage(data, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d write failed! len:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "write failed! len:%{public}d", ret);
return ret;
}
bool isWrite = ((ctrl.requestType & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT);
ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_CONTROL_TRANSFER), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d USB_FUN_CONTROL_TRANSFER ret:%{public}d",
__func__, __LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "USB_FUN_CONTROL_TRANSFER ret:%{public}d", ret);
return ret;
}
if (!isWrite) {
ret = GetBufferMessage(reply, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d Get buffer message error. ret = %{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USBD, "Get buffer message error. ret = %{public}d", ret);
return ret;
}
USB_HILOGI(MODULE_USBD, "%{public}s Get buffer message. length = %{public}zu", __func__, bufferData.size());
USB_HILOGI(MODULE_USBD, "Get buffer message. length = %{public}zu", bufferData.size());
}
return UEC_OK;
}
@@ -693,15 +671,14 @@ int32_t UsbServerProxy::SetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, busNum, devAddr);
WRITE_PARCEL_WITH_RET(data, Uint8, configIndex, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_SET_ACTIVE_CONFIG), data, reply, option);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d USB_FUN_SET_ACTIVE_CONFIG ret:%{public}d",
__func__, __LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "USB_FUN_SET_ACTIVE_CONFIG ret:%{public}d", ret);
}
return ret;
}
@@ -713,14 +690,13 @@ int32_t UsbServerProxy::GetActiveConfig(uint8_t busNum, uint8_t devAddr, uint8_t
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, busNum, devAddr);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_GET_ACTIVE_CONFIG), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d USB_FUN_GET_ACTIVE_CONFIG ret:%{public}d",
__func__, __LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "USB_FUN_GET_ACTIVE_CONFIG ret:%{public}d", ret);
return ret;
}
READ_PARCEL_WITH_RET(reply, Uint8, configIndex, UEC_SERVICE_WRITE_PARCEL_ERROR);
@@ -734,7 +710,7 @@ int32_t UsbServerProxy::SetInterface(uint8_t busNum, uint8_t devAddr, uint8_t in
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, busNum, devAddr);
@@ -742,8 +718,7 @@ int32_t UsbServerProxy::SetInterface(uint8_t busNum, uint8_t devAddr, uint8_t in
WRITE_PARCEL_WITH_RET(data, Uint8, altIndex, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_SET_INTERFACE), data, reply, option);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d USB_FUN_SET_INTERFACE ret:%{public}d",
__func__, __LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "USB_FUN_SET_INTERFACE ret:%{public}d", ret);
}
return ret;
}
@@ -755,7 +730,7 @@ int32_t UsbServerProxy::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::v
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, busNum, devAddr);
@@ -763,8 +738,7 @@ int32_t UsbServerProxy::GetRawDescriptor(uint8_t busNum, uint8_t devAddr, std::v
if (ret == UEC_OK) {
ret = GetBufferMessage(reply, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d get failed ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "get failed ret:%{public}d", ret);
}
}
return ret;
@@ -778,7 +752,7 @@ int32_t UsbServerProxy::GetFileDescriptor(uint8_t busNum, uint8_t devAddr, int32
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, busNum, devAddr);
@@ -798,7 +772,7 @@ int32_t UsbServerProxy::RequestQueue(const UsbDev &dev, const UsbPipe &pipe, con
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s get descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "get descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -807,21 +781,19 @@ int32_t UsbServerProxy::RequestQueue(const UsbDev &dev, const UsbPipe &pipe, con
int32_t ret = UsbServerProxy::SetBufferMessage(data, clientData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d setBuffer failed ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "set clientData failed ret:%{public}d", ret);
return ERR_INVALID_VALUE;
}
ret = UsbServerProxy::SetBufferMessage(data, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d setBuffer failed ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "setBuffer failed ret:%{public}d", ret);
return ERR_INVALID_VALUE;
}
ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REQUEST_QUEUE), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d queue failed!", __func__, __LINE__);
USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
return ret;
}
return ret;
@@ -837,7 +809,7 @@ int32_t UsbServerProxy::RequestWait(const UsbDev &dev, int32_t timeOut, std::vec
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s get descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "get descriptor failed!");
return ERR_ENOUGH_DATA;
}
@@ -845,22 +817,19 @@ int32_t UsbServerProxy::RequestWait(const UsbDev &dev, int32_t timeOut, std::vec
WRITE_PARCEL_WITH_RET(data, Int32, timeOut, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REQUEST_WAIT), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d queue failed! ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "queue failed! ret:%{public}d", ret);
return ret;
}
ret = UsbServerProxy::GetBufferMessage(reply, clientData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d get clientData failed! ret:%{public}d",
__func__, __LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "get clientData failed! ret:%{public}d", ret);
return ret;
}
ret = UsbServerProxy::GetBufferMessage(reply, bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s:%{public}d get buffer failed! ret:%{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_INNERKIT, "get buffer failed! ret:%{public}d", ret);
return ret;
}
@@ -876,7 +845,7 @@ int32_t UsbServerProxy::RequestCancel(uint8_t busNum, uint8_t devAddr, uint8_t i
MessageParcel reply;
MessageOption option;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s get descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "get descriptor failed!");
return ERR_ENOUGH_DATA;
}
@@ -885,7 +854,7 @@ int32_t UsbServerProxy::RequestCancel(uint8_t busNum, uint8_t devAddr, uint8_t i
WRITE_PARCEL_WITH_RET(data, Uint8, endpointId, UEC_SERVICE_WRITE_PARCEL_ERROR);
ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REQUEST_CANCEL), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s request cancel failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "request cancel failed!");
}
return ret;
@@ -899,14 +868,14 @@ int32_t UsbServerProxy::Close(uint8_t busNum, uint8_t devAddr)
MessageParcel data;
MessageParcel reply;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s get descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "get descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, busNum, devAddr);
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_CLOSE_DEVICE), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s queue failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "queue failed!");
return ret;
}
@@ -919,7 +888,7 @@ int32_t UsbServerProxy::RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe,
RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
MessageParcel data;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -930,7 +899,7 @@ int32_t UsbServerProxy::RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe,
MessageParcel reply;
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_REG_BULK_CALLBACK), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
return ret;
}
return ret;
@@ -942,7 +911,7 @@ int32_t UsbServerProxy::UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe
RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
MessageParcel data;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -952,7 +921,7 @@ int32_t UsbServerProxy::UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe
MessageParcel reply;
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_UNREG_BULK_CALLBACK), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
return ret;
}
return ret;
@@ -964,7 +933,7 @@ int32_t UsbServerProxy::BulkRead(const UsbDev &dev, const UsbPipe &pipe, sptr<As
RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
MessageParcel data;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -975,7 +944,7 @@ int32_t UsbServerProxy::BulkRead(const UsbDev &dev, const UsbPipe &pipe, sptr<As
MessageParcel reply;
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_AYSNC_READ), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
return ret;
}
return ret;
@@ -987,7 +956,7 @@ int32_t UsbServerProxy::BulkWrite(const UsbDev &dev, const UsbPipe &pipe, sptr<A
RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
MessageParcel data;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -998,7 +967,7 @@ int32_t UsbServerProxy::BulkWrite(const UsbDev &dev, const UsbPipe &pipe, sptr<A
MessageParcel reply;
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_AYSNC_WRITE), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
return ret;
}
return ret;
@@ -1010,7 +979,7 @@ int32_t UsbServerProxy::BulkCancel(const UsbDev &dev, const UsbPipe &pipe)
RETURN_IF_WITH_RET(remote == nullptr, UEC_SERVICE_INNER_ERR);
MessageParcel data;
if (!data.WriteInterfaceToken(UsbServerProxy::GetDescriptor())) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s write descriptor failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
return ERR_ENOUGH_DATA;
}
SetDeviceMessage(data, dev.busNum, dev.devAddr);
@@ -1020,7 +989,7 @@ int32_t UsbServerProxy::BulkCancel(const UsbDev &dev, const UsbPipe &pipe)
MessageParcel reply;
int32_t ret = remote->SendRequest(static_cast<int32_t>(IUsbSrv::USB_FUN_BULK_AYSNC_CANCEL), data, reply, option);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_INNERKIT, "UsbServerProxy::%{public}s SendRequest failed!", __func__);
USB_HILOGE(MODULE_INNERKIT, "SendRequest failed!");
return ret;
}
return ret;
services/zidl/src/usb_srv_stub.cpp
+36 -43
View File
@@ -13,9 +13,6 @@
* limitations under the License.
*/
#include <map>
#include <sstream>
#include <vector>
#include "message_parcel.h"
#include "securec.h"
#include "usb_common.h"
@@ -45,11 +42,11 @@ int32_t UsbServerStub::SetBufferMessage(MessageParcel &data, const std::vector<u
}
if (!data.WriteUint32(length)) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed length:%{public}u", __func__, __LINE__, length);
USB_HILOGE(MODULE_USBD, "write length failed length:%{public}u", length);
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
if ((ptr) && (length > 0) && !data.WriteBuffer((const void *)ptr, length)) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed length:%{public}u", __func__, __LINE__, length);
USB_HILOGE(MODULE_USBD, "writer buffer failed length:%{public}u", length);
return UEC_SERVICE_WRITE_PARCEL_ERROR;
}
return UEC_OK;
@@ -60,17 +57,17 @@ int32_t UsbServerStub::GetBufferMessage(MessageParcel &data, std::vector<uint8_t
uint32_t dataSize = 0;
bufferData.clear();
if (!data.ReadUint32(dataSize)) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed", __func__, __LINE__);
USB_HILOGE(MODULE_USBD, "read dataSize failed");
return UEC_SERVICE_READ_PARCEL_ERROR;
}
if (dataSize == 0) {
USB_HILOGW(MODULE_USBD, "%{public}s:%{public}d size:%{public}u", __func__, __LINE__, dataSize);
USB_HILOGW(MODULE_USBD, "size:%{public}u", dataSize);
return UEC_OK;
}
const uint8_t *readData = data.ReadUnpadBuffer(dataSize);
if (readData == nullptr) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d failed size:%{public}u", __func__, __LINE__, dataSize);
USB_HILOGE(MODULE_USBD, "failed size:%{public}u", dataSize);
return UEC_SERVICE_READ_PARCEL_ERROR;
}
std::vector<uint8_t> tdata(readData, readData + dataSize);
@@ -378,12 +375,12 @@ int32_t UsbServerStub::DoBulkTransferRead(MessageParcel &data, MessageParcel &re
const UsbPipe tmpPipe = {interface, endpoint};
int32_t ret = BulkTransferRead(tmpDev, tmpPipe, bufferData, timeOut);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "read failed ret:%{public}d", ret);
return ret;
}
ret = SetBufferMessage(reply, bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "set buffer failed ret:%{public}d", ret);
}
return ret;
}
@@ -405,13 +402,12 @@ int32_t UsbServerStub::DoBulkTransferWrite(MessageParcel &data, MessageParcel &r
const UsbPipe tmpPipe = {interface, endpoint};
int32_t ret = GetBufferMessage(data, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "GetBufferMessage failedret:%{public}d", ret);
return ret;
}
ret = BulkTransferWrite(tmpDev, tmpPipe, bufferData, timeOut);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d BulkTransferWrite error ret:%{public}d", __func__, __LINE__,
ret);
USB_HILOGE(MODULE_USBD, "BulkTransferWrite error ret:%{public}d", ret);
}
return ret;
}
@@ -436,7 +432,7 @@ int32_t UsbServerStub::DoControlTransfer(MessageParcel &data, MessageParcel &rep
std::vector<uint8_t> bufferData;
int32_t ret = GetBufferMessage(data, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d get error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "get error ret:%{public}d", ret);
return ret;
}
@@ -445,15 +441,14 @@ int32_t UsbServerStub::DoControlTransfer(MessageParcel &data, MessageParcel &rep
const UsbCtrlTransfer tctrl = {requestType, request, value, index, timeOut};
ret = ControlTransfer(tmpDev, tctrl, bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ControlTransfer error ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "ControlTransfer error ret:%{public}d", ret);
return ret;
}
if (!bWrite) {
ret = SetBufferMessage(reply, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d Set buffer message error length = %{public}d", __func__,
__LINE__, ret);
USB_HILOGE(MODULE_USBD, "Set buffer message error length = %{public}d", ret);
}
}
@@ -509,10 +504,10 @@ int32_t UsbServerStub::DoGetRawDescriptor(MessageParcel &data, MessageParcel &re
if (UEC_OK == ret) {
ret = SetBufferMessage(reply, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "SetBufferMessage failed ret:%{public}d", ret);
}
} else {
USB_HILOGW(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGW(MODULE_USBD, "GetRawDescriptor failed ret:%{public}d", ret);
}
return ret;
}
@@ -528,7 +523,7 @@ int32_t UsbServerStub::DoGetFileDescriptor(MessageParcel &data, MessageParcel &r
if (UEC_OK == ret) {
WRITE_PARCEL_WITH_RET(reply, Int32, fd, UEC_SERVICE_WRITE_PARCEL_ERROR);
} else {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
}
return ret;
}
@@ -548,19 +543,19 @@ int32_t UsbServerStub::DoRequestQueue(MessageParcel &data, MessageParcel &reply,
int32_t ret = UsbServerStub::GetBufferMessage(data, clientData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "GetBufferMessage failed ret:%{public}d", ret);
return ret;
}
ret = UsbServerStub::GetBufferMessage(data, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "GetBufferMessage failed ret:%{public}d", ret);
return ret;
}
const UsbDev tmpDev = {busNum, devAddr};
const UsbPipe tmpPipe = {ifId, endpoint};
ret = RequestQueue(tmpDev, tmpPipe, clientData, bufferData);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "GetBufferMessage failed ret:%{public}d", ret);
}
return ret;
}
@@ -579,19 +574,19 @@ int32_t UsbServerStub::DoRequestWait(MessageParcel &data, MessageParcel &reply,
const UsbDev tmpDev = {busNum, devAddr};
int32_t ret = RequestWait(tmpDev, timeOut, clientData, bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "RequestWait failed ret:%{public}d", ret);
return ret;
}
ret = SetBufferMessage(reply, clientData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "Set clientData failed ret:%{public}d", ret);
return ret;
}
ret = SetBufferMessage(reply, bufferData);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "Set bufferData failed ret:%{public}d", ret);
return ret;
}
return ret;
@@ -609,7 +604,7 @@ int32_t UsbServerStub::DoRequestCancel(MessageParcel &data, MessageParcel &reply
READ_PARCEL_WITH_RET(data, Uint8, endpointId, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = RequestCancel(busNum, devAddr, interfaceId, endpointId);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret:%{public}d", ret);
}
return ret;
}
@@ -622,7 +617,7 @@ int32_t UsbServerStub::DoClose(MessageParcel &data, MessageParcel &reply, Messag
READ_PARCEL_WITH_RET(data, Uint8, devAddr, UEC_SERVICE_WRITE_PARCEL_ERROR);
int32_t ret = Close(busNum, devAddr);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "failed ret:%{public}d", ret);
}
return ret;
}
@@ -632,13 +627,13 @@ int32_t UsbServerStub::DoGetDevices(MessageParcel &data, MessageParcel &reply, M
std::vector<UsbDevice> deviceList;
int32_t ret = GetDevices(deviceList);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_SERVICE, "%{public}s: failed ret = %{public}d", __func__, ret);
USB_HILOGE(MODULE_SERVICE, "GetDevices failed ret = %{public}d", ret);
return ret;
}
USB_HILOGE(MODULE_SERVICE, "%{public}s: list size = %{public}zu", __func__, deviceList.size());
USB_HILOGI(MODULE_SERVICE, "list size = %{public}zu", deviceList.size());
ret = SetDeviceListMessageParcel(deviceList, reply);
if (UEC_OK != ret) {
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d failed ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USB_INNERKIT, "SetDeviceListMessageParcel failed ret:%{public}d", ret);
}
return ret;
}
@@ -678,10 +673,8 @@ int32_t UsbServerStub::SetDeviceMessageParcel(UsbDevice &devInfo, MessageParcel
WRITE_PARCEL_WITH_RET(data, String, devInfo.GetProductName(), UEC_SERVICE_WRITE_PARCEL_ERROR);
WRITE_PARCEL_WITH_RET(data, String, devInfo.GetVersion(), UEC_SERVICE_WRITE_PARCEL_ERROR);
WRITE_PARCEL_WITH_RET(data, String, devInfo.GetmSerial(), UEC_SERVICE_WRITE_PARCEL_ERROR);
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d devName:%{public}s Bus:%{public}d dev:%{public}d ", __func__,
__LINE__, devInfo.GetName().c_str(), devInfo.GetBusNum(), devInfo.GetDevAddr());
USB_HILOGE(MODULE_USB_INNERKIT, "%{public}s:%{public}d devInfo:%{public}s", __func__, __LINE__,
devInfo.ToString().c_str());
USB_HILOGE(MODULE_USB_INNERKIT, "devInfo:%{public}s", devInfo.ToString().c_str());
WRITE_PARCEL_WITH_RET(data, Int32, devInfo.GetConfigCount(), UEC_SERVICE_WRITE_PARCEL_ERROR);
return SetDeviceConfigsMessageParcel(devInfo.GetConfigs(), data);
}
@@ -698,7 +691,7 @@ int32_t UsbServerStub::SetDeviceConfigsMessageParcel(std::vector<USBConfig> &con
WRITE_PARCEL_WITH_RET(data, String, config.GetName(), UEC_SERVICE_WRITE_PARCEL_ERROR);
WRITE_PARCEL_WITH_RET(data, Uint32, config.GetInterfaceCount(), UEC_SERVICE_WRITE_PARCEL_ERROR);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, config.ToString().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "devInfo=%{public}s", config.ToString().c_str());
int32_t ret = SetDeviceInterfacesMessageParcel(config.GetInterfaces(), data);
if (ret) {
return ret;
@@ -721,7 +714,7 @@ int32_t UsbServerStub::SetDeviceInterfacesMessageParcel(std::vector<UsbInterface
WRITE_PARCEL_WITH_RET(data, String, interface.GetName(), UEC_SERVICE_WRITE_PARCEL_ERROR);
WRITE_PARCEL_WITH_RET(data, Int32, interface.GetEndpointCount(), UEC_SERVICE_WRITE_PARCEL_ERROR);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, interface.ToString().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "interface=%{public}s", interface.ToString().c_str());
int32_t ret = SetDeviceEndpointsMessageParcel(interface.GetEndpoints(), data);
if (ret) {
return ret;
@@ -738,7 +731,7 @@ int32_t UsbServerStub::SetDeviceEndpointsMessageParcel(std::vector<USBEndpoint>
WRITE_PARCEL_WITH_RET(data, Int32, ep.GetAttributes(), UEC_SERVICE_WRITE_PARCEL_ERROR);
WRITE_PARCEL_WITH_RET(data, Int32, ep.GetInterval(), UEC_SERVICE_WRITE_PARCEL_ERROR);
WRITE_PARCEL_WITH_RET(data, Int32, ep.GetMaxPacketSize(), UEC_SERVICE_WRITE_PARCEL_ERROR);
USB_HILOGI(MODULE_USB_SERVICE, "%{public}s devInfo=%{public}s", __func__, ep.ToString().c_str());
USB_HILOGI(MODULE_USB_SERVICE, "ep=%{public}s", ep.ToString().c_str());
}
return UEC_OK;
}
@@ -758,7 +751,7 @@ int32_t UsbServerStub::DoRegBulkCallback(MessageParcel &data, MessageParcel &rep
const UsbPipe tmpPipe = {interface, endpoint};
int32_t ret = RegBulkCallback(tmpDev, tmpPipe, cb);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
return ret;
}
return ret;
@@ -778,7 +771,7 @@ int32_t UsbServerStub::DoUnRegBulkCallback(MessageParcel &data, MessageParcel &r
const UsbPipe tmpPipe = {interface, endpoint};
int32_t ret = UnRegBulkCallback(tmpDev, tmpPipe);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
return ret;
}
return ret;
@@ -799,7 +792,7 @@ int32_t UsbServerStub::DoBulkRead(MessageParcel &data, MessageParcel &reply, Mes
const UsbPipe tmpPipe = {interface, endpoint};
int32_t ret = BulkRead(tmpDev, tmpPipe, ashmem);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "BulkRead failed ret:%{public}d", ret);
return ret;
}
return ret;
@@ -820,7 +813,7 @@ int32_t UsbServerStub::DoBulkWrite(MessageParcel &data, MessageParcel &reply, Me
const UsbPipe tmpPipe = {interface, endpoint};
int32_t ret = BulkWrite(tmpDev, tmpPipe, ashmem);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
return ret;
}
return ret;
@@ -840,7 +833,7 @@ int32_t UsbServerStub::DoBulkCancel(MessageParcel &data, MessageParcel &reply, M
const UsbPipe tmpPipe = {interface, endpoint};
int32_t ret = BulkCancel(tmpDev, tmpPipe);
if (ret != UEC_OK) {
USB_HILOGE(MODULE_USBD, "%{public}s:%{public}d ret:%{public}d", __func__, __LINE__, ret);
USB_HILOGE(MODULE_USBD, "ret:%{public}d", ret);
return ret;
}
return ret;
utils/native/include/delayed_sp_singleton.h
+1 -1
View File
@@ -56,7 +56,7 @@ template <typename T> sptr<T> DelayedSpSingleton<T>::GetInstance()
if (instance_ == nullptr) {
instance_ = new(std::nothrow) T();
if (instance_ == nullptr) {
USB_HILOGI(MODULE_USB_SERVICE, " %{public}s:%{public}d get instance failed\n", __func__, __LINE__);
USB_HILOGI(MODULE_USB_SERVICE, "get instance failed\n");
}
}